{

switch (propertyId) {

case CSSPropertyFontSize:

case CSSPropertyHeight:

case CSSPropertyWidth:

case CSSPropertyMinHeight:

case CSSPropertyMinWidth:

case CSSPropertyPaddingBottom:

case CSSPropertyPaddingLeft:

case CSSPropertyPaddingRight:

case CSSPropertyPaddingTop:

case CSSPropertyInlineSize:

case CSSPropertyBlockSize:

case CSSPropertyMinInlineSize:

case CSSPropertyMinBlockSize:

case CSSPropertyPaddingBlockEnd:

case CSSPropertyPaddingBlockStart:

case CSSPropertyPaddingInlineEnd:

case CSSPropertyPaddingInlineStart:

case CSSPropertyR:

case CSSPropertyRx:

case CSSPropertyRy:

case CSSPropertyShapeMargin:

acceptsNegativeNumbers = false;

return true;

case CSSPropertyBottom:

case CSSPropertyCx:

case CSSPropertyCy:

case CSSPropertyLeft:

case CSSPropertyInsetBlockEnd:

case CSSPropertyInsetBlockStart:

case CSSPropertyInsetInlineEnd:

case CSSPropertyInsetInlineStart:

case CSSPropertyMarginBottom:

case CSSPropertyMarginLeft:

case CSSPropertyMarginRight:

case CSSPropertyMarginTop:

case CSSPropertyRight:

case CSSPropertyTop:

case CSSPropertyMarginBlockEnd:

case CSSPropertyMarginBlockStart:

case CSSPropertyMarginInlineEnd:

case CSSPropertyMarginInlineStart:

case CSSPropertyX:

case CSSPropertyY:

acceptsNegativeNumbers = true;

return true;

default:

return false;

}

{

// The charactersToDouble() function allows a trailing '.' but that is not allowed in CSS number values.

if (length && characters[length - 1] == '.')

return std::nullopt;

// FIXME: If we don't want to skip over leading spaces, we should use parseDouble, not charactersToDouble.

bool ok;

auto number = charactersToDouble(characters, length, &ok);

if (!ok)

return std::nullopt;

return number;

{

if (length > 2 && isASCIIAlphaCaselessEqual(characters[length - 2], 'p') && isASCIIAlphaCaselessEqual(characters[length - 1], 'x')) {

length -= 2;

unit = CSSUnitType::CSS_PX;

} else if (length > 1 && characters[length - 1] == '%') {

length -= 1;

unit = CSSUnitType::CSS_PERCENTAGE;

}

auto parsedNumber = parseCSSNumber(characters, length);

number = parsedNumber.value_or(0);

return parsedNumber.has_value();

{

// Just support deg and rad for now.

if (length < 4)

return false;

if (isASCIIAlphaCaselessEqual(characters[length - 3], 'd') && isASCIIAlphaCaselessEqual(characters[length - 2], 'e') && isASCIIAlphaCaselessEqual(characters[length - 1], 'g')) {

length -= 3;

unit = CSSUnitType::CSS_DEG;

} else if (isASCIIAlphaCaselessEqual(characters[length - 3], 'r') && isASCIIAlphaCaselessEqual(characters[length - 2], 'a') && isASCIIAlphaCaselessEqual(characters[length - 1], 'd')) {

length -= 3;

unit = CSSUnitType::CSS_RAD;

} else

return false;

auto parsedNumber = parseCSSNumber(characters, length);

number = parsedNumber.value_or(0);

return parsedNumber.has_value();

{

ASSERT(!string.isEmpty());

bool acceptsNegativeNumbers = false;

// In @viewport, width and height are shorthands, not simple length values.

if (isCSSViewportParsingEnabledForMode(cssParserMode) || !isSimpleLengthPropertyID(propertyId, acceptsNegativeNumbers))

return nullptr;

unsigned length = string.length();

double number;

CSSUnitType unit = CSSUnitType::CSS_NUMBER;

if (string.is8Bit()) {

if (!parseSimpleLength(string.characters8(), length, unit, number))

return nullptr;

} else {

if (!parseSimpleLength(string.characters16(), length, unit, number))

return nullptr;

}

if (unit == CSSUnitType::CSS_NUMBER) {

if (number && cssParserMode != SVGAttributeMode)

return nullptr;

unit = CSSUnitType::CSS_PX;

}

if (number < 0 && !acceptsNegativeNumbers)

return nullptr;

if (std::isinf(number))

return nullptr;

return CSSPrimitiveValue::create(number, unit);

{

int length = end - string;

if (length < 1)

return 0;

bool decimalMarkSeen = false;

int processedLength = 0;

for (int i = 0; i < length; ++i) {

if (string[i] == terminator) {

processedLength = i;

break;

}

if (!isASCIIDigit(string[i])) {

if (!decimalMarkSeen && string[i] == '.')

decimalMarkSeen = true;

else

return 0;

}

}

if (decimalMarkSeen && processedLength == 1)

return 0;

return processedLength;

{

int length = checkForValidDouble(string, end, terminator);

if (!length)

return 0;

int position = 0;

double localValue = 0;

// The consumed characters here are guaranteed to be

// ASCII digits with or without a decimal mark

for (; position < length; ++position) {

if (string[position] == '.')

break;

localValue = localValue * 10 + string[position] - '0';

}

if (++position == length) {

value = localValue;

return length;

}

double fraction = 0;

double scale = 1;

const double maxScale = 1000000;

while (position < length && scale < maxScale) {

fraction = fraction * 10 + string[position++] - '0';

scale *= 10;

}

value = localValue + fraction / scale;

return length;

{

const CharacterType* current = string;

double localValue = 0;

bool negative = false;

while (current != end && isHTMLSpace<CharacterType>(*current))

current++;

if (current != end && *current == '-') {

negative = true;

current++;

}

if (current == end || !isASCIIDigit(*current))

return std::nullopt;

while (current != end && isASCIIDigit(*current)) {

double newValue = localValue * 10 + *current++ - '0';

if (newValue >= 255) {

// Clamp values at 255.

localValue = 255;

while (current != end && isASCIIDigit(*current))

++current;

break;

}

localValue = newValue;

}

if (current == end)

return std::nullopt;

if (expect == CSSUnitType::CSS_NUMBER && (*current == '.' || *current == '%'))

return std::nullopt;

if (*current == '.') {

// We already parsed the integral part, try to parse

// the fraction part of the percentage value.

double percentage = 0;

int numCharactersParsed = parseDouble(current, end, '%', percentage);

if (!numCharactersParsed)

return std::nullopt;

current += numCharactersParsed;

if (*current != '%')

return std::nullopt;

localValue += percentage;

}

if (expect == CSSUnitType::CSS_PERCENTAGE && *current != '%')

return std::nullopt;

if (*current == '%') {

expect = CSSUnitType::CSS_PERCENTAGE;

localValue = localValue / 100.0 * 255.0;

// Clamp values at 255 for percentages over 100%

if (localValue > 255)

localValue = 255;

current++;

} else

expect = CSSUnitType::CSS_NUMBER;

while (current != end && isHTMLSpace<CharacterType>(*current))

current++;

if (current == end || *current++ != terminator)

return std::nullopt;

string = current;

// Clamp negative values at zero.

ASSERT(localValue <= 255);

return negative ? 0 : static_cast<uint8_t>(localValue);

{

// "0.X"

if (length == 3 && string[0] == '0' && string[1] == '.' && isASCIIDigit(string[2]))

return true;

// ".X"

if (length == 2 && string[0] == '.' && isASCIIDigit(string[1]))

return true;

return false;

{

while (string != end && isHTMLSpace<CharacterType>(*string))

string++;

bool negative = false;

if (string != end && *string == '-') {

negative = true;

string++;

}

int length = end - string;

if (length < 2)

return std::nullopt;

if (string[length - 1] != terminator || !isASCIIDigit(string[length - 2]))

return std::nullopt;

if (string[0] != '0' && string[0] != '1' && string[0] != '.') {

if (checkForValidDouble(string, end, terminator)) {

string = end;

return negative ? 0 : 255;

}

return std::nullopt;

}

if (length == 2 && string[0] != '.') {

uint8_t result = !negative && string[0] == '1' ? 255 : 0;

string = end;

return result;

}

if (isTenthAlpha(string, length - 1)) {

static constexpr uint8_t tenthAlphaValues[] = { 0, 26, 51, 77, 102, 128, 153, 179, 204, 230 };

uint8_t result = negative ? 0 : tenthAlphaValues[string[length - 2] - '0'];

string = end;

return result;

}

double alpha = 0;

if (!parseDouble(string, end, terminator, alpha))

return std::nullopt;

string = end;

return negative ? 0 : convertFloatAlphaTo<uint8_t>(alpha);

{

if (length < 5)

return false;

return characters[4] == '('

&& isASCIIAlphaCaselessEqual(characters[0], 'r')

&& isASCIIAlphaCaselessEqual(characters[1], 'g')

&& isASCIIAlphaCaselessEqual(characters[2], 'b')

&& isASCIIAlphaCaselessEqual(characters[3], 'a');

{

if (length < 4)

return false;

return characters[3] == '('

&& isASCIIAlphaCaselessEqual(characters[0], 'r')

&& isASCIIAlphaCaselessEqual(characters[1], 'g')

&& isASCIIAlphaCaselessEqual(characters[2], 'b');

{

switch (length) {

case 3:

// #abc converts to #aabbcc

// FIXME: Replace conversion to PackedColor::ARGB with simpler bit math to construct

// the SRGBA<uint8_t> directly.

return asSRGBA(PackedColor::ARGB {

0xFF000000

| (value & 0xF00) << 12 | (value & 0xF00) << 8

| (value & 0xF0) << 8 | (value & 0xF0) << 4

| (value & 0xF) << 4 | (value & 0xF) });

case 4:

// #abcd converts to ddaabbcc since alpha bytes are the high bytes.

// FIXME: Replace conversion to PackedColor::ARGB with simpler bit math to construct

// the SRGBA<uint8_t> directly.

return asSRGBA(PackedColor::ARGB {

(value & 0xF) << 28 | (value & 0xF) << 24

| (value & 0xF000) << 8 | (value & 0xF000) << 4

| (value & 0xF00) << 4 | (value & 0xF00)

| (value & 0xF0) | (value & 0xF0) >> 4 });

case 6:

// FIXME: Replace conversion to PackedColor::ARGB with simpler bit math to construct

// the SRGBA<uint8_t> directly.

return asSRGBA(PackedColor::ARGB { 0xFF000000 | value });

case 8:

return asSRGBA(PackedColor::RGBA { value });

}

return std::nullopt;

{

if (length != 3 && length != 4 && length != 6 && length != 8)

return std::nullopt;

uint32_t value = 0;

for (unsigned i = 0; i < length; ++i) {

auto digit = characters[i];

if (!isASCIIHexDigit(digit))

return std::nullopt;

value <<= 4;

value |= toASCIIHexValue(digit);

}

return finishParsingHexColor(value, length);

{

if (length >= 4 && characters[0] == '#') {

if (auto hexColor = parseHexColorInternal(characters + 1, length - 1))

return *hexColor;

}

if (!strict && (length == 3 || length == 6)) {

if (auto hexColor = parseHexColorInternal(characters, length))

return *hexColor;

}

auto expect = CSSUnitType::CSS_UNKNOWN;

// Try rgba() syntax.

if (mightBeRGBA(characters, length)) {

auto current = characters + 5;

auto end = characters + length;

auto red = parseColorIntOrPercentage(current, end, ',', expect);

if (!red)

return std::nullopt;

auto green = parseColorIntOrPercentage(current, end, ',', expect);

if (!green)

return std::nullopt;

auto blue = parseColorIntOrPercentage(current, end, ',', expect);

if (!blue)

return std::nullopt;

auto alpha = parseAlphaValue(current, end, ')');

if (!alpha)

return std::nullopt;

if (current != end)

return std::nullopt;

return SRGBA<uint8_t> { *red, *green, *blue, *alpha };

}

// Try rgb() syntax.

if (mightBeRGB(characters, length)) {

auto current = characters + 4;

auto end = characters + length;

auto red = parseColorIntOrPercentage(current, end, ',', expect);

if (!red)

return std::nullopt;

auto green = parseColorIntOrPercentage(current, end, ',', expect);

if (!green)

return std::nullopt;

auto blue = parseColorIntOrPercentage(current, end, ')', expect);

if (!blue)

return std::nullopt;

if (current != end)

return std::nullopt;

return SRGBA<uint8_t> { *red, *green, *blue };

}

return std::nullopt;

{

bool strict = !isQuirksModeBehavior(context.mode);

if (string.is8Bit())

return parseNumericColor(string.characters8(), string.length(), strict);

return parseNumericColor(string.characters16(), string.length(), strict);

{

ASSERT(!string.isEmpty());

auto valueID = cssValueKeywordID(string);

if (StyleColor::isColorKeyword(valueID)) {

if (!isValueAllowedInMode(valueID, context.mode))

return nullptr;

return CSSValuePool::singleton().createIdentifierValue(valueID);

}

if (auto color = parseNumericColor(string, context))

return CSSValuePool::singleton().createColorValue(*color);

return nullptr;

{

buffer[length] = '\0';

auto namedColor = findColor(buffer, length);

if (!namedColor)

return std::nullopt;

return asSRGBA(PackedColor::ARGB { namedColor->ARGBValue });

{

char buffer[64]; // Easily big enough for the longest color name.

if (length > sizeof(buffer) - 1)

return std::nullopt;

for (unsigned i = 0; i < length; ++i) {

auto character = characters[i];

if (!character || !isASCII(character))

return std::nullopt;

buffer[i] = toASCIILower(static_cast<char>(character));

}

return finishParsingNamedColor(buffer, length);

{

if (auto color = parseNumericColor(characters, length, strict))

return color;

return parseNamedColorInternal(characters, length);

{

if (string.is8Bit())

return parseSimpleColorInternal(string.characters8(), string.length(), strict);

return parseSimpleColorInternal(string.characters16(), string.length(), strict);

{

if (string.is8Bit())

return parseHexColorInternal(string.characters8(), string.length());

return parseHexColorInternal(string.characters16(), string.length());

{

if (string.is8Bit())

return parseNamedColorInternal(string.characters8(), string.length());

return parseNamedColorInternal(string.characters16(), string.length());

{

#if !ENABLE(OVERFLOW_SCROLLING_TOUCH)

UNUSED_PARAM(context);

#endif

if (valueID == CSSValueInvalid || !isValueAllowedInMode(valueID, context.mode))

return false;

switch (propertyId) {

case CSSPropertyAlignmentBaseline:

// auto | baseline | before-edge | text-before-edge | middle |

// central | after-edge | text-after-edge | ideographic | alphabetic |

// hanging | mathematical

return valueID == CSSValueAuto || valueID == CSSValueAlphabetic || valueID == CSSValueBaseline

|| valueID == CSSValueMiddle || (valueID >= CSSValueBeforeEdge && valueID <= CSSValueMathematical);

case CSSPropertyAll:

return false; // Only accepts css-wide keywords

case CSSPropertyBackgroundRepeatX: // repeat | no-repeat

case CSSPropertyBackgroundRepeatY: // repeat | no-repeat

return valueID == CSSValueRepeat || valueID == CSSValueNoRepeat;

case CSSPropertyBorderCollapse: // collapse | separate

return valueID == CSSValueCollapse || valueID == CSSValueSeparate;

case CSSPropertyBorderTopStyle: // <border-style>

case CSSPropertyBorderRightStyle: // Defined as: none | hidden | dotted | dashed |

case CSSPropertyBorderBottomStyle: // solid | double | groove | ridge | inset | outset

case CSSPropertyBorderLeftStyle:

case CSSPropertyBorderBlockEndStyle:

case CSSPropertyBorderBlockStartStyle:

case CSSPropertyBorderInlineEndStyle:

case CSSPropertyBorderInlineStartStyle:

case CSSPropertyColumnRuleStyle:

return valueID >= CSSValueNone && valueID <= CSSValueDouble;

case CSSPropertyBoxSizing:

return valueID == CSSValueBorderBox || valueID == CSSValueContentBox;

case CSSPropertyBufferedRendering:

return valueID == CSSValueAuto || valueID == CSSValueDynamic || valueID == CSSValueStatic;

case CSSPropertyCaptionSide: // top | bottom | left | right

return valueID == CSSValueLeft || valueID == CSSValueRight || valueID == CSSValueTop || valueID == CSSValueBottom;

case CSSPropertyClear: // none | inline-start | inline-end | left | right | both

return valueID == CSSValueNone || valueID == CSSValueInlineStart || valueID == CSSValueInlineEnd || valueID == CSSValueLeft || valueID == CSSValueRight || valueID == CSSValueBoth;

case CSSPropertyClipRule:

case CSSPropertyFillRule:

return valueID == CSSValueNonzero || valueID == CSSValueEvenodd;

case CSSPropertyColorInterpolation:

case CSSPropertyColorInterpolationFilters:

return valueID == CSSValueAuto || valueID == CSSValueSRGB || valueID == CSSValueLinearRGB;

case CSSPropertyDirection: // ltr | rtl

return valueID == CSSValueLtr || valueID == CSSValueRtl;

case CSSPropertyDominantBaseline:

// auto | use-script | no-change | reset-size | ideographic |

// alphabetic | hanging | mathematical | central | middle |

// text-after-edge | text-before-edge

return valueID == CSSValueAuto || valueID == CSSValueAlphabetic || valueID == CSSValueMiddle

|| (valueID >= CSSValueUseScript && valueID <= CSSValueResetSize)

|| (valueID >= CSSValueCentral && valueID <= CSSValueMathematical);

case CSSPropertyEmptyCells: // show | hide

return valueID == CSSValueShow || valueID == CSSValueHide;

case CSSPropertyFloat: // inline-start | inline-end | left | right | none

return valueID == CSSValueInlineStart || valueID == CSSValueInlineEnd || valueID == CSSValueLeft || valueID == CSSValueRight || valueID == CSSValueNone;

case CSSPropertyImageOrientation: // from-image | none

return valueID == CSSValueFromImage || valueID == CSSValueNone;

case CSSPropertyImageRendering: // auto | optimizeContrast | pixelated | optimizeSpeed | crispEdges | optimizeQuality | webkit-crispEdges

return valueID == CSSValueAuto || valueID == CSSValueOptimizeSpeed || valueID == CSSValueOptimizeQuality || valueID == CSSValueWebkitCrispEdges || valueID == CSSValueWebkitOptimizeContrast || valueID == CSSValueCrispEdges || valueID == CSSValuePixelated;

case CSSPropertyInputSecurity:

return valueID == CSSValueAuto || valueID == CSSValueNone;

#if ENABLE(CSS_COMPOSITING)

case CSSPropertyIsolation: // auto | isolate

return valueID == CSSValueAuto || valueID == CSSValueIsolate;

#endif

case CSSPropertyListStylePosition: // inside | outside

return valueID == CSSValueInside || valueID == CSSValueOutside;

case CSSPropertyListStyleType:

// See section CSS_PROP_LIST_STYLE_TYPE of file CSSValueKeywords.in

// for the list of supported list-style-types.

return CSSPropertyParserHelpers::isPredefinedCounterStyle(valueID) || valueID == CSSValueNone;

case CSSPropertyMaskType:

return valueID == CSSValueLuminance || valueID == CSSValueAlpha;

case CSSPropertyMathStyle:

return valueID == CSSValueNormal || valueID == CSSValueCompact;

case CSSPropertyObjectFit:

return valueID == CSSValueFill || valueID == CSSValueContain || valueID == CSSValueCover || valueID == CSSValueNone || valueID == CSSValueScaleDown;

case CSSPropertyOutlineStyle: // (<border-style> except hidden) | auto

return valueID == CSSValueAuto || valueID == CSSValueNone || (valueID >= CSSValueInset && valueID <= CSSValueDouble);

// FIXME-NEWPARSER: Support?

// case CSSPropertyOverflowAnchor:

// return valueID == CSSValueNone || valueID == CSSValueAuto;

case CSSPropertyOverflowWrap: // normal | break-word | anywhere

return valueID == CSSValueNormal || valueID == CSSValueBreakWord || valueID == CSSValueAnywhere;

case CSSPropertyOverflowX: // visible | hidden | scroll | auto | overlay (overlay is a synonym for auto)

if (context.overflowClipEnabled && valueID == CSSValueClip)

return true;

return valueID == CSSValueVisible || valueID == CSSValueHidden || valueID == CSSValueScroll || valueID == CSSValueAuto || valueID == CSSValueOverlay;

case CSSPropertyOverflowY: // visible | hidden | scroll | auto | overlay | -webkit-paged-x | -webkit-paged-y (overlay is a synonym for auto)

if (context.overflowClipEnabled && valueID == CSSValueClip)

return true;

return valueID == CSSValueVisible || valueID == CSSValueHidden || valueID == CSSValueScroll || valueID == CSSValueAuto || valueID == CSSValueOverlay || valueID == CSSValueWebkitPagedX || valueID == CSSValueWebkitPagedY;

case CSSPropertyOverscrollBehaviorBlock:

case CSSPropertyOverscrollBehaviorInline:

case CSSPropertyOverscrollBehaviorX:

case CSSPropertyOverscrollBehaviorY:

return valueID == CSSValueAuto || valueID == CSSValueContain || valueID == CSSValueNone;

case CSSPropertyBreakAfter:

case CSSPropertyBreakBefore:

return valueID == CSSValueAuto || valueID == CSSValueAvoid || valueID == CSSValueAvoidPage || valueID == CSSValuePage || valueID == CSSValueLeft || valueID == CSSValueRight || valueID == CSSValueRecto || valueID == CSSValueVerso || valueID == CSSValueAvoidColumn || valueID == CSSValueColumn;

case CSSPropertyBreakInside:

return valueID == CSSValueAuto || valueID == CSSValueAvoid || valueID == CSSValueAvoidPage || valueID == CSSValueAvoidColumn;

case CSSPropertyPointerEvents:

// none | visiblePainted | visibleFill | visibleStroke | visible |

// painted | fill | stroke | auto | all | bounding-box

return valueID == CSSValueVisible || valueID == CSSValueNone || valueID == CSSValueAll || valueID == CSSValueAuto || valueID == CSSValueBoundingBox || (valueID >= CSSValueVisiblePainted && valueID <= CSSValueStroke);

case CSSPropertyPosition: // static | relative | absolute | fixed | sticky

return valueID == CSSValueStatic

|| valueID == CSSValueRelative

|| valueID == CSSValueAbsolute

|| valueID == CSSValueFixed

|| valueID == CSSValueSticky || valueID == CSSValueWebkitSticky;

case CSSPropertyResize: // none | both | horizontal | vertical | block | inline | auto

return valueID == CSSValueNone || valueID == CSSValueBoth || valueID == CSSValueHorizontal || valueID == CSSValueVertical || valueID == CSSValueBlock || valueID == CSSValueInline || valueID == CSSValueAuto;

case CSSPropertyShapeRendering:

return valueID == CSSValueAuto || valueID == CSSValueOptimizeSpeed || valueID == CSSValueCrispedges || valueID == CSSValueGeometricPrecision;

case CSSPropertyStrokeLinejoin:

return valueID == CSSValueMiter || valueID == CSSValueRound || valueID == CSSValueBevel;

case CSSPropertyStrokeLinecap:

return valueID == CSSValueButt || valueID == CSSValueRound || valueID == CSSValueSquare;

case CSSPropertyTableLayout: // auto | fixed

return valueID == CSSValueAuto || valueID == CSSValueFixed;

case CSSPropertyTextAlign:

return (valueID >= CSSValueWebkitAuto && valueID <= CSSValueInternalThCenter) || valueID == CSSValueStart || valueID == CSSValueEnd;

case CSSPropertyTextAlignLast:

// auto | start | end | left | right | center | justify | match-parent

return (valueID >= CSSValueLeft && valueID <= CSSValueJustify) || valueID == CSSValueStart || valueID == CSSValueEnd || valueID == CSSValueAuto || valueID == CSSValueMatchParent;

case CSSPropertyTextAnchor:

return valueID == CSSValueStart || valueID == CSSValueMiddle || valueID == CSSValueEnd;

case CSSPropertyTextDecorationStyle:

// solid | double | dotted | dashed | wavy

return valueID == CSSValueSolid || valueID == CSSValueDouble || valueID == CSSValueDotted || valueID == CSSValueDashed || valueID == CSSValueWavy;

case CSSPropertyTextJustify:

// auto | none | inter-word | inter-character | distribute

return valueID == CSSValueInterWord || valueID == CSSValueInterCharacter || valueID == CSSValueDistribute || valueID == CSSValueAuto || valueID == CSSValueNone;

case CSSPropertyTextOrientation:

// mixed | upright | sideways

return valueID == CSSValueMixed || valueID == CSSValueUpright || valueID == CSSValueSideways;

case CSSPropertyTextOverflow: // clip | ellipsis

return valueID == CSSValueClip || valueID == CSSValueEllipsis;

case CSSPropertyTextRendering: // auto | optimizeSpeed | optimizeLegibility | geometricPrecision

return valueID == CSSValueAuto || valueID == CSSValueOptimizeSpeed || valueID == CSSValueOptimizeLegibility || valueID == CSSValueGeometricPrecision;

case CSSPropertyTextTransform: // capitalize | uppercase | lowercase | none

return (valueID >= CSSValueCapitalize && valueID <= CSSValueLowercase) || valueID == CSSValueNone;

case CSSPropertyUnicodeBidi:

return valueID == CSSValueNormal || valueID == CSSValueEmbed

|| valueID == CSSValueBidiOverride

|| valueID == CSSValueIsolate || valueID == CSSValueWebkitIsolate

|| valueID == CSSValueIsolateOverride || valueID == CSSValueWebkitIsolateOverride

|| valueID == CSSValuePlaintext || valueID == CSSValueWebkitPlaintext;

case CSSPropertyVectorEffect:

return valueID == CSSValueNone || valueID == CSSValueNonScalingStroke;

case CSSPropertyVisibility: // visible | hidden | collapse

return valueID == CSSValueVisible || valueID == CSSValueHidden || valueID == CSSValueCollapse;

case CSSPropertyAppearance: {

if (valueID == CSSValueDefaultButton)

return context.useSystemAppearance;

#if ENABLE(ATTACHMENT_ELEMENT)

if (valueID == CSSValueAttachment || valueID == CSSValueBorderlessAttachment)

return DeprecatedGlobalSettings::attachmentElementEnabled();

#endif

return (valueID >= CSSValueCheckbox && valueID <= CSSValueTextfield) || valueID == CSSValueNone || valueID == CSSValueAuto;

}

case CSSPropertyBackfaceVisibility:

return valueID == CSSValueVisible || valueID == CSSValueHidden;

#if ENABLE(CSS_COMPOSITING)

case CSSPropertyMixBlendMode:

return valueID == CSSValueNormal || valueID == CSSValueMultiply || valueID == CSSValueScreen || valueID == CSSValueOverlay

|| valueID == CSSValueDarken || valueID == CSSValueLighten || valueID == CSSValueColorDodge || valueID == CSSValueColorBurn

|| valueID == CSSValueHardLight || valueID == CSSValueSoftLight || valueID == CSSValueDifference || valueID == CSSValueExclusion

|| valueID == CSSValueHue || valueID == CSSValueSaturation || valueID == CSSValueColor || valueID == CSSValueLuminosity || valueID == CSSValuePlusDarker || valueID == CSSValuePlusLighter;

#endif

case CSSPropertyWebkitBoxAlign:

return valueID == CSSValueStretch || valueID == CSSValueStart || valueID == CSSValueEnd || valueID == CSSValueCenter || valueID == CSSValueBaseline;

#if ENABLE(CSS_BOX_DECORATION_BREAK)

case CSSPropertyWebkitBoxDecorationBreak:

return valueID == CSSValueClone || valueID == CSSValueSlice;

case CSSPropertyWebkitBoxDirection:

return valueID == CSSValueNormal || valueID == CSSValueReverse;

#endif

case CSSPropertyWebkitBoxLines:

return valueID == CSSValueSingle || valueID == CSSValueMultiple;

case CSSPropertyWebkitBoxOrient:

return valueID == CSSValueHorizontal || valueID == CSSValueVertical || valueID == CSSValueInlineAxis || valueID == CSSValueBlockAxis;

case CSSPropertyWebkitBoxPack:

return valueID == CSSValueStart || valueID == CSSValueEnd || valueID == CSSValueCenter || valueID == CSSValueJustify;

#if ENABLE(CURSOR_VISIBILITY)

case CSSPropertyWebkitCursorVisibility:

return valueID == CSSValueAuto || valueID == CSSValueAutoHide;

#endif

case CSSPropertyColumnFill:

return valueID == CSSValueAuto || valueID == CSSValueBalance;

case CSSPropertyWebkitColumnAxis:

return valueID == CSSValueHorizontal || valueID == CSSValueVertical || valueID == CSSValueAuto;

case CSSPropertyWebkitColumnProgression:

return valueID == CSSValueNormal || valueID == CSSValueReverse;

case CSSPropertyFlexDirection:

return valueID == CSSValueRow || valueID == CSSValueRowReverse || valueID == CSSValueColumn || valueID == CSSValueColumnReverse;

case CSSPropertyFlexWrap:

return valueID == CSSValueNowrap || valueID == CSSValueWrap || valueID == CSSValueWrapReverse;

case CSSPropertyWebkitHyphens:

return valueID == CSSValueAuto || valueID == CSSValueNone || valueID == CSSValueManual;

case CSSPropertyFontKerning:

return valueID == CSSValueAuto || valueID == CSSValueNormal || valueID == CSSValueNone;

case CSSPropertyWebkitFontSmoothing:

return valueID == CSSValueAuto || valueID == CSSValueNone || valueID == CSSValueAntialiased || valueID == CSSValueSubpixelAntialiased;

case CSSPropertyWebkitLineAlign:

return valueID == CSSValueNone || valueID == CSSValueEdges;

case CSSPropertyLineBreak: // auto | loose | normal | strict | after-white-space | anywhere

return valueID == CSSValueAuto || valueID == CSSValueLoose || valueID == CSSValueNormal || valueID == CSSValueStrict || valueID == CSSValueAfterWhiteSpace || valueID == CSSValueAnywhere;

case CSSPropertyWebkitLineSnap:

return valueID == CSSValueNone || valueID == CSSValueBaseline || valueID == CSSValueContain;

case CSSPropertyPrintColorAdjust:

return valueID == CSSValueExact || valueID == CSSValueEconomy;

case CSSPropertyWebkitRtlOrdering:

return valueID == CSSValueLogical || valueID == CSSValueVisual;

case CSSPropertyWebkitRubyPosition:

return valueID == CSSValueBefore || valueID == CSSValueAfter || valueID == CSSValueInterCharacter;

case CSSPropertyWebkitTextCombine:

return valueID == CSSValueNone || valueID == CSSValueHorizontal;

case CSSPropertyTextCombineUpright:

return valueID == CSSValueNone || valueID == CSSValueAll;

case CSSPropertyWebkitTextSecurity: // disc | circle | square | none

return valueID == CSSValueDisc || valueID == CSSValueCircle || valueID == CSSValueSquare || valueID == CSSValueNone;

case CSSPropertyTransformStyle:

return valueID == CSSValueFlat

|| valueID == CSSValuePreserve3d

#if ENABLE(CSS_TRANSFORM_STYLE_OPTIMIZED_3D)

|| (valueID == CSSValueOptimized3d && context.transformStyleOptimized3DEnabled)

#endif

;

case CSSPropertyWebkitUserDrag: // auto | none | element

return valueID == CSSValueAuto || valueID == CSSValueNone || valueID == CSSValueElement;

case CSSPropertyWebkitUserModify: // read-only | read-write

return valueID == CSSValueReadOnly || valueID == CSSValueReadWrite || valueID == CSSValueReadWritePlaintextOnly;

case CSSPropertyWebkitUserSelect: // auto | none | text | all

return valueID == CSSValueAuto || valueID == CSSValueNone || valueID == CSSValueText || valueID == CSSValueAll;

case CSSPropertyWritingMode:

// Note that horizontal-bt is not supported by the unprefixed version of

// the property, only by the -webkit- version.

return (valueID >= CSSValueHorizontalTb && valueID <= CSSValueHorizontalBt)

|| valueID == CSSValueLrTb || valueID == CSSValueRlTb || valueID == CSSValueTbRl

|| valueID == CSSValueLr || valueID == CSSValueRl || valueID == CSSValueTb;

case CSSPropertyWhiteSpace: // normal | pre | nowrap | pre-line | nowrap | break-spacess

return valueID == CSSValueNormal || valueID == CSSValuePre || valueID == CSSValuePreWrap || valueID == CSSValuePreLine || valueID == CSSValueNowrap || valueID == CSSValueBreakSpaces;

case CSSPropertyWordBreak: // normal | break-all | keep-all | break-word (this is a custom extension)

return valueID == CSSValueNormal || valueID == CSSValueBreakAll || valueID == CSSValueKeepAll || valueID == CSSValueBreakWord;

#if ENABLE(CSS_TRAILING_WORD)

case CSSPropertyAppleTrailingWord: // auto | -apple-partially-balanced

return valueID == CSSValueAuto || valueID == CSSValueWebkitPartiallyBalanced;

#endif

#if ENABLE(APPLE_PAY)

case CSSPropertyApplePayButtonStyle: // white | white-outline | black

return valueID == CSSValueWhite || valueID == CSSValueWhiteOutline || valueID == CSSValueBlack;

case CSSPropertyApplePayButtonType: // plain | buy | set-up | donate | check-out | book | subscribe | reload | add-money | top-up | order | rent | support | contribute | tip

return (valueID == CSSValuePlain

|| valueID == CSSValueBuy

|| valueID == CSSValueSetUp

|| valueID == CSSValueDonate

|| valueID == CSSValueCheckOut

|| valueID == CSSValueBook

|| valueID == CSSValueSubscribe

#if ENABLE(APPLE_PAY_NEW_BUTTON_TYPES)

|| valueID == CSSValueReload

|| valueID == CSSValueAddMoney

|| valueID == CSSValueTopUp

|| valueID == CSSValueOrder

|| valueID == CSSValueRent

|| valueID == CSSValueSupport

|| valueID == CSSValueContribute

|| valueID == CSSValueTip

#endif

);

#endif

case CSSPropertyWebkitNbspMode: // normal | space

return valueID == CSSValueNormal || valueID == CSSValueSpace;

case CSSPropertyWebkitTextZoom:

return valueID == CSSValueNormal || valueID == CSSValueReset;

#if PLATFORM(IOS_FAMILY)

// Apple specific property. These will never be standardized and is purely to

// support custom WebKit-based Apple applications.

case CSSPropertyWebkitTouchCallout:

return valueID == CSSValueDefault || valueID == CSSValueNone;

#endif

case CSSPropertyWebkitMarqueeDirection:

return valueID == CSSValueForwards || valueID == CSSValueBackwards || valueID == CSSValueAhead || valueID == CSSValueReverse || valueID == CSSValueLeft || valueID == CSSValueRight || valueID == CSSValueDown

|| valueID == CSSValueUp || valueID == CSSValueAuto;

case CSSPropertyWebkitMarqueeStyle:

return valueID == CSSValueNone || valueID == CSSValueSlide || valueID == CSSValueScroll || valueID == CSSValueAlternate;

case CSSPropertyFontVariantPosition: // normal | sub | super

return valueID == CSSValueNormal || valueID == CSSValueSub || valueID == CSSValueSuper;

case CSSPropertyFontVariantCaps: // normal | small-caps | all-small-caps | petite-caps | all-petite-caps | unicase | titling-caps

return valueID == CSSValueNormal || valueID == CSSValueSmallCaps || valueID == CSSValueAllSmallCaps || valueID == CSSValuePetiteCaps || valueID == CSSValueAllPetiteCaps || valueID == CSSValueUnicase || valueID == CSSValueTitlingCaps;

case CSSPropertyFontVariantAlternates: // We only support the normal and historical-forms values.

return valueID == CSSValueNormal || valueID == CSSValueHistoricalForms;

#if ENABLE(OVERFLOW_SCROLLING_TOUCH)

case CSSPropertyWebkitOverflowScrolling:

return valueID == CSSValueAuto || valueID == CSSValueTouch;

#endif

#if ENABLE(VARIATION_FONTS)

case CSSPropertyFontOpticalSizing:

return valueID == CSSValueAuto || valueID == CSSValueNone;

#endif

case CSSPropertyTextDecorationSkipInk:

return valueID == CSSValueAuto || valueID == CSSValueNone || valueID == CSSValueAll;

case CSSPropertyContainerType:

// FIXME: Support 'style'. It will require parsing the value as a list.

return valueID == CSSValueNormal || valueID == CSSValueSize || valueID == CSSValueInlineSize;

default:

ASSERT_NOT_REACHED();

return false;

}

{

switch (propertyId) {

case CSSPropertyBorderBlockEndStyle:

case CSSPropertyBorderBlockStartStyle:

case CSSPropertyBorderBottomStyle:

case CSSPropertyBorderCollapse:

case CSSPropertyBorderInlineEndStyle:

case CSSPropertyBorderInlineStartStyle:

case CSSPropertyBorderLeftStyle:

case CSSPropertyBorderRightStyle:

case CSSPropertyBorderTopStyle:

case CSSPropertyBoxSizing:

case CSSPropertyBreakAfter:

case CSSPropertyBreakBefore:

case CSSPropertyBreakInside:

case CSSPropertyCaptionSide:

case CSSPropertyClear:

case CSSPropertyColumnFill:

case CSSPropertyWebkitColumnProgression:

case CSSPropertyColumnRuleStyle:

case CSSPropertyDirection:

case CSSPropertyEmptyCells:

case CSSPropertyFlexDirection:

case CSSPropertyFlexWrap:

case CSSPropertyFloat:

case CSSPropertyFontKerning:

case CSSPropertyFontVariantAlternates:

case CSSPropertyFontVariantCaps:

case CSSPropertyFontVariantPosition:

case CSSPropertyImageOrientation:

case CSSPropertyImageRendering:

case CSSPropertyInputSecurity:

case CSSPropertyListStylePosition:

case CSSPropertyListStyleType:

case CSSPropertyObjectFit:

case CSSPropertyOutlineStyle:

case CSSPropertyOverflowWrap:

case CSSPropertyOverflowX:

case CSSPropertyOverflowY:

case CSSPropertyOverscrollBehaviorBlock:

case CSSPropertyOverscrollBehaviorInline:

case CSSPropertyOverscrollBehaviorX:

case CSSPropertyOverscrollBehaviorY:

case CSSPropertyPointerEvents:

case CSSPropertyPosition:

case CSSPropertyResize:

case CSSPropertyTableLayout:

case CSSPropertyTextAlign:

case CSSPropertyTextAlignLast:

case CSSPropertyTextJustify:

case CSSPropertyTextOrientation:

case CSSPropertyTextOverflow:

case CSSPropertyTextRendering:

case CSSPropertyTextTransform:

case CSSPropertyTransformStyle:

case CSSPropertyUnicodeBidi:

case CSSPropertyVisibility:

case CSSPropertyAppearance:

case CSSPropertyBackfaceVisibility:

case CSSPropertyWebkitBoxAlign:

case CSSPropertyWebkitBoxDirection:

case CSSPropertyWebkitBoxLines:

case CSSPropertyWebkitBoxOrient:

case CSSPropertyWebkitBoxPack:

case CSSPropertyWebkitColumnAxis:

case CSSPropertyWebkitFontSmoothing:

case CSSPropertyWebkitHyphens:

case CSSPropertyWebkitLineAlign:

case CSSPropertyLineBreak:

case CSSPropertyWebkitLineSnap:

case CSSPropertyWebkitMarqueeDirection:

case CSSPropertyWebkitMarqueeStyle:

case CSSPropertyWebkitNbspMode:

case CSSPropertyPrintColorAdjust:

case CSSPropertyWebkitRtlOrdering:

case CSSPropertyWebkitRubyPosition:

case CSSPropertyWebkitTextCombine:

case CSSPropertyTextCombineUpright:

case CSSPropertyTextDecorationStyle:

case CSSPropertyWebkitTextSecurity:

case CSSPropertyWebkitTextZoom:

case CSSPropertyWebkitUserDrag:

case CSSPropertyWebkitUserModify:

case CSSPropertyWebkitUserSelect:

case CSSPropertyWhiteSpace:

case CSSPropertyWordBreak:

// SVG CSS properties from SVG 1.1, Appendix N: Property Index.

case CSSPropertyAlignmentBaseline:

case CSSPropertyBufferedRendering:

case CSSPropertyClipRule:

case CSSPropertyColorInterpolation:

case CSSPropertyColorInterpolationFilters:

case CSSPropertyDominantBaseline: