aiforge/vendor/github.com/microcosm-cc/bluemonday/handlers.go

// Copyright (c) 2019, David Kitchen <david@buro9.com>
//
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// * Redistributions of source code must retain the above copyright notice, this
//   list of conditions and the following disclaimer.
//
// * Redistributions in binary form must reproduce the above copyright notice,
//   this list of conditions and the following disclaimer in the documentation
//   and/or other materials provided with the distribution.
//
// * Neither the name of the organisation (Microcosm) nor the names of its
//   contributors may be used to endorse or promote products derived from
//   this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
package bluemonday

import (
	"regexp"
	"strings"
)

var (
	defaultStyleHandlers = map[string]func(string) bool{
		"align-content":              AlignContentHandler,
		"align-items":                AlignItemsHandler,
		"align-self":                 AlignSelfHandler,
		"all":                        AllHandler,
		"animation":                  AnimationHandler,
		"animation-delay":            AnimationDelayHandler,
		"animation-direction":        AnimationDirectionHandler,
		"animation-duration":         AnimationDurationHandler,
		"animation-fill-mode":        AnimationFillModeHandler,
		"animation-iteration-count":  AnimationIterationCountHandler,
		"animation-name":             AnimationNameHandler,
		"animation-play-state":       AnimationPlayStateHandler,
		"animation-timing-function":  TimingFunctionHandler,
		"backface-visibility":        BackfaceVisibilityHandler,
		"background":                 BackgroundHandler,
		"background-attachment":      BackgroundAttachmentHandler,
		"background-blend-mode":      BackgroundBlendModeHandler,
		"background-clip":            BackgroundClipHandler,
		"background-color":           ColorHandler,
		"background-image":           ImageHandler,
		"background-origin":          BackgroundOriginHandler,
		"background-position":        BackgroundPositionHandler,
		"background-repeat":          BackgroundRepeatHandler,
		"background-size":            BackgroundSizeHandler,
		"border":                     BorderHandler,
		"border-bottom":              BorderSideHandler,
		"border-bottom-color":        ColorHandler,
		"border-bottom-left-radius":  BorderSideRadiusHandler,
		"border-bottom-right-radius": BorderSideRadiusHandler,
		"border-bottom-style":        BorderSideStyleHandler,
		"border-bottom-width":        BorderSideWidthHandler,
		"border-collapse":            BorderCollapseHandler,
		"border-color":               ColorHandler,
		"border-image":               BorderImageHandler,
		"border-image-outset":        BorderImageOutsetHandler,
		"border-image-repeat":        BorderImageRepeatHandler,
		"border-image-slice":         BorderImageSliceHandler,
		"border-image-source":        ImageHandler,
		"border-image-width":         BorderImageWidthHandler,
		"border-left":                BorderSideHandler,
		"border-left-color":          ColorHandler,
		"border-left-style":          BorderSideStyleHandler,
		"border-left-width":          BorderSideWidthHandler,
		"border-radius":              BorderRadiusHandler,
		"border-right":               BorderSideHandler,
		"border-right-color":         ColorHandler,
		"border-right-style":         BorderSideStyleHandler,
		"border-right-width":         BorderSideWidthHandler,
		"border-spacing":             BorderSpacingHandler,
		"border-style":               BorderStyleHandler,
		"border-top":                 BorderSideHandler,
		"border-top-color":           ColorHandler,
		"border-top-left-radius":     BorderSideRadiusHandler,
		"border-top-right-radius":    BorderSideRadiusHandler,
		"border-top-style":           BorderSideStyleHandler,
		"border-top-width":           BorderSideWidthHandler,
		"border-width":               BorderWidthHandler,
		"bottom":                     SideHandler,
		"box-decoration-break":       BoxDecorationBreakHandler,
		"box-shadow":                 BoxShadowHandler,
		"box-sizing":                 BoxSizingHandler,
		"break-after":                BreakBeforeAfterHandler,
		"break-before":               BreakBeforeAfterHandler,
		"break-inside":               BreakInsideHandler,
		"caption-side":               CaptionSideHandler,
		"caret-color":                CaretColorHandler,
		"clear":                      ClearHandler,
		"clip":                       ClipHandler,
		"color":                      ColorHandler,
		"column-count":               ColumnCountHandler,
		"column-fill":                ColumnFillHandler,
		"column-gap":                 ColumnGapHandler,
		"column-rule":                ColumnRuleHandler,
		"column-rule-color":          ColorHandler,
		"column-rule-style":          BorderSideStyleHandler,
		"column-rule-width":          ColumnRuleWidthHandler,
		"column-span":                ColumnSpanHandler,
		"column-width":               ColumnWidthHandler,
		"columns":                    ColumnsHandler,
		"cursor":                     CursorHandler,
		"direction":                  DirectionHandler,
		"display":                    DisplayHandler,
		"empty-cells":                EmptyCellsHandler,
		"filter":                     FilterHandler,
		"flex":                       FlexHandler,
		"flex-basis":                 FlexBasisHandler,
		"flex-direction":             FlexDirectionHandler,
		"flex-flow":                  FlexFlowHandler,
		"flex-grow":                  FlexGrowHandler,
		"flex-shrink":                FlexGrowHandler,
		"flex-wrap":                  FlexWrapHandler,
		"float":                      FloatHandler,
		"font":                       FontHandler,
		"font-family":                FontFamilyHandler,
		"font-kerning":               FontKerningHandler,
		"font-language-override":     FontLanguageOverrideHandler,
		"font-size":                  FontSizeHandler,
		"font-size-adjust":           FontSizeAdjustHandler,
		"font-stretch":               FontStretchHandler,
		"font-style":                 FontStyleHandler,
		"font-synthesis":             FontSynthesisHandler,
		"font-variant":               FontVariantHandler,
		"font-variant-caps":          FontVariantCapsHandler,
		"font-variant-position":      FontVariantPositionHandler,
		"font-weight":                FontWeightHandler,
		"grid":                       GridHandler,
		"grid-area":                  GridAreaHandler,
		"grid-auto-columns":          GridAutoColumnsHandler,
		"grid-auto-flow":             GridAutoFlowHandler,
		"grid-auto-rows":             GridAutoColumnsHandler,
		"grid-column":                GridColumnHandler,
		"grid-column-end":            GridAxisStartEndHandler,
		"grid-column-gap":            LengthHandler,
		"grid-column-start":          GridAxisStartEndHandler,
		"grid-gap":                   GridGapHandler,
		"grid-row":                   GridRowHandler,
		"grid-row-end":               GridAxisStartEndHandler,
		"grid-row-gap":               LengthHandler,
		"grid-row-start":             GridAxisStartEndHandler,
		"grid-template":              GridTemplateHandler,
		"grid-template-areas":        GridTemplateAreasHandler,
		"grid-template-columns":      GridTemplateColumnsHandler,
		"grid-template-rows":         GridTemplateRowsHandler,
		"hanging-punctuation":        HangingPunctuationHandler,
		"height":                     HeightHandler,
		"hyphens":                    HyphensHandler,
		"image-rendering":            ImageRenderingHandler,
		"isolation":                  IsolationHandler,
		"justify-content":            JustifyContentHandler,
		"left":                       SideHandler,
		"letter-spacing":             LetterSpacingHandler,
		"line-break":                 LineBreakHandler,
		"line-height":                LineHeightHandler,
		"list-style":                 ListStyleHandler,
		"list-style-image":           ImageHandler,
		"list-style-position":        ListStylePositionHandler,
		"list-style-type":            ListStyleTypeHandler,
		"margin":                     MarginHandler,
		"margin-bottom":              MarginSideHandler,
		"margin-left":                MarginSideHandler,
		"margin-right":               MarginSideHandler,
		"margin-top":                 MarginSideHandler,
		"max-height":                 MaxHeightWidthHandler,
		"max-width":                  MaxHeightWidthHandler,
		"min-height":                 MinHeightWidthHandler,
		"min-width":                  MinHeightWidthHandler,
		"mix-blend-mode":             MixBlendModeHandler,
		"object-fit":                 ObjectFitHandler,
		"object-position":            ObjectPositionHandler,
		"opacity":                    OpacityHandler,
		"order":                      OrderHandler,
		"orphans":                    OrphansHandler,
		"outline":                    OutlineHandler,
		"outline-color":              ColorHandler,
		"outline-offset":             OutlineOffsetHandler,
		"outline-style":              OutlineStyleHandler,
		"outline-width":              OutlineWidthHandler,
		"overflow":                   OverflowHandler,
		"overflow-wrap":              OverflowWrapHandler,
		"overflow-x":                 OverflowXYHandler,
		"overflow-y":                 OverflowXYHandler,
		"padding":                    PaddingHandler,
		"padding-bottom":             PaddingSideHandler,
		"padding-left":               PaddingSideHandler,
		"padding-right":              PaddingSideHandler,
		"padding-top":                PaddingSideHandler,
		"page-break-after":           PageBreakBeforeAfterHandler,
		"page-break-before":          PageBreakBeforeAfterHandler,
		"page-break-inside":          PageBreakInsideHandler,
		"perspective":                PerspectiveHandler,
		"perspective-origin":         PerspectiveOriginHandler,
		"pointer-events":             PointerEventsHandler,
		"position":                   PositionHandler,
		"quotes":                     QuotesHandler,
		"resize":                     ResizeHandler,
		"right":                      SideHandler,
		"scroll-behavior":            ScrollBehaviorHandler,
		"tab-size":                   TabSizeHandler,
		"table-layout":               TableLayoutHandler,
		"text-align":                 TextAlignHandler,
		"text-align-last":            TextAlignLastHandler,
		"text-combine-upright":       TextCombineUprightHandler,
		"text-decoration":            TextDecorationHandler,
		"text-decoration-color":      ColorHandler,
		"text-decoration-line":       TextDecorationLineHandler,
		"text-decoration-style":      TextDecorationStyleHandler,
		"text-indent":                TextIndentHandler,
		"text-justify":               TextJustifyHandler,
		"text-orientation":           TextOrientationHandler,
		"text-overflow":              TextOverflowHandler,
		"text-shadow":                TextShadowHandler,
		"text-transform":             TextTransformHandler,
		"top":                        SideHandler,
		"transform":                  TransformHandler,
		"transform-origin":           TransformOriginHandler,
		"transform-style":            TransformStyleHandler,
		"transition":                 TransitionHandler,
		"transition-delay":           TransitionDelayHandler,
		"transition-duration":        TransitionDurationHandler,
		"transition-property":        TransitionPropertyHandler,
		"transition-timing-function": TimingFunctionHandler,
		"unicode-bidi":               UnicodeBidiHandler,
		"user-select":                UserSelectHandler,
		"vertical-align":             VerticalAlignHandler,
		"visibility":                 VisiblityHandler,
		"white-space":                WhiteSpaceHandler,
		"widows":                     OrphansHandler,
		"width":                      WidthHandler,
		"word-break":                 WordBreakHandler,
		"word-spacing":               WordSpacingHandler,
		"word-wrap":                  WordWrapHandler,
		"writing-mode":               WritingModeHandler,
		"z-index":                    ZIndexHandler,
	}
	colorValues = []string{"initial", "inherit", "aliceblue", "antiquewhite",
		"aqua", "aquamarine", "azure", "beige", "bisque", "black",
		"blanchedalmond", "blue", "blueviolet", "brown", "burlywood",
		"cadetblue", "chartreuse", "chocolate", "coral", "cornflowerblue",
		"cornsilk", "crimson", "cyan", "darkblue", "darkcyan", "darkgoldenrod",
		"darkgray", "darkgrey", "darkgreen", "darkkhaki", "darkmagenta",
		"darkolivegreen", "darkorange", "darkorchid", "darkred", "darksalmon",
		"darkseagreen", "darkslateblue", "darkslategrey", "darkslategray",
		"darkturquoise", "darkviolet", "deeppink", "deepskyblue", "dimgray",
		"dimgrey", "dodgerblue", "firebrick", "floralwhite", "forestgreen",
		"fuchsia", "gainsboro", "ghostwhite", "gold", "goldenrod", "gray",
		"grey", "green", "greenyellow", "honeydew", "hotpink", "indianred",
		"indigo", "ivory", "khaki", "lavender", "lavenderblush",
		"lemonchiffon", "lightblue", "lightcoral", "lightcyan",
		"lightgoldenrodyellow", "lightgray", "lightgrey", "lightgreen",
		"lightpink", "lightsalmon", "lightseagreen", "lightskyblue",
		"lightslategray", "lightslategrey", "lightsteeelblue", "lightyellow",
		"lime", "limegreen", "linen", "magenta", "maroon", "mediumaquamarine",
		"mediumblue", "mediumorchid", "mediumpurple", "mediumseagreen",
		"mediumslateblue", "mediumspringgreen", "mediumturquoise",
		"mediumvioletred", "midnightblue", "mintcream", "mistyrose",
		"moccasin", "navajowhite", "navy", "oldlace", "olive", "olivedrab",
		"orange", "orangered", "orchid", "palegoldenrod", "palegreen",
		"paleturquoise", "palevioletred", "papayawhip", "peachpuff", "peru",
		"pink", "plum", "powderblue", "purple", "rebeccapurple", "red",
		"rosybrown", "royalblue", "saddlebrown", "salmon", "sandybrown",
		"seagreen", "seashell", "sienna", "silver", "skyblue", "slateblue",
		"slategray", "slategrey", "snow", "springgreen", "steelblue", "tan",
		"teal", "thistle", "tomato", "turquoise", "violet", "wheat", "white",
		"whitesmoke", "yellow", "yellowgreen"}
)

func multiSplit(value string, seps ...string) []string {
	curArray := []string{value}
	for _, i := range seps {
		newArray := []string{}
		for _, j := range curArray {
			newArray = append(newArray, strings.Split(j, i)...)
		}
		curArray = newArray
	}
	return curArray
}

func recursiveCheck(value []string, funcs []func(string) bool) bool {
	for i := 0; i < len(value); i++ {
		tempVal := strings.Join(value[:i+1], " ")
		for _, j := range funcs {
			if j(tempVal) && (len(value[i+1:]) == 0 || recursiveCheck(value[i+1:], funcs)) {
				return true
			}
		}
	}
	return false
}

func in(value []string, arr []string) bool {
	for _, i := range value {
		foundString := false
		for _, j := range arr {
			if j == i {
				foundString = true
			}
		}
		if !foundString {
			return false
		}
	}
	return true
}

func splitValues(value string) []string {
	values := strings.Split(value, ",")
	for _, strippedValue := range values {
		strippedValue = strings.ToLower(strings.TrimSpace(strippedValue))
	}
	return values
}

func getDefaultHandler(attr string) func(string) bool {

	if defaultStyleHandlers[attr] != nil {
		return defaultStyleHandlers[attr]
	}
	return BaseHandler
}

func BaseHandler(value string) bool {
	return false
}

func AlignContentHandler(value string) bool {
	values := []string{"stretch", "center", "flex-start",
		"flex-end", "space-between", "space-around", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func AlignItemsHandler(value string) bool {
	values := []string{"stretch", "center", "flex-start",
		"flex-end", "baseline", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func AlignSelfHandler(value string) bool {
	values := []string{"auto", "stretch", "center", "flex-start",
		"flex-end", "baseline", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func AllHandler(value string) bool {
	values := []string{"initial", "inherit", "unset"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func AnimationHandler(value string) bool {
	values := []string{"initial", "inherit"}
	if in([]string{value}, values) {
		return true
	}
	splitVals := strings.Split(value, " ")
	usedFunctions := []func(string) bool{
		AnimationNameHandler,
		AnimationDurationHandler,
		TimingFunctionHandler,
		AnimationDelayHandler,
		AnimationIterationCountHandler,
		AnimationDirectionHandler,
		AnimationFillModeHandler,
		AnimationPlayStateHandler,
	}
	return recursiveCheck(splitVals, usedFunctions)
}

func AnimationDelayHandler(value string) bool {
	reg := regexp.MustCompile(`[\-]?[0-9]+[\.]?[0-9]*[s|ms]?`)
	reg.Longest()
	if reg.FindString(value) == value && value != "" {
		return true
	}
	values := []string{"initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func AnimationDirectionHandler(value string) bool {
	values := []string{"normal", "reverse", "alternate", "alternate-reverse", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func AnimationDurationHandler(value string) bool {
	reg := regexp.MustCompile(`[0-9]+[\.]?[0-9]*[s|ms]?`)
	reg.Longest()
	if reg.FindString(value) == value && value != "" {
		return true
	}
	values := []string{"initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func AnimationFillModeHandler(value string) bool {
	values := []string{"none", "forwards", "backwards", "both", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func AnimationIterationCountHandler(value string) bool {
	reg := regexp.MustCompile(`[0-9]+[\.]?[0-9]*`)
	reg.Longest()
	if reg.FindString(value) == value && value != "" {
		return true
	}
	values := []string{"infinite", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func AnimationNameHandler(value string) bool {
	reg := regexp.MustCompile(`[a-z]+`)
	reg.Longest()
	return reg.FindString(value) == value && value != ""
}

func AnimationPlayStateHandler(value string) bool {
	values := []string{"paused", "running", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func TimingFunctionHandler(value string) bool {
	values := []string{"linear", "ease", "ease-in", "ease-out", "ease-in-out", "step-start", "step-end", "initial", "inherit"}
	splitVals := splitValues(value)
	if in(splitVals, values) {
		return true
	}
	reg := regexp.MustCompile(`cubic-bezier\(([ ]*(0(.[0-9]+)?|1(.0)?),){3}[ ]*(0(.[0-9]+)?|1)\)`)
	reg.Longest()
	if reg.FindString(value) == value && value != "" {
		return true
	}
	reg = regexp.MustCompile(`steps\([ ]*[0-9]+([ ]*,[ ]*(start|end)?)\)`)
	reg.Longest()
	return reg.FindString(value) == value && value != ""
}

func BackfaceVisibilityHandler(value string) bool {
	values := []string{"visible", "hidden", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func BackgroundHandler(value string) bool {
	values := []string{"initial", "inherit"}
	if in([]string{value}, values) {
		return true
	}
	splitVals := strings.Split(value, " ")
	newSplitVals := []string{}
	for _, i := range splitVals {
		if len(strings.Split(i, "/")) == 2 {
			newSplitVals = append(newSplitVals, strings.Split(i, "/")...)
		} else {
			newSplitVals = append(newSplitVals, i)
		}
	}
	usedFunctions := []func(string) bool{
		ColorHandler,
		ImageHandler,
		BackgroundPositionHandler,
		BackgroundSizeHandler,
		BackgroundRepeatHandler,
		BackgroundOriginHandler,
		BackgroundClipHandler,
		BackgroundAttachmentHandler,
	}
	return recursiveCheck(newSplitVals, usedFunctions)
}

func BackgroundAttachmentHandler(value string) bool {
	values := []string{"scroll", "fixed", "local", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func BackgroundClipHandler(value string) bool {
	values := []string{"border-box", "padding-box", "content-box", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func BackgroundBlendModeHandler(value string) bool {
	values := []string{"normal", "multiply", "screen", "overlay", "darken",
		"lighten", "color-dodge", "saturation", "color", "luminosity"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func ImageHandler(value string) bool {
	values := []string{"none", "initial", "inherit"}
	splitVals := splitValues(value)
	if in(splitVals, values) {
		return true
	}
	reg := regexp.MustCompile(`url\([\"\']?((https|http)[a-z0-9\.\\/_:]+[\"\']?)\)`)
	reg.Longest()
	return reg.FindString(value) == value && value != ""
}

func BackgroundOriginHandler(value string) bool {
	values := []string{"padding-box", "border-box", "content-box", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func BackgroundPositionHandler(value string) bool {
	splitVals := strings.Split(value, ";")
	values := []string{"left", "left top", "left bottom", "right", "right top", "right bottom", "right center", "center top", "center center", "center bottom", "center", "top", "bottom", "initial", "inherit"}
	if in(splitVals, values) {
		return true
	}
	reg := regexp.MustCompile(`[\-]*[0-9]+[cm|mm|in|px|pt|pc\%]* [[\-]*[0-9]+[cm|mm|in|px|pt|pc\%]*]*`)
	reg.Longest()
	if reg.FindString(value) == value && value != "" {
		return true
	}
	return false
}

func BackgroundRepeatHandler(value string) bool {
	values := []string{"repeat", "repeat-x", "repeat-y", "no-repeat", "space", "round", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func BackgroundSizeHandler(value string) bool {
	splitVals := strings.Split(value, " ")
	values := []string{"auto", "cover", "contain", "initial", "inherit"}
	if in(splitVals, values) {
		return true
	}
	if len(splitVals) > 0 && LengthHandler(splitVals[0]) {
		if len(splitVals) < 2 || (len(splitVals) == 2 && LengthHandler(splitVals[1])) {
			return true
		}
	}
	return false
}

func BorderHandler(value string) bool {
	values := []string{"initial", "inherit"}
	if in([]string{value}, values) {
		return true
	}
	splitVals := multiSplit(value, " ", "/")
	usedFunctions := []func(string) bool{
		BorderWidthHandler,
		BorderStyleHandler,
		ColorHandler,
	}
	return recursiveCheck(splitVals, usedFunctions)
}

func BorderSideHandler(value string) bool {
	values := []string{"initial", "inherit"}
	if in([]string{value}, values) {
		return true
	}
	splitVals := strings.Split(value, " ")
	usedFunctions := []func(string) bool{
		BorderSideWidthHandler,
		BorderSideStyleHandler,
		ColorHandler,
	}
	return recursiveCheck(splitVals, usedFunctions)
}

func BorderSideRadiusHandler(value string) bool {
	splitVals := strings.Split(value, " ")
	valid := true
	for _, i := range splitVals {
		if !LengthHandler(i) {
			valid = false
			break
		}
	}
	if valid {
		return true
	}
	splitVals = splitValues(value)
	values := []string{"initial", "inherit"}
	return in(splitVals, values)
}

func BorderSideStyleHandler(value string) bool {
	values := []string{"none", "hidden", "dotted", "dashed", "solid", "double", "groove", "ridge", "inset", "outset", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func BorderSideWidthHandler(value string) bool {
	if LengthHandler(value) {
		return true
	}
	splitVals := strings.Split(value, ";")
	values := []string{"medium", "thin", "thick", "initial", "inherit"}
	return in(splitVals, values)
}

func BorderCollapseHandler(value string) bool {
	values := []string{"separate", "collapse", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func BorderImageHandler(value string) bool {
	values := []string{"initial", "inherit"}
	if in([]string{value}, values) {
		return true
	}
	splitVals := multiSplit(value, " ", " / ")
	usedFunctions := []func(string) bool{
		ImageHandler,
		BorderImageSliceHandler,
		BorderImageWidthHandler,
		BorderImageOutsetHandler,
		BorderImageRepeatHandler,
	}
	return recursiveCheck(splitVals, usedFunctions)
}

func BorderImageOutsetHandler(value string) bool {
	if LengthHandler(value) {
		return true
	}
	values := []string{"initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func BorderImageRepeatHandler(value string) bool {
	values := []string{"stretch", "repeat", "round", "space", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func BorderImageSliceHandler(value string) bool {
	values := []string{"fill", "initial", "inherit"}
	if in([]string{value}, values) {
		return true
	}
	splitVals := strings.Split(value, " ")
	if len(splitVals) > 4 {
		return false
	}
	usedFunctions := []func(string) bool{
		LengthHandler,
	}
	return recursiveCheck(splitVals, usedFunctions)
}

func BorderImageWidthHandler(value string) bool {
	if LengthHandler(value) {
		return true
	}
	values := []string{"auto", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func BorderRadiusHandler(value string) bool {
	values := []string{"initial", "inherit"}
	if in([]string{value}, values) {
		return true
	}
	splitVals := strings.Split(value, " ")
	if len(splitVals) > 4 {
		return false
	}
	usedFunctions := []func(string) bool{
		LengthHandler,
	}
	return recursiveCheck(splitVals, usedFunctions)
}

func BorderSpacingHandler(value string) bool {
	values := []string{"initial", "inherit"}
	if in([]string{value}, values) {
		return true
	}
	splitVals := strings.Split(value, " ")
	if len(splitVals) > 2 {
		return false
	}
	usedFunctions := []func(string) bool{
		LengthHandler,
	}
	return recursiveCheck(splitVals, usedFunctions)
}

func BorderStyleHandler(value string) bool {
	values := []string{"initial", "inherit"}
	if in([]string{value}, values) {
		return true
	}
	splitVals := strings.Split(value, " ")
	if len(splitVals) > 4 {
		return false
	}
	usedFunctions := []func(string) bool{
		BorderSideStyleHandler,
	}
	return recursiveCheck(splitVals, usedFunctions)
}

func BorderWidthHandler(value string) bool {
	values := []string{"initial", "inherit"}
	if in([]string{value}, values) {
		return true
	}
	splitVals := strings.Split(value, " ")
	if len(splitVals) > 4 {
		return false
	}
	usedFunctions := []func(string) bool{
		BorderSideWidthHandler,
	}
	return recursiveCheck(splitVals, usedFunctions)
}

func SideHandler(value string) bool {
	if LengthHandler(value) {
		return true
	}
	values := []string{"auto", "inherit", "unset"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func BoxDecorationBreakHandler(value string) bool {
	values := []string{"slice", "clone", "initial", "initial", "inherit", "unset"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func BoxShadowHandler(value string) bool {
	values := []string{"none", "initial", "inherit"}
	if in([]string{value}, values) {
		return true
	}
	commaSplitVals := strings.Split(value, ",")
	for _, val := range commaSplitVals {
		splitVals := strings.Split(val, " ")
		if len(splitVals) > 6 || len(splitVals) < 2 {
			return false
		}
		if !LengthHandler(splitVals[0]) {
			return false
		}
		if !LengthHandler(splitVals[1]) {
			return false
		}
		usedFunctions := []func(string) bool{
			LengthHandler,
			ColorHandler,
		}
		if len(splitVals) > 2 && !recursiveCheck(splitVals[2:], usedFunctions) {
			return false
		}
	}
	return true
}

func BoxSizingHandler(value string) bool {
	values := []string{"slicontent-box", "border-box", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func BreakBeforeAfterHandler(value string) bool {
	values := []string{"auto", "avoid", "always", "all", "avoid-page", "page", "left", "right", "recto", "verso", "avoid-column", "column", "avoid-region", "region"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func BreakInsideHandler(value string) bool {
	values := []string{"auto", "avoid", "avoid-page", "avoid-column", "avoid-region"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func CaptionSideHandler(value string) bool {
	values := []string{"top", "bottom", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func CaretColorHandler(value string) bool {
	splitVals := splitValues(value)
	if in(splitVals, colorValues) {
		return true
	}
	reg := regexp.MustCompile(`#[0-9abcdef]{6}`)
	reg.Longest()
	if reg.FindString(value) == value && value != "" {
		return true
	}
	reg = regexp.MustCompile(`rgb\(([ ]*((([0-9]{1,2}|100)\%)|(([01]?[0-9]{1,2})|(2[0-4][0-9])|(25[0-5]))),){2}([ ]*((([0-9]{1,2}|100)\%)|(([01]?[0-9]{1,2})|(2[0-4][0-9])|(25[0-5]))))\)`)
	reg.Longest()
	if reg.FindString(value) == value && value != "" {
		return true
	}
	reg = regexp.MustCompile(`rgba\(([ ]*((([0-9]{1,2}|100)\%)|(([01]?[0-9]{1,2})|(2[0-4][0-9])|(25[0-5]))),){3}[ ]*(1(\.0)?|0|(0\.[0-9]+))\)`)
	reg.Longest()
	if reg.FindString(value) == value && value != "" {
		return true
	}
	reg = regexp.MustCompile(`hsl\([ ]*([012]?[0-9]{1,2}|3[0-5][0-9]|360),[ ]*([0-9]{0,2}|100)\%,[ ]*([0-9]{0,2}|100)\%\)`)
	if reg.FindString(value) == value && value != "" {
		return true
	}
	reg = regexp.MustCompile(`hsla\(([ ]*[012]?[0-9]{1,2}|3[0-5][0-9]|360),[ ]*([0-9]{0,2}|100)\%,[ ]*([0-9]{0,2}|100)\%,[ ]*(1|1\.0|0|(0\.[0-9]+))\)`)
	reg.Longest()
	if reg.FindString(value) == value && value != "" {
		return true
	}
	return false
}

func ClearHandler(value string) bool {
	values := []string{"none", "left", "right", "both", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func ClipHandler(value string) bool {
	reg := regexp.MustCompile(`rect\([0-9]+px,[ ]*[0-9]+px,[ ]*[0-9]+px,[ ]*[0-9]+px\)`)
	reg.Longest()
	if reg.FindString(value) == value && value != "" {
		return true
	}
	values := []string{"auto", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func ColorHandler(value string) bool {
	splitVals := splitValues(value)
	if in(splitVals, colorValues) {
		return true
	}
	reg := regexp.MustCompile(`#[0-9abcdef]{6}`)
	reg.Longest()
	if reg.FindString(value) == value && value != "" {
		return true
	}
	reg = regexp.MustCompile(`rgb\(([ ]*((([0-9]{1,2}|100)\%)|(([01]?[0-9]{1,2})|(2[0-4][0-9])|(25[0-5]))),){2}([ ]*((([0-9]{1,2}|100)\%)|(([01]?[0-9]{1,2})|(2[0-4][0-9])|(25[0-5]))))\)`)
	reg.Longest()
	if reg.FindString(value) == value && value != "" {
		return true
	}
	reg = regexp.MustCompile(`rgba\(([ ]*((([0-9]{1,2}|100)\%)|(([01]?[0-9]{1,2})|(2[0-4][0-9])|(25[0-5]))),){3}[ ]*(1(\.0)?|0|(0\.[0-9]+))\)`)
	reg.Longest()
	if reg.FindString(value) == value && value != "" {
		return true
	}
	reg = regexp.MustCompile(`hsl\([ ]*([012]?[0-9]{1,2}|3[0-5][0-9]|360),[ ]*([0-9]{0,2}|100)\%,[ ]*([0-9]{0,2}|100)\%\)`)
	reg.Longest()
	if reg.FindString(value) == value && value != "" {
		return true
	}
	reg = regexp.MustCompile(`hsla\(([ ]*[012]?[0-9]{1,2}|3[0-5][0-9]|360),[ ]*([0-9]{0,2}|100)\%,[ ]*([0-9]{0,2}|100)\%,[ ]*(1|1\.0|0|(0\.[0-9]+))\)`)
	reg.Longest()
	if reg.FindString(value) == value && value != "" {
		return true
	}
	return false
}

func ColumnCountHandler(value string) bool {
	reg := regexp.MustCompile(`[0-9]+`)
	reg.Longest()
	if reg.FindString(value) == value && value != "" {
		return true
	}
	values := []string{"auto", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func ColumnFillHandler(value string) bool {
	values := []string{"balance", "auto", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func ColumnGapHandler(value string) bool {
	if LengthHandler(value) {
		return true
	}
	values := []string{"normal", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func ColumnRuleHandler(value string) bool {
	values := []string{"initial", "inherit"}
	if in([]string{value}, values) {
		return true
	}
	splitVals := strings.Split(value, " ")
	usedFunctions := []func(string) bool{
		ColumnRuleWidthHandler,
		BorderSideStyleHandler,
		ColorHandler,
	}
	return recursiveCheck(splitVals, usedFunctions)
}

func ColumnRuleWidthHandler(value string) bool {
	if LengthHandler(value) {
		return true
	}
	splitVals := strings.Split(value, ";")
	values := []string{"medium", "thin", "thick", "initial", "inherit"}
	return in(splitVals, values)
}

func ColumnSpanHandler(value string) bool {
	values := []string{"none", "all", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func ColumnWidthHandler(value string) bool {
	if LengthHandler(value) {
		return true
	}
	splitVals := strings.Split(value, ";")
	values := []string{"auto", "initial", "inherit"}
	return in(splitVals, values)
}

func ColumnsHandler(value string) bool {
	values := []string{"auto", "initial", "inherit"}
	if in([]string{value}, values) {
		return true
	}
	splitVals := strings.Split(value, " ")
	usedFunctions := []func(string) bool{
		ColumnWidthHandler,
		ColumnCountHandler,
	}
	return recursiveCheck(splitVals, usedFunctions)
}

func CursorHandler(value string) bool {
	values := []string{"alias", "all-scroll", "auto", "cell", "context-menu", "col-resize", "copy", "crosshair", "default", "e-resize", "ew-resize", "grab", "grabbing", "help", "move", "n-resize", "ne-resize", "nesw-resize", "ns-resize", "nw-resize", "nwse-resize", "no-drop", "none", "not-allowed", "pointer", "progress", "row-resize", "s-resize", "se-resize", "sw-resize", "text", "vertical-text", "w-resize", "wait", "zoom-in", "zoom-out", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func DirectionHandler(value string) bool {
	values := []string{"ltr", "rtl", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func DisplayHandler(value string) bool {
	values := []string{"inline", "block", "contents", "flex", "grid", "inline-block", "inline-flex", "inline-grid", "inline-table", "list-item", "run-in", "table", "table-caption", "table-column-group", "table-header-group", "table-footer-group", "table-row-group", "table-cell", "table-column", "table-row", "none", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func EmptyCellsHandler(value string) bool {
	values := []string{"show", "hide", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func FilterHandler(value string) bool {
	values := []string{"none", "initial", "inherit"}
	splitVals := splitValues(value)
	if in(splitVals, values) {
		return true
	}
	reg := regexp.MustCompile(`blur\([0-9]+px\)`)
	reg.Longest()
	if reg.FindString(value) == value && value != "" {
		return true
	}
	reg = regexp.MustCompile(`(brightness|contrast)\([0-9]+\%\)`)
	reg.Longest()
	if reg.FindString(value) == value && value != "" {
		return true
	}
	reg = regexp.MustCompile(`drop-shadow\(([-]?[0-9]+px) ([-]?[0-9]+px)( [-]?[0-9]+px)?( ([-]?[0-9]+px))?`)
	reg.Longest()
	colorValue := strings.TrimSuffix(string(reg.ReplaceAll([]byte(value), []byte{})), ")")
	if ColorHandler(colorValue) {
		return true
	}
	reg = regexp.MustCompile(`grayscale\(([0-9]{1,2}|100)%\)`)
	reg.Longest()
	if reg.FindString(value) == value && value != "" {
		return true
	}
	reg = regexp.MustCompile(`hue-rotate\(([12]?[0-9]{1,2}|3[0-5][0-9]|360)?\)`)
	reg.Longest()
	if reg.FindString(value) == value && value != "" {
		return true
	}
	reg = regexp.MustCompile(`invert\(([0-9]{1,2}|100)%\)`)
	reg.Longest()
	if reg.FindString(value) == value && value != "" {
		return true
	}
	reg = regexp.MustCompile(`opacity\(([0-9]{1,2}|100)%\)`)
	reg.Longest()
	if reg.FindString(value) == value && value != "" {
		return true
	}
	reg = regexp.MustCompile(`saturate\([0-9]+%\)`)
	reg.Longest()
	if reg.FindString(value) == value && value != "" {
		return true
	}
	reg = regexp.MustCompile(`sepia\(([0-9]{1,2}|100)%\)`)
	reg.Longest()
	if reg.FindString(value) == value && value != "" {
		return true
	}
	//Not allowing URLs
	return false
}

func FlexHandler(value string) bool {
	values := []string{"auto", "initial", "initial", "inherit"}
	if in([]string{value}, values) {
		return true
	}
	splitVals := strings.Split(value, " ")
	usedFunctions := []func(string) bool{
		FlexGrowHandler,
		FlexBasisHandler,
	}
	return recursiveCheck(splitVals, usedFunctions)
}

func FlexBasisHandler(value string) bool {
	if LengthHandler(value) {
		return true
	}
	splitVals := strings.Split(value, ";")
	values := []string{"auto", "initial", "inherit"}
	return in(splitVals, values)
}

func FlexDirectionHandler(value string) bool {
	values := []string{"row", "row-reverse", "column", "column-reverse", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func FlexFlowHandler(value string) bool {
	values := []string{"initial", "inherit"}
	if in([]string{value}, values) {
		return true
	}
	splitVals := strings.Split(value, " ")
	usedFunctions := []func(string) bool{
		FlexDirectionHandler,
		FlexWrapHandler,
	}
	return recursiveCheck(splitVals, usedFunctions)
}

func FlexGrowHandler(value string) bool {
	reg := regexp.MustCompile(`[0-9\.]+`)
	reg.Longest()
	if reg.FindString(value) == value && value != "" {
		return true
	}
	splitVals := strings.Split(value, ";")
	values := []string{"initial", "inherit"}
	return in(splitVals, values)
}

func FlexWrapHandler(value string) bool {
	values := []string{"nowrap", "wrap", "wrap-reverse", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func FloatHandler(value string) bool {
	values := []string{"none", "left", "right", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func FontHandler(value string) bool {
	values := []string{"caption", "icon", "menu", "message-box", "small-caption", "status-bar", "initial", "inherit"}
	if in([]string{value}, values) {
		return true
	}
	splitVals := strings.Split(value, " ")
	newSplitVals := []string{}
	for _, i := range splitVals {
		if len(strings.Split(i, "/")) == 2 {
			newSplitVals = append(newSplitVals, strings.Split(i, "/")...)
		} else {
			newSplitVals = append(newSplitVals, i)
		}
	}
	usedFunctions := []func(string) bool{
		FontStyleHandler,
		FontVariantHandler,
		FontWeightHandler,
		FontSizeHandler,
		FontFamilyHandler,
	}
	return recursiveCheck(newSplitVals, usedFunctions)
}

func FontFamilyHandler(value string) bool {
	values := []string{"initial", "inherit"}
	splitVals := splitValues(value)
	if in(splitVals, values) {
		return true
	}
	reg := regexp.MustCompile(`('[a-z \-]+'|[a-z \-]+)`)
	reg.Longest()
	for _, i := range splitVals {
		i = strings.TrimSpace(i)
		if reg.FindString(i) != i {
			return false
		}
	}
	return true
}

func FontKerningHandler(value string) bool {
	values := []string{"auto", "normal", "none"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func FontLanguageOverrideHandler(value string) bool {
	reg := regexp.MustCompile(`[a-z]+`)
	reg.Longest()
	return reg.FindString(value) == value && value != ""
}

func FontSizeHandler(value string) bool {
	if LengthHandler(value) {
		return true
	}
	values := []string{"medium", "xx-small", "x-small", "small", "large", "x-large", "xx-large", "smaller", "larger", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func FontSizeAdjustHandler(value string) bool {
	reg := regexp.MustCompile(`[0-9]+[\.]?[0-9]*`)
	reg.Longest()
	if reg.FindString(value) == value && value != "" {
		return true
	}
	values := []string{"auto", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func FontStretchHandler(value string) bool {
	values := []string{"ultra-condensed", "extra-condensed", "condensed", "semi-condensed", "normal", "semi-expanded", "expanded", "extra-expanded", "ultra-expanded", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func FontStyleHandler(value string) bool {
	values := []string{"normal", "italic", "oblique", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func FontSynthesisHandler(value string) bool {
	values := []string{"none", "style", "weight"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func FontVariantCapsHandler(value string) bool {
	values := []string{"normal", "small-caps", "all-small-caps", "petite-caps", "all-petite-caps", "unicase", "titling-caps"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func FontVariantHandler(value string) bool {
	values := []string{"normal", "small-caps", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func FontVariantPositionHandler(value string) bool {
	values := []string{"normal", "sub", "super"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func FontWeightHandler(value string) bool {
	values := []string{"normal", "bold", "bolder", "lighter", "100", "200", "300", "400", "500", "600", "700", "800", "900", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func GridHandler(value string) bool {
	values := []string{"none", "initial", "inherit"}
	if in([]string{value}, values) {
		return true
	}
	splitVals := strings.Split(value, " ")
	newSplitVals := []string{}
	for _, i := range splitVals {
		if i != "/" {
			newSplitVals = append(newSplitVals, i)
		}
	}
	usedFunctions := []func(string) bool{
		GridTemplateRowsHandler,
		GridTemplateColumnsHandler,
		GridTemplateAreasHandler,
		GridAutoColumnsHandler,
		GridAutoFlowHandler,
	}
	return recursiveCheck(newSplitVals, usedFunctions)
}

func GridAreaHandler(value string) bool {
	values := []string{"none", "initial", "inherit"}
	if in([]string{value}, values) {
		return true
	}
	splitVals := strings.Split(value, " / ")
	usedFunctions := []func(string) bool{
		GridAxisStartEndHandler,
	}
	return recursiveCheck(splitVals, usedFunctions)
}

func GridAutoColumnsHandler(value string) bool {
	if LengthHandler(value) {
		return true
	}
	values := []string{"auto", "max-content", "min-content", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func GridAutoFlowHandler(value string) bool {
	values := []string{"row", "column", "dense", "row dense", "column dense"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func GridColumnHandler(value string) bool {
	values := []string{"none", "initial", "inherit"}
	if in([]string{value}, values) {
		return true
	}
	splitVals := strings.Split(value, " / ")
	if len(splitVals) > 2 {
		return false
	}
	usedFunctions := []func(string) bool{
		GridAxisStartEndHandler,
	}
	return recursiveCheck(splitVals, usedFunctions)
}

func GridColumnGapHandler(value string) bool {
	return LengthHandler(value)
}

func LengthHandler(value string) bool {
	reg := regexp.MustCompile(`[\-]?[0-9]+[\.]?[0-9]*(%|cm|mm|in|px|pt|pc|em|ex|ch|rem|vw|vh|vmin|vmax|deg|rad|turn)?`)
	reg.Longest()
	return reg.FindString(value) == value && value != ""
}

func LineBreakHandler(value string) bool {
	values := []string{"auto", "loose", "normal", "strict"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func GridAxisStartEndHandler(value string) bool {
	reg := regexp.MustCompile(`[0-9]+`)
	if reg.FindString(value) == value && value != "" {
		return true
	}
	reg = regexp.MustCompile(`span [0-9]+`)
	if reg.FindString(value) == value && value != "" {
		return true
	}
	values := []string{"auto"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func GridGapHandler(value string) bool {
	splitVals := strings.Split(value, " ")
	if len(splitVals) > 2 {
		return false
	}
	usedFunctions := []func(string) bool{
		GridColumnGapHandler,
	}
	return recursiveCheck(splitVals, usedFunctions)
}

func GridRowHandler(value string) bool {
	splitVals := strings.Split(value, " / ")
	if len(splitVals) > 2 {
		return false
	}
	usedFunctions := []func(string) bool{
		GridAxisStartEndHandler,
	}
	return recursiveCheck(splitVals, usedFunctions)
}

func GridTemplateHandler(value string) bool {
	values := []string{"none", "initial", "inherit"}
	if in([]string{value}, values) {
		return true
	}
	splitVals := strings.Split(value, " / ")
	if len(splitVals) > 2 {
		return false
	}
	usedFunctions := []func(string) bool{
		GridTemplateColumnsHandler,
		GridTemplateRowsHandler,
	}
	return recursiveCheck(splitVals, usedFunctions)
}

func GridTemplateAreasHandler(value string) bool {
	values := []string{"none"}
	if in([]string{value}, values) {
		return true
	}
	reg := regexp.MustCompile(`['"]?[a-z ]+['"]?`)
	reg.Longest()
	return reg.FindString(value) == value && value != ""
}

func GridTemplateColumnsHandler(value string) bool {
	splitVals := strings.Split(value, " ")
	values := []string{"none", "auto", "max-content", "min-content", "initial", "inherit"}
	for _, val := range splitVals {
		if LengthHandler(val) {
			continue
		}
		valArr := []string{val}
		if !in(valArr, values) {
			return false
		}
	}
	return true
}

func GridTemplateRowsHandler(value string) bool {
	splitVals := strings.Split(value, " ")
	values := []string{"none", "auto", "max-content", "min-content"}
	for _, val := range splitVals {
		if LengthHandler(val) {
			continue
		}
		valArr := []string{val}
		if !in(valArr, values) {
			return false
		}
	}
	return true
}

func HangingPunctuationHandler(value string) bool {
	values := []string{"none", "first", "last", "allow-end", "force-end", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func HeightHandler(value string) bool {
	if LengthHandler(value) {
		return true
	}
	values := []string{"auto", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func HyphensHandler(value string) bool {
	values := []string{"none", "manual", "auto", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func ImageRenderingHandler(value string) bool {
	values := []string{"auto", "smooth", "high-quality", "crisp-edges", "pixelated"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func IsolationHandler(value string) bool {
	values := []string{"auto", "isolate", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func JustifyContentHandler(value string) bool {
	values := []string{"flex-start", "flex-end", "center", "space-between", "space-around", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func LetterSpacingHandler(value string) bool {
	if LengthHandler(value) {
		return true
	}
	values := []string{"normal", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func LineHeightHandler(value string) bool {
	if LengthHandler(value) {
		return true
	}
	values := []string{"normal", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func ListStyleHandler(value string) bool {
	values := []string{"initial", "inherit"}
	if in([]string{value}, values) {
		return true
	}
	splitVals := strings.Split(value, " ")
	usedFunctions := []func(string) bool{
		ListStyleTypeHandler,
		ListStylePositionHandler,
		ImageHandler,
	}
	return recursiveCheck(splitVals, usedFunctions)
}

func ListStylePositionHandler(value string) bool {
	values := []string{"inside", "outside", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func ListStyleTypeHandler(value string) bool {
	values := []string{"disc", "armenian", "circle", "cjk-ideographic", "decimal", "decimal-leading-zero", "georgian", "hebrew", "hiragana", "hiragana-iroha", "katakana", "katakana-iroha", "lower-alpha", "lower-greek", "lower-latin", "lower-roman", "none", "square", "upper-alpha", "upper-greek", "upper-latin", "upper-roman", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func MarginHandler(value string) bool {
	values := []string{"auto", "initial", "inherit"}
	if in([]string{value}, values) {
		return true
	}
	splitVals := strings.Split(value, " ")
	usedFunctions := []func(string) bool{
		MarginSideHandler,
	}
	return recursiveCheck(splitVals, usedFunctions)
}

func MarginSideHandler(value string) bool {
	if LengthHandler(value) {
		return true
	}
	values := []string{"auto", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func MaxHeightWidthHandler(value string) bool {
	if LengthHandler(value) {
		return true
	}
	values := []string{"none", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func MinHeightWidthHandler(value string) bool {
	if LengthHandler(value) {
		return true
	}
	values := []string{"initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func MixBlendModeHandler(value string) bool {
	values := []string{"normal", "multiply", "screen", "overlay", "darken", "lighten", "color-dodge", "color-burn", "difference", "exclusion", "hue", "saturation", "color", "luminosity"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func ObjectFitHandler(value string) bool {
	values := []string{"fill", "contain", "cover", "none", "scale-down", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func ObjectPositionHandler(value string) bool {
	values := []string{"initial", "inherit"}
	if in([]string{value}, values) {
		return true
	}
	splitVals := strings.Split(value, " ")
	if len(splitVals) > 2 {
		return false
	}
	usedFunctions := []func(string) bool{
		LengthHandler,
	}
	return recursiveCheck(splitVals, usedFunctions)
}

func OpacityHandler(value string) bool {
	reg := regexp.MustCompile("(0[.]?[0-9]*)|(1.0)")
	reg.Longest()
	if reg.FindString(value) == value && value != "" {
		return true
	}
	values := []string{"initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func OrderHandler(value string) bool {
	reg := regexp.MustCompile("[0-9]+")
	reg.Longest()
	if reg.FindString(value) == value && value != "" {
		return true
	}
	values := []string{"initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func OutlineHandler(value string) bool {
	values := []string{"initial", "inherit"}
	if in([]string{value}, values) {
		return true
	}
	splitVals := strings.Split(value, " ")
	usedFunctions := []func(string) bool{
		ColorHandler,
		OutlineWidthHandler,
		OutlineStyleHandler,
	}
	return recursiveCheck(splitVals, usedFunctions)
}

func OutlineOffsetHandler(value string) bool {
	if LengthHandler(value) {
		return true
	}
	values := []string{"initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func OutlineStyleHandler(value string) bool {
	values := []string{"none", "hidden", "dotted", "dashed", "solid", "double", "groove", "ridge", "inset", "outset", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func OutlineWidthHandler(value string) bool {
	if LengthHandler(value) {
		return true
	}
	values := []string{"medium", "thin", "thick", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func OverflowHandler(value string) bool {
	values := []string{"visible", "hidden", "scroll", "auto", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func OverflowXYHandler(value string) bool {
	values := []string{"visible", "hidden", "scroll", "auto", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func OverflowWrapHandler(value string) bool {
	values := []string{"normal", "break-word", "anywhere"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func OrphansHandler(value string) bool {
	reg := regexp.MustCompile(`[0-9]+`)
	reg.Longest()
	return reg.FindString(value) == value && value != ""
}

func PaddingHandler(value string) bool {
	values := []string{"initial", "inherit"}
	if in([]string{value}, values) {
		return true
	}
	splitVals := strings.Split(value, " ")
	if len(splitVals) > 4 {
		return false
	}
	usedFunctions := []func(string) bool{
		PaddingSideHandler,
	}
	return recursiveCheck(splitVals, usedFunctions)
}

func PaddingSideHandler(value string) bool {
	if LengthHandler(value) {
		return true
	}
	values := []string{"initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func PageBreakBeforeAfterHandler(value string) bool {
	values := []string{"auto", "always", "avoid", "left", "right", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func PageBreakInsideHandler(value string) bool {
	values := []string{"auto", "avoid", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func PerspectiveHandler(value string) bool {
	if LengthHandler(value) {
		return true
	}
	values := []string{"none", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func PerspectiveOriginHandler(value string) bool {
	values := []string{"initial", "inherit"}
	if in([]string{value}, values) {
		return true
	}
	splitVals := strings.Split(value, " ")
	xValues := []string{"left", "center", "right"}
	yValues := []string{"top", "center", "bottom"}
	if len(splitVals) > 1 {
		if !in([]string{splitVals[0]}, xValues) && !LengthHandler(splitVals[0]) {
			return false
		}
		return in([]string{splitVals[1]}, yValues) || LengthHandler(splitVals[1])
	} else if len(splitVals) == 1 {
		return in(splitVals, xValues) || in(splitVals, yValues) || LengthHandler(splitVals[0])
	}
	return false
}

func PointerEventsHandler(value string) bool {
	values := []string{"auto", "none", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func PositionHandler(value string) bool {
	values := []string{"static", "absolute", "fixed", "relative", "sticky", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func QuotesHandler(value string) bool {
	values := []string{"none", "initial", "inherit"}
	splitVals := splitValues(value)
	if in(splitVals, values) {
		return true
	}
	reg := regexp.MustCompile(`([ ]*["'][\x{0022}\x{0027}\x{2039}\x{2039}\x{203A}\x{00AB}\x{00BB}\x{2018}\x{2019}\x{201C}-\x{201E}]["'] ["'][\x{0022}\x{0027}\x{2039}\x{2039}\x{203A}\x{00AB}\x{00BB}\x{2018}\x{2019}\x{201C}-\x{201E}]["'])+`)
	reg.Longest()
	return reg.FindString(value) == value && value != ""
}

func ResizeHandler(value string) bool {
	values := []string{"none", "both", "horizontal", "vertical", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func ScrollBehaviorHandler(value string) bool {
	values := []string{"auto", "smooth", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func TabSizeHandler(value string) bool {
	if LengthHandler(value) {
		return true
	}
	values := []string{"initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func TableLayoutHandler(value string) bool {
	values := []string{"auto", "fixed", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func TextAlignHandler(value string) bool {
	values := []string{"left", "right", "center", "justify", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func TextAlignLastHandler(value string) bool {
	values := []string{"auto", "left", "right", "center", "justify", "start", "end", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func TextCombineUprightHandler(value string) bool {
	values := []string{"none", "all"}
	splitVals := splitValues(value)
	if in(splitVals, values) {
		return true
	}
	reg := regexp.MustCompile(`digits [2-4]`)
	reg.Longest()
	return reg.FindString(value) == value && value != ""
}

func TextDecorationHandler(value string) bool {
	values := []string{"initial", "inherit"}
	if in([]string{value}, values) {
		return true
	}
	splitVals := strings.Split(value, " ")
	usedFunctions := []func(string) bool{
		TextDecorationStyleHandler,
		ColorHandler,
		TextDecorationLineHandler,
	}
	return recursiveCheck(splitVals, usedFunctions)
}

func TextDecorationLineHandler(value string) bool {
	values := []string{"none", "underline", "overline", "line-through", "initial", "inherit"}
	splitVals := strings.Split(value, " ")
	return in(splitVals, values)
}

func TextDecorationStyleHandler(value string) bool {
	values := []string{"solid", "double", "dotted", "dashed", "wavy", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func TextIndentHandler(value string) bool {
	if LengthHandler(value) {
		return true
	}
	values := []string{"initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func TextJustifyHandler(value string) bool {
	values := []string{"auto", "inter-word", "inter-character", "none", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func TextOverflowHandler(value string) bool {
	reg := regexp.MustCompile("[\"'][a-z]+[\"']")
	reg.Longest()
	if reg.FindString(value) == value && value != "" {
		return true
	}
	values := []string{"clip", "ellipsis", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func TextOrientationHandler(value string) bool {
	values := []string{"mixed", "upright", "sideways", "sideways-right"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func TextShadowHandler(value string) bool {
	values := []string{"none", "initial", "inherit"}
	if in([]string{value}, values) {
		return true
	}
	commaSplitVals := strings.Split(value, ",")
	for _, val := range commaSplitVals {
		splitVals := strings.Split(val, " ")
		if len(splitVals) > 6 || len(splitVals) < 2 {
			return false
		}
		if !LengthHandler(splitVals[0]) {
			return false
		}
		if !LengthHandler(splitVals[1]) {
			return false
		}
		usedFunctions := []func(string) bool{
			LengthHandler,
			ColorHandler,
		}
		if len(splitVals) > 2 && !recursiveCheck(splitVals[2:], usedFunctions) {
			return false
		}
	}
	return true
}

func TextTransformHandler(value string) bool {
	values := []string{"none", "capitalize", "uppercase", "lowercase", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func TransformHandler(value string) bool {
	values := []string{"none", "initial", "inherit"}
	if in([]string{value}, values) {
		return true
	}
	reg := regexp.MustCompile(`matrix\(([ ]*[0-9]+[\.]?[0-9]*,){5}([ ]*[0-9]+[\.]?[0-9]*)\)`)
	reg.Longest()
	if reg.FindString(value) == value && value != "" {
		return true
	}
	reg = regexp.MustCompile(`matrix3d\(([ ]*[0-9]+[\.]?[0-9]*,){15}([ ]*[0-9]+[\.]?[0-9]*)\)`)
	if reg.FindString(value) == value && value != "" {
		return true
	}
	reg = regexp.MustCompile(`(translate|translate3d|translatex|translatey|translatez|scale|scale3d|scalex|scaley|scalez)\(`)
	reg.Longest()
	subValue := string(reg.ReplaceAll([]byte(value), []byte{}))
	trimValue := strings.Split(strings.TrimSuffix(subValue, ")"), ",")
	valid := true
	for _, i := range trimValue {
		if !LengthHandler(strings.TrimSpace(i)) {
			valid = false
			break
		}
	}
	if valid && trimValue != nil {
		return true
	}
	reg = regexp.MustCompile(`rotate(x|y|z)?\(([12]?|3[0-5][0-9]|360)\)`)
	reg.Longest()
	if reg.FindString(value) == value && value != "" {
		return true
	}
	reg = regexp.MustCompile(`rotate3d\(([ ]?(1(\.0)?|0\.[0-9]+),){3}([12]?|3[0-5][0-9]|360)\)`)
	reg.Longest()
	if reg.FindString(value) == value && value != "" {
		return true
	}
	reg = regexp.MustCompile(`skew(x|y)?\(`)
	reg.Longest()
	subValue = string(reg.ReplaceAll([]byte(value), []byte{}))
	subValue = strings.TrimSuffix(subValue, ")")
	trimValue = strings.Split(subValue, ",")
	valid = true
	for _, i := range trimValue {
		if !LengthHandler(strings.TrimSpace(i)) {
			valid = false
			break
		}
	}
	if valid {
		return true
	}
	reg = regexp.MustCompile(`perspective\(`)
	reg.Longest()
	subValue = string(reg.ReplaceAll([]byte(value), []byte{}))
	subValue = strings.TrimSuffix(subValue, ")")
	return LengthHandler(subValue)
}

func TransformOriginHandler(value string) bool {
	values := []string{"initial", "inherit"}
	if in([]string{value}, values) {
		return true
	}
	splitVals := strings.Split(value, " ")
	xValues := []string{"left", "center", "right"}
	yValues := []string{"top", "center", "bottom"}
	if len(splitVals) > 2 {
		if !in([]string{splitVals[0]}, xValues) && !LengthHandler(splitVals[0]) {
			return false
		}
		if !in([]string{splitVals[1]}, yValues) && !LengthHandler(splitVals[1]) {
			return false
		}
		return LengthHandler(splitVals[2])
	} else if len(splitVals) > 1 {
		if !in([]string{splitVals[0]}, xValues) && !LengthHandler(splitVals[0]) {
			return false
		}
		return in([]string{splitVals[1]}, yValues) || LengthHandler(splitVals[1])
	} else if len(splitVals) == 1 {
		return in(splitVals, xValues) || in(splitVals, yValues) || LengthHandler(splitVals[0])
	}
	return false
}

func TransformStyleHandler(value string) bool {
	values := []string{"flat", "preserve-3d", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func TransitionHandler(value string) bool {
	values := []string{"initial", "inherit"}
	if in([]string{value}, values) {
		return true
	}
	splitVals := strings.Split(value, " ")
	usedFunctions := []func(string) bool{
		TransitionPropertyHandler,
		TransitionDurationHandler,
		TimingFunctionHandler,
		TransitionDelayHandler,
		ColorHandler,
	}
	return recursiveCheck(splitVals, usedFunctions)
}

func TransitionDelayHandler(value string) bool {
	reg := regexp.MustCompile("[0-9]+[.]?[0-9]*(s|ms)?")
	reg.Longest()
	if reg.FindString(value) == value && value != "" {
		return true
	}
	values := []string{"initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func TransitionDurationHandler(value string) bool {
	reg := regexp.MustCompile("[0-9]+[.]?[0-9]*(s|ms)?")
	reg.Longest()
	if reg.FindString(value) == value && value != "" {
		return true
	}
	values := []string{"initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func TransitionPropertyHandler(value string) bool {
	reg := regexp.MustCompile("([a-zA-Z]+,[ ]?)*[a-zA-Z]+")
	reg.Longest()
	if reg.FindString(value) == value && value != "" {
		return true
	}
	values := []string{"none", "all", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func UnicodeBidiHandler(value string) bool {
	values := []string{"normal", "embed", "bidi-override", "isolate", "isolate-override", "plaintext", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func UserSelectHandler(value string) bool {
	values := []string{"auto", "none", "text", "all"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func VerticalAlignHandler(value string) bool {
	if LengthHandler(value) {
		return true
	}
	values := []string{"baseline", "sub", "super", "top", "text-top", "middle", "bottom", "text-bottom", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func VisiblityHandler(value string) bool {
	values := []string{"visible", "hidden", "collapse", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func WhiteSpaceHandler(value string) bool {
	values := []string{"normal", "nowrap", "pre", "pre-line", "pre-wrap", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func WidthHandler(value string) bool {
	if LengthHandler(value) {
		return true
	}
	values := []string{"auto", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func WordSpacingHandler(value string) bool {
	if LengthHandler(value) {
		return true
	}
	values := []string{"normal", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func WordBreakHandler(value string) bool {
	values := []string{"normal", "break-all", "keep-all", "break-word", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func WordWrapHandler(value string) bool {
	values := []string{"normal", "break-word", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func WritingModeHandler(value string) bool {
	values := []string{"horizontal-tb", "vertical-rl", "vertical-lr"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}

func ZIndexHandler(value string) bool {
	reg := regexp.MustCompile(`[\-]?[0-9]+`)
	reg.Longest()
	if reg.FindString(value) == value && value != "" {
		return true
	}
	values := []string{"auto", "initial", "inherit"}
	splitVals := splitValues(value)
	return in(splitVals, values)
}