Платформа ЦРНП "Мирокод" для разработки проектов
https://git.mirocod.ru
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2086 lines
64 KiB
2086 lines
64 KiB
// 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 css |
|
|
|
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) |
|
}
|
|
|