mirror of
https://github.com/go-gitea/gitea.git
synced 2024-10-31 08:37:35 -04:00
d00ebf445b
* upgrade to most recent bluemonday * make vendor * update tests for bluemonday * update tests for bluemonday * update tests for bluemonday
2086 lines
64 KiB
Go
Vendored
2086 lines
64 KiB
Go
Vendored
// 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)
|
|
}
|