2268 lines
No EOL
79 KiB
JavaScript
2268 lines
No EOL
79 KiB
JavaScript
'use strict';
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _postcssValueParser = require('postcss-value-parser');
|
|
|
|
var _postcssValueParser2 = _interopRequireDefault(_postcssValueParser);
|
|
|
|
var _cssColorNames = require('css-color-names');
|
|
|
|
var _cssColorNames2 = _interopRequireDefault(_cssColorNames);
|
|
|
|
var _endsWith = require('ends-with');
|
|
|
|
var _endsWith2 = _interopRequireDefault(_endsWith);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
function lowercase(value) {
|
|
return value.toLowerCase();
|
|
}
|
|
|
|
function isKeyword(_ref, values) {
|
|
var type = _ref.type;
|
|
var value = _ref.value;
|
|
|
|
if (type !== 'word') {
|
|
return false;
|
|
}
|
|
if (Array.isArray(values)) {
|
|
return ~values.map(lowercase).indexOf(lowercase(value));
|
|
}
|
|
return lowercase(value) === values;
|
|
}
|
|
|
|
function isFunction(node, values) {
|
|
if (node.type !== 'function') {
|
|
return false;
|
|
}
|
|
if (Array.isArray(values)) {
|
|
return ~values.map(lowercase).indexOf(lowercase(node.value));
|
|
}
|
|
return lowercase(node.value) === values;
|
|
}
|
|
|
|
var isVariable = function isVariable(node) {
|
|
return isFunction(node, 'var');
|
|
};
|
|
|
|
function isKeywordFactory(keywords) {
|
|
return function wrappedIsKeyword(parsed) {
|
|
if (parsed.nodes.length === 1) {
|
|
return isKeyword(parsed.nodes[0], keywords);
|
|
}
|
|
return false;
|
|
};
|
|
}
|
|
|
|
var isUrl = function isUrl(node) {
|
|
return isFunction(node, 'url');
|
|
};
|
|
|
|
var isInteger = function isInteger(_ref) {
|
|
var type = _ref.type;
|
|
var value = _ref.value;
|
|
|
|
if (type !== 'word') {
|
|
return false;
|
|
}
|
|
var int = (0, _postcssValueParser.unit)(value);
|
|
return int && !~value.indexOf('.') && !int.unit;
|
|
};
|
|
|
|
var isComma = function isComma(_ref) {
|
|
var type = _ref.type;
|
|
var value = _ref.value;
|
|
|
|
return type === 'div' && value === ',';
|
|
};
|
|
|
|
var isNumber = function isNumber(node) {
|
|
var value = node.value;
|
|
|
|
if (node.type !== 'word') {
|
|
return false;
|
|
}
|
|
|
|
return !isNaN(value) && !(0, _endsWith2.default)(value, '.');
|
|
};
|
|
|
|
var isPercentage = function isPercentage(_ref) {
|
|
var value = _ref.value;
|
|
|
|
var int = (0, _postcssValueParser.unit)(value);
|
|
return int && !(0, _endsWith2.default)(int.number, '.') && !~int.unit.indexOf('.') && int.unit === '%';
|
|
};
|
|
|
|
var namedColours = Object.keys(_cssColorNames2.default);
|
|
|
|
function isRgb(node) {
|
|
if (!isFunction(node, 'rgb')) {
|
|
return;
|
|
}
|
|
var valid = true;
|
|
(0, _postcssValueParser.walk)(node.nodes, function (child, index) {
|
|
var even = index % 2 === 0;
|
|
if (even && !isInteger(child) && !isPercentage(child) || !even && !isComma(child)) {
|
|
valid = false;
|
|
}
|
|
return false;
|
|
});
|
|
|
|
return valid && node.nodes.length === 5;
|
|
}
|
|
|
|
function isRgba(node) {
|
|
if (!isFunction(node, 'rgba')) {
|
|
return;
|
|
}
|
|
var valid = true;
|
|
(0, _postcssValueParser.walk)(node.nodes, function (child, index) {
|
|
var even = index % 2 === 0;
|
|
if (even && (index < 6 && !isInteger(child) && !isPercentage(child) || index > 5 && !isNumber(child)) || !even && !isComma(child)) {
|
|
valid = false;
|
|
}
|
|
return false;
|
|
});
|
|
|
|
return valid && node.nodes.length === 7;
|
|
}
|
|
|
|
function isHsl(node) {
|
|
if (!isFunction(node, 'hsl')) {
|
|
return;
|
|
}
|
|
var valid = true;
|
|
(0, _postcssValueParser.walk)(node.nodes, function (child, index) {
|
|
var even = index % 2 === 0;
|
|
if (even && (index < 1 && !isNumber(child) || index > 1 && !isPercentage(child)) || !even && !isComma(child)) {
|
|
valid = false;
|
|
}
|
|
return false;
|
|
});
|
|
|
|
return valid && node.nodes.length === 5;
|
|
}
|
|
|
|
function isHsla(node) {
|
|
if (!isFunction(node, 'hsla')) {
|
|
return;
|
|
}
|
|
var valid = true;
|
|
(0, _postcssValueParser.walk)(node.nodes, function (child, index) {
|
|
var even = index % 2 === 0;
|
|
if (even && ((index === 0 || index === 6) && !isNumber(child) || (index === 2 || index === 4) && !isPercentage(child)) || !even && !isComma(child)) {
|
|
valid = false;
|
|
}
|
|
return false;
|
|
});
|
|
|
|
return valid && node.nodes.length === 7;
|
|
}
|
|
|
|
function isHex(node) {
|
|
if (node.type !== 'word' || node.value[0] !== '#') {
|
|
return false;
|
|
}
|
|
var range = node.value.slice(1);
|
|
return ~[3, 4, 6, 8].indexOf(range.length) && !isNaN(parseInt(range, 16));
|
|
}
|
|
|
|
function isNamedColor(node) {
|
|
return isKeyword(node, namedColours);
|
|
}
|
|
|
|
function isCurrentColor(node) {
|
|
return isKeyword(node, 'currentcolor');
|
|
}
|
|
|
|
function isColor(node) {
|
|
return isRgb(node) || isRgba(node) || isHsl(node) || isHsla(node) || isHex(node) || isNamedColor(node) || isCurrentColor(node);
|
|
}
|
|
|
|
var brStyles = ['none', 'hidden', 'dotted', 'dashed', 'solid', 'double', 'groove', 'ridge', 'inset', 'outset'];
|
|
|
|
var isBrStyle = function isBrStyle(node) {
|
|
return isKeyword(node, brStyles);
|
|
};
|
|
|
|
var isSpace = function isSpace(_ref) {
|
|
var type = _ref.type;
|
|
|
|
return type === 'space';
|
|
};
|
|
|
|
var angles = ['deg', 'grad', 'rad', 'turn'];
|
|
|
|
var isAngle = function isAngle(_ref) {
|
|
var value = _ref.value;
|
|
|
|
var int = (0, _postcssValueParser.unit)(value);
|
|
return int && !(0, _endsWith2.default)(int.number, '.') && !~int.unit.indexOf('.') && (int.number === '0' || ~angles.indexOf(int.unit));
|
|
};
|
|
|
|
var units = ['s', 'ms'];
|
|
|
|
var isTime = function isTime(_ref) {
|
|
var value = _ref.value;
|
|
|
|
var int = (0, _postcssValueParser.unit)(value);
|
|
return int && !(0, _endsWith2.default)(int.number, '.') && !~int.unit.indexOf('.') && ~units.indexOf(int.unit);
|
|
};
|
|
|
|
var operators = ['+', '-', '*', '/'];
|
|
var operatorsRegExp = /[+\-\*\/]/i;
|
|
|
|
function isCalc(node) {
|
|
if (!isFunction(node, 'calc') || !node.nodes || !node.nodes.length) {
|
|
return false;
|
|
}
|
|
|
|
var valid = true;
|
|
var lastNonSpaceValue = false;
|
|
|
|
(0, _postcssValueParser.walk)(node.nodes, function (child) {
|
|
var type = child.type;
|
|
var value = child.value;
|
|
// if an expression starts with operator
|
|
|
|
if (!lastNonSpaceValue && ~operators.indexOf(value)) {
|
|
valid = false;
|
|
}
|
|
// store last non space node
|
|
if (type !== 'space') {
|
|
lastNonSpaceValue = value;
|
|
}
|
|
// only variables and () functions are allowed
|
|
if (!isVariable(child) && type === 'function') {
|
|
if (value.length > 0) {
|
|
valid = false;
|
|
}
|
|
if (!child.nodes.length || !child.nodes) {
|
|
valid = false;
|
|
}
|
|
}
|
|
// invalidate any invalid word node
|
|
if (type === 'word' && !isAngle(child) && !isLength(child) && !isTime(child) && !isInteger(child) && !isNumber(child) && !isPercentage(child) && operators.indexOf(value) < 0) {
|
|
// + and - must be surrounded by spaces
|
|
if (value.indexOf('+') > 0 || value.indexOf('-') > 0) {
|
|
valid = false;
|
|
}
|
|
// expression can't endwith operator
|
|
if (~operators.indexOf(value[value.length - 1])) {
|
|
valid = false;
|
|
}
|
|
// unknown word node w/o operators is invalid
|
|
if (!operatorsRegExp.test(value)) {
|
|
valid = false;
|
|
}
|
|
}
|
|
});
|
|
// if an expression ends with operator
|
|
if (~operators.indexOf(lastNonSpaceValue)) {
|
|
valid = false;
|
|
}
|
|
|
|
return valid;
|
|
}
|
|
|
|
var lengths = ['em', 'ex', 'ch', 'rem', 'vh', 'vw', 'vmin', 'vmax', 'px', 'q', 'mm', 'cm', 'in', 'pt', 'pc'];
|
|
|
|
var isLength = function isLength(node) {
|
|
if (isCalc(node)) {
|
|
return true;
|
|
}
|
|
if (node.type !== 'word') {
|
|
return false;
|
|
}
|
|
var int = (0, _postcssValueParser.unit)(node.value);
|
|
return int && !(0, _endsWith2.default)(int.number, '.') && !~int.unit.indexOf('.') && (int.number === '0' || ~lengths.indexOf(int.unit));
|
|
};
|
|
|
|
var brWidths = ['thin', 'medium', 'thick'];
|
|
|
|
var isBrWidth = function isBrWidth(node) {
|
|
return isLength(node) || isKeyword(node, brWidths);
|
|
};
|
|
|
|
var attachments = ['scroll', 'fixed', 'local'];
|
|
|
|
var isAttachment = function isAttachment(node) {
|
|
return isKeyword(node, attachments);
|
|
};
|
|
|
|
var singleValues = ['repeat-x', 'repeat-y'];
|
|
|
|
var multipleValues = ['repeat', 'space', 'round', 'no-repeat'];
|
|
|
|
var isRepeatStyle = function isRepeatStyle(parsed) {
|
|
var group = [];
|
|
var valid = true;
|
|
if (parsed.nodes[parsed.nodes.length - 1].type === 'div') {
|
|
return false;
|
|
}
|
|
parsed.walk(function (node) {
|
|
if (isKeyword(node, singleValues)) {
|
|
if (group.length) {
|
|
valid = false;
|
|
return false;
|
|
}
|
|
group.push(node);
|
|
} else if (isKeyword(node, multipleValues) || isVariable(node)) {
|
|
if (group.some(function (n) {
|
|
return isKeyword(n, singleValues);
|
|
}) || group.length === 2) {
|
|
valid = false;
|
|
return false;
|
|
}
|
|
group.push(node);
|
|
} else if (isComma(node)) {
|
|
group = [];
|
|
return false;
|
|
} else if (!isSpace(node)) {
|
|
valid = false;
|
|
}
|
|
return false;
|
|
});
|
|
return valid;
|
|
};
|
|
|
|
var singleAnimationDirections = ['normal', 'reverse', 'alternate', 'alternate-reverse'];
|
|
|
|
var isSingleAnimationDirection = function isSingleAnimationDirection(node) {
|
|
return isKeyword(node, singleAnimationDirections);
|
|
};
|
|
|
|
var singleAnimationFillModes = ['none', 'forwards', 'backwards', 'both'];
|
|
|
|
var isSingleAnimationFillMode = function isSingleAnimationFillMode(node) {
|
|
return isKeyword(node, singleAnimationFillModes);
|
|
};
|
|
|
|
var value = ['infinite'];
|
|
|
|
var isSingleAnimationIterationCount = function isSingleAnimationIterationCount(node) {
|
|
return isKeyword(node, value) || isNumber(node);
|
|
};
|
|
|
|
function isInvalid(value) {
|
|
return (/[^a-z0-9_-]/ig.test(value)
|
|
);
|
|
}
|
|
|
|
function isCodepoint(value) {
|
|
return (/\\u[a-f0-9]{1,6}/ig.test(value) || /\\[a-f0-9]{1,6}/ig.test(value)
|
|
);
|
|
}
|
|
|
|
function isValid(value) {
|
|
return !isInvalid(value) || isCodepoint(value);
|
|
}
|
|
|
|
var isCustomIdent = function isCustomIdent(_ref) {
|
|
var type = _ref.type;
|
|
var value = _ref.value;
|
|
|
|
if (type !== 'word') {
|
|
return false;
|
|
}
|
|
if (value[0] === '-') {
|
|
if (/[0-9]/.test(value[1])) {
|
|
return false;
|
|
}
|
|
if (value[1] === '-' && value[2] !== '-') {
|
|
return false;
|
|
}
|
|
return isValid(value);
|
|
}
|
|
return !/[0-9]/.test(value[0]) && isValid(value);
|
|
};
|
|
|
|
var isSingleAnimationName = function isSingleAnimationName(node) {
|
|
return isKeyword(node, 'none') || isCustomIdent(node);
|
|
};
|
|
|
|
var singleAnimationPlayStates = ['running', 'paused'];
|
|
|
|
var isSingleAnimationPlayState = function isSingleAnimationPlayState(node) {
|
|
return isKeyword(node, singleAnimationPlayStates);
|
|
};
|
|
|
|
var keywords = ['ease', 'linear', 'ease-in', 'ease-out', 'ease-in-out', 'step-start', 'step-end'];
|
|
|
|
var stepsKeywords = ['start', 'end'];
|
|
|
|
function isTimingKeyword(node) {
|
|
return isKeyword(node, keywords);
|
|
}
|
|
|
|
function isSteps(node) {
|
|
if (!isFunction(node, 'steps') || !isInteger(node.nodes[0])) {
|
|
return false;
|
|
}
|
|
var one = node.nodes[1];
|
|
var two = node.nodes[2];
|
|
if (one && !isComma(one)) {
|
|
return false;
|
|
}
|
|
if (two) {
|
|
return isKeyword(two, stepsKeywords);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
function isValidAbscissa(_ref) {
|
|
var type = _ref.type;
|
|
var value = _ref.value;
|
|
|
|
return type === 'word' && value >= 0 && value <= 1;
|
|
}
|
|
|
|
function isCubicBezier(node) {
|
|
if (!isFunction(node, 'cubic-bezier')) {
|
|
return false;
|
|
}
|
|
var valid = true;
|
|
(0, _postcssValueParser.walk)(node.nodes, function (child, index) {
|
|
var even = index % 2 === 0;
|
|
if (even && ((index === 0 || index === 4) && !isValidAbscissa(child) || (index === 2 || index === 6) && !isNumber(child)) || !even && !isComma(child)) {
|
|
valid = false;
|
|
}
|
|
return false;
|
|
});
|
|
|
|
return valid && node.nodes.length === 7;
|
|
}
|
|
|
|
var isSingleTransitionTimingFunction = function isSingleTransitionTimingFunction(node) {
|
|
return isTimingKeyword(node) || isSteps(node) || isCubicBezier(node);
|
|
};
|
|
|
|
var numberPercentages = ['brightness', 'contrast', 'grayscale', 'invert', 'opacity', 'sepia', 'saturate'];
|
|
|
|
function isNumberOrPercentage(node) {
|
|
if (!isFunction(node, numberPercentages)) {
|
|
return false;
|
|
}
|
|
var nodes = node.nodes;
|
|
|
|
return nodes.length === 1 && (isNumber(nodes[0]) || isPercentage(nodes[0]));
|
|
}
|
|
|
|
function isBlur(node) {
|
|
if (!isFunction(node, 'blur')) {
|
|
return false;
|
|
}
|
|
var nodes = node.nodes;
|
|
|
|
return nodes.length === 1 && isLength(nodes[0]);
|
|
}
|
|
|
|
function isDropShadow(node) {
|
|
if (!isFunction(node, 'drop-shadow')) {
|
|
return false;
|
|
}
|
|
var valid = true;
|
|
(0, _postcssValueParser.walk)(node.nodes, function (child, index) {
|
|
var even = index % 2 === 0;
|
|
if (even && index <= 2 && !isLength(child)) {
|
|
valid = false;
|
|
return false;
|
|
}
|
|
if (even && index === 4 && !isLength(child) && !isColor(child)) {
|
|
valid = false;
|
|
return false;
|
|
}
|
|
if (even && index === 6 && !isColor(child)) {
|
|
valid = false;
|
|
return false;
|
|
}
|
|
if (!even && !isSpace(child)) {
|
|
valid = false;
|
|
return false;
|
|
}
|
|
});
|
|
return valid && node.nodes.length <= 7;
|
|
}
|
|
|
|
function isHueRotate(node) {
|
|
if (!isFunction(node, 'hue-rotate')) {
|
|
return false;
|
|
}
|
|
var nodes = node.nodes;
|
|
|
|
return nodes.length === 1 && isAngle(nodes[0]);
|
|
}
|
|
|
|
function isFilterFunction(node) {
|
|
return isBlur(node) || isDropShadow(node) || isHueRotate(node) || isNumberOrPercentage(node);
|
|
}
|
|
|
|
function isFilterFunctionList(parsed) {
|
|
var valid = true;
|
|
parsed.walk(function (node, index) {
|
|
var even = index % 2 === 0;
|
|
if (even && !isFilterFunction(node) && !isVariable(node)) {
|
|
valid = false;
|
|
}
|
|
if (!even && !isSpace(node)) {
|
|
valid = false;
|
|
}
|
|
return false;
|
|
});
|
|
return valid;
|
|
}
|
|
|
|
var blendValues = ['normal', 'multiply', 'screen', 'overlay', 'darken', 'lighten', 'color-dodge', 'color-burn', 'hard-light', 'soft-light', 'difference', 'exclusion', 'hue', 'saturation', 'color', 'luminosity'];
|
|
|
|
var isBlendMode = function isBlendMode(node) {
|
|
return isKeyword(node, blendValues);
|
|
};
|
|
|
|
var boxes = ['border-box', 'padding-box', 'content-box'];
|
|
|
|
var isBox = function isBox(node) {
|
|
return isKeyword(node, boxes);
|
|
};
|
|
|
|
function getArguments(node) {
|
|
return node.nodes.reduce(function (list, child) {
|
|
if (isComma(child)) {
|
|
list.push([]);
|
|
} else {
|
|
list[list.length - 1].push(child);
|
|
}
|
|
return list;
|
|
}, [[]]);
|
|
}
|
|
|
|
var isLengthPercentage = function isLengthPercentage(node) {
|
|
return isLength(node) || isPercentage(node);
|
|
};
|
|
|
|
var left$1 = 'left';
|
|
var center = 'center';
|
|
var right$1 = 'right';
|
|
var top$1 = 'top';
|
|
var bottom$1 = 'bottom';
|
|
|
|
var horizontals$1 = [left$1, right$1, center];
|
|
var verticals$1 = [top$1, bottom$1, center];
|
|
|
|
function isKeywordOrVar(node, keywords) {
|
|
return isKeyword(node, keywords) || isVariable(node);
|
|
}
|
|
|
|
function isLengthPercentageOrVar(node) {
|
|
return isLengthPercentage(node) || isVariable(node);
|
|
}
|
|
|
|
function validateGroup(group) {
|
|
var length = group.length;
|
|
|
|
if (length === 1) {
|
|
if (!isKeywordOrVar(group[0], [left$1, center, right$1, top$1, bottom$1]) && !isLengthPercentage(group[0])) {
|
|
return false;
|
|
}
|
|
}
|
|
if (length === 3) {
|
|
if (!isSpace(group[1])) {
|
|
return false;
|
|
}
|
|
if (isKeywordOrVar(group[0], horizontals$1) && isKeywordOrVar(group[2], verticals$1) || isKeywordOrVar(group[0], verticals$1) && isKeywordOrVar(group[2], horizontals$1)) {
|
|
return true;
|
|
}
|
|
if (!isKeywordOrVar(group[0], horizontals$1) && !isLengthPercentage(group[0])) {
|
|
return false;
|
|
}
|
|
if (!isKeywordOrVar(group[2], verticals$1) && !isLengthPercentage(group[2])) {
|
|
return false;
|
|
}
|
|
}
|
|
if (length >= 5 && length <= 7) {
|
|
if (isKeywordOrVar(group[0], [left$1, right$1]) && isSpace(group[1]) && isLengthPercentageOrVar(group[2]) && isSpace(group[3]) && isKeywordOrVar(group[4], verticals$1)) {
|
|
if (group[6] && isSpace(group[5]) && (!isLengthPercentageOrVar(group[6]) || group[4].value === center)) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
if (isKeywordOrVar(group[0], [top$1, bottom$1]) && isSpace(group[1]) && isLengthPercentageOrVar(group[2]) && isSpace(group[3]) && isKeywordOrVar(group[4], horizontals$1)) {
|
|
if (group[6] && isSpace(group[5]) && (!isLengthPercentageOrVar(group[6]) || group[4].value === center)) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
return length < 8;
|
|
}
|
|
|
|
function isPositionFactory(repeating) {
|
|
return function isPosition(parsed) {
|
|
if (repeating && parsed.nodes[parsed.nodes.length - 1].type === 'div') {
|
|
return false;
|
|
}
|
|
|
|
return getArguments(parsed).every(validateGroup);
|
|
};
|
|
}
|
|
|
|
var resolutions = ['dpi', 'dpcm', 'dppx'];
|
|
|
|
function isResolution(_ref) {
|
|
var type = _ref.type;
|
|
var value = _ref.value;
|
|
|
|
if (type !== 'word') {
|
|
return false;
|
|
}
|
|
var int = (0, _postcssValueParser.unit)(value);
|
|
return int && !(0, _endsWith2.default)(int.number, '.') && !~int.unit.indexOf('.') && ~resolutions.indexOf(int.unit);
|
|
};
|
|
|
|
var isString = function isString(_ref) {
|
|
var type = _ref.type;
|
|
return type === 'string';
|
|
};
|
|
|
|
function isMultiplier(_ref) {
|
|
var type = _ref.type;
|
|
var value = _ref.value;
|
|
|
|
if (type !== 'word') {
|
|
return false;
|
|
}
|
|
var int = (0, _postcssValueParser.unit)(value);
|
|
return int && !(0, _endsWith2.default)(int.number, '.') && !~int.unit.indexOf('.') && int.unit === 'x';
|
|
};
|
|
|
|
function isImageFunction(node) {
|
|
if (!isFunction(node, 'image')) {
|
|
return false;
|
|
}
|
|
var valid = true;
|
|
(0, _postcssValueParser.walk)(node.nodes, function (child, index) {
|
|
if (index === 0 && !isImage(child) && !isString(child) && !isColor(child)) {
|
|
valid = false;
|
|
}
|
|
if (index === 1 && !isComma(child)) {
|
|
valid = false;
|
|
}
|
|
if (index === 2 && (isColor(node.nodes[0]) || !isColor(child))) {
|
|
valid = false;
|
|
}
|
|
return false;
|
|
});
|
|
return valid && node.nodes.length <= 3;
|
|
}
|
|
|
|
function validateImageSet(group) {
|
|
if (!isImage(group[0]) && !isString(group[0]) || isFunction(group[0], 'image-set') || !group[2] || !isResolution(group[2]) && !isMultiplier(group[2])) {
|
|
return false;
|
|
}
|
|
return group.length === 3;
|
|
}
|
|
|
|
function isImageSet(node) {
|
|
if (!isFunction(node, 'image-set')) {
|
|
return false;
|
|
}
|
|
return getArguments(node).every(validateImageSet);
|
|
}
|
|
|
|
function isElement(node) {
|
|
if (!isFunction(node, 'element')) {
|
|
return false;
|
|
}
|
|
if (node.nodes.length !== 1) {
|
|
return false;
|
|
}
|
|
var _node$nodes$ = node.nodes[0];
|
|
var type = _node$nodes$.type;
|
|
var value = _node$nodes$.value;
|
|
|
|
return value[0] === '#' && type === 'word';
|
|
}
|
|
|
|
function isCrossFade(node) {
|
|
if (!isFunction(node, 'cross-fade')) {
|
|
return false;
|
|
}
|
|
var valid = true;
|
|
(0, _postcssValueParser.walk)(node.nodes, function (child, index) {
|
|
if (index === 0 && !isPercentage(child) && !isImage(child)) {
|
|
valid = false;
|
|
}
|
|
if (index === 2 && !isPercentage(child) && !isImage(child)) {
|
|
valid = false;
|
|
}
|
|
if (index === 4 && !isImage(child) && !isColor(child)) {
|
|
valid = false;
|
|
}
|
|
return false;
|
|
});
|
|
return valid;
|
|
}
|
|
|
|
function isColourStop(group) {
|
|
var length = group.length;
|
|
|
|
if (length === 1) {
|
|
return isColor(group[0]);
|
|
}
|
|
if (length === 3) {
|
|
return isColor(group[0]) && isLengthPercentage(group[2]);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
var top = 'top';
|
|
var right = 'right';
|
|
var bottom = 'bottom';
|
|
var left = 'left';
|
|
|
|
var verticals = [top, bottom];
|
|
var horizontals = [right, left];
|
|
var directions = [].concat(horizontals, verticals);
|
|
|
|
function isLinearGradient(node) {
|
|
if (!isFunction(node, ['linear-gradient', 'repeating-linear-gradient'])) {
|
|
return false;
|
|
}
|
|
var colours = 0;
|
|
var valid = getArguments(node).every(function (group, index) {
|
|
if (index === 0) {
|
|
var length = group.length;
|
|
|
|
if (length === 1 && isAngle(group[0])) {
|
|
return true;
|
|
}
|
|
if (length > 1 && group[0].value === 'to' && length <= 5) {
|
|
return !group[4] && isKeyword(group[2], directions) || isKeyword(group[2], horizontals) && isKeyword(group[4], verticals) || isKeyword(group[2], verticals) && isKeyword(group[4], horizontals);
|
|
}
|
|
}
|
|
var colour = isColourStop(group);
|
|
if (colour) {
|
|
colours++;
|
|
}
|
|
return colour;
|
|
});
|
|
return valid && colours > 1;
|
|
}
|
|
|
|
var at = 'at';
|
|
var circle = 'circle';
|
|
var ellipse = 'ellipse';
|
|
var endingShapes = [circle, ellipse];
|
|
|
|
var extentKeywords = ['closest-corner', 'closest-side', 'farthest-corner', 'farthest-side'];
|
|
|
|
var isRadialGradientPosition = isPositionFactory(false);
|
|
|
|
function isAt(_ref2) {
|
|
var value = _ref2.value;
|
|
|
|
return value === at;
|
|
}
|
|
|
|
function isRadialGradient(node) {
|
|
if (!isFunction(node, ['radial-gradient', 'repeating-radial-gradient'])) {
|
|
return false;
|
|
}
|
|
var colours = 0;
|
|
var valid = getArguments(node).every(function (group, index) {
|
|
if (index === 0) {
|
|
var length = group.length;
|
|
|
|
var firstIsEndingShape = isKeyword(group[0], endingShapes);
|
|
var firstIsLength = isLength(group[0]);
|
|
var firstIsExtent = isKeyword(group[0], extentKeywords);
|
|
if (length === 1 && (firstIsEndingShape || firstIsLength || firstIsExtent)) {
|
|
return true;
|
|
}
|
|
var position2 = isRadialGradientPosition({ nodes: group.slice(2) });
|
|
if (isAt(group[0]) && position2) {
|
|
return true;
|
|
}
|
|
var firstIsCircle = group[0].value === circle;
|
|
var secondIsExtent = group[2] && isKeyword(group[2], extentKeywords);
|
|
var secondIsEndingShape = group[2] && isKeyword(group[2], endingShapes);
|
|
if (length === 3 && (firstIsCircle && isLength(group[2]) || firstIsLength && group[2].value === circle || firstIsExtent && secondIsEndingShape || firstIsEndingShape && secondIsExtent)) {
|
|
return true;
|
|
}
|
|
var firstIsEllipse = group[0].value === ellipse;
|
|
var firstIsLP = isLengthPercentage(group[0]);
|
|
var secondIsLP = group[2] && isLengthPercentage(group[2]);
|
|
var thirdIsLP = group[4] && isLengthPercentage(group[4]);
|
|
var position4 = isRadialGradientPosition({ nodes: group.slice(4) });
|
|
var position6 = isRadialGradientPosition({ nodes: group.slice(6) });
|
|
var position8 = isRadialGradientPosition({ nodes: group.slice(8) });
|
|
if (length === 5 && (firstIsEllipse && secondIsLP && thirdIsLP || firstIsLP && secondIsLP && group[4].value === ellipse)) {
|
|
return true;
|
|
}
|
|
if (length > 3 && (firstIsEndingShape && isAt(group[2]) && position4 || firstIsExtent && isAt(group[2]) && position4 || firstIsLength && isAt(group[2]) && position4 || firstIsLP && secondIsLP && isAt(group[4]) && position6 || firstIsCircle && isLength(group[2]) && isAt(group[4]) && position6 || firstIsEndingShape && secondIsExtent && isAt(group[4]) && position6 || firstIsExtent && secondIsEndingShape && isAt(group[4]) && position6 || firstIsEllipse && secondIsLP && thirdIsLP && isAt(group[6]) && position8 || firstIsLP && secondIsLP && group[4].value === ellipse && isAt(group[6]) && position8)) {
|
|
return true;
|
|
}
|
|
}
|
|
var colour = isColourStop(group);
|
|
if (colour) {
|
|
colours++;
|
|
}
|
|
return colour;
|
|
});
|
|
return valid && colours > 1;
|
|
}
|
|
|
|
function isGradient(node) {
|
|
return isLinearGradient(node) || isRadialGradient(node);
|
|
}
|
|
|
|
function isImage(node) {
|
|
return isUrl(node) || isImageFunction(node) || isImageSet(node) || isElement(node) || isCrossFade(node) || isGradient(node);
|
|
}
|
|
|
|
function isBgImage(node) {
|
|
return isImage(node) || isKeyword(node, 'none');
|
|
}
|
|
|
|
var sizeKeywords = ['cover', 'contain'];
|
|
|
|
var auto = 'auto';
|
|
|
|
function validateNode(node) {
|
|
return isKeyword(node, auto) || isLengthPercentage(node) || isVariable(node);
|
|
}
|
|
|
|
function validateGroup$1(group) {
|
|
var length = group.length;
|
|
|
|
if (length && length < 4) {
|
|
if (!validateNode(group[0])) {
|
|
return false;
|
|
}
|
|
if (group[2] && !validateNode(group[2])) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
function isBgSize(parsed) {
|
|
if (parsed.nodes.length === 1 && isKeyword(parsed.nodes[0], sizeKeywords)) {
|
|
return true;
|
|
}
|
|
|
|
return getArguments(parsed).every(validateGroup$1);
|
|
}
|
|
|
|
var absoluteSizes = ['xx-small', 'x-small', 'small', 'medium', 'large', 'x-large', 'xx-large'];
|
|
|
|
var isAbsoluteSize = function isAbsoluteSize(node) {
|
|
return isKeyword(node, absoluteSizes);
|
|
};
|
|
|
|
var relativeSizes = ['larger', 'smaller'];
|
|
|
|
var isRelativeSize = function isRelativeSize(node) {
|
|
return isKeyword(node, relativeSizes);
|
|
};
|
|
|
|
var isNegative = function isNegative(num) {
|
|
return num < 0;
|
|
};
|
|
|
|
var isFlex = function isFlex(_ref) {
|
|
var value = _ref.value;
|
|
|
|
var int = (0, _postcssValueParser.unit)(value);
|
|
return int && !(0, _endsWith2.default)(int.number, '.') && !~int.unit.indexOf('.') && int.unit === 'fr' && !isNegative(int.number);
|
|
};
|
|
|
|
var isMinMax = function isMinMax(node) {
|
|
if (isFunction(node, 'minmax') && node.nodes.length === 3) {
|
|
|
|
var firstChild = node.nodes[0];
|
|
var secondChild = node.nodes[1];
|
|
var thirdChild = node.nodes[2];
|
|
|
|
if (!isKeyword(firstChild, keywords$1) && !isLengthPercentage(firstChild)) {
|
|
return false;
|
|
}
|
|
|
|
if (!isComma(secondChild)) {
|
|
return false;
|
|
}
|
|
|
|
if (!isKeyword(thirdChild, keywords$1) && !isLengthPercentage(thirdChild) && !isFlex(thirdChild)) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
};
|
|
|
|
var keywords$1 = ['min-content', 'max-content', 'auto'];
|
|
|
|
var isTrackSize = function isTrackSize(node) {
|
|
return isMinMax(node) || isFlex(node) || isLengthPercentage(node) || isKeyword(node, keywords$1);
|
|
};
|
|
|
|
var standard = ['disc', 'circle', 'square', 'decimal', 'cjk-decimal', 'decimal-leading-zero', 'lower-roman', 'upper-roman', 'lower-greek', 'lower-alpha', 'lower-latin', 'upper-alpha', 'upper-latin', 'arabic-indic', '-moz-arabic-indic', 'armenian', 'bengali', '-moz-bengali', 'cambodian', 'cjk-earthly-branch', '-moz-cjk-earthly-branch', 'cjk-heavenly-stem', '-moz-cjk-heavenly-stem', 'cjk-ideographic', 'devanagari', '-moz-devanagari', 'ethiopic-numeric', 'georgian', 'gujarati', '-moz-gujarati', 'gurmukhi', '-moz-gurmukhi', 'hebrew', 'hiragana', 'hiragana-iroha', 'japanese-formal', 'japanese-informal', 'kannada', '-moz-kannada', 'katakana', 'katakana-iroha', 'khmer', '-moz-khmer', 'korean-hangul-formal', 'korean-hanja-formal', 'korean-hanja-informal', 'lao', '-moz-lao', 'lower-armenian', 'malayalam', '-moz-malayalam', 'mongolian', 'myanmar', '-moz-myanmar', 'oriya', '-moz-oriya', 'persian', '-moz-persian', 'simp-chinese-formal', 'simp-chinese-informal', 'tamil', '-moz-tamil', 'telugu', '-moz-telugu', 'thai', '-moz-thai', 'tibetan', 'trad-chinese-formal', 'trad-chinese-informal', 'upper-armenian', 'disclosure-open', 'disclosure-closed'];
|
|
|
|
var nonStandard = ['-moz-ethiopic-halehame', '-moz-ethiopic-halehame-am', 'ethiopic-halehame-ti-er', '-moz-ethiopic-halehame-ti-er', 'ethiopic-halehame-ti-et', '-moz-ethiopic-halehame-ti-et', 'hangul', '-moz-hangul', 'hangul-consonant', '-moz-hangul-consonant', 'urdu', '-moz-urdu'];
|
|
|
|
var valid = [].concat(standard, nonStandard);
|
|
|
|
var symbolTypes = ['cyclic', 'numeric', 'alphabetic', 'symbolic', 'fixed'];
|
|
|
|
function isSymbols(node) {
|
|
if (!isFunction(node, 'symbols')) {
|
|
return false;
|
|
}
|
|
var validSym = true;
|
|
(0, _postcssValueParser.walk)(node.nodes, function (child, index) {
|
|
var even = index % 2 === 0;
|
|
if (even && (index === 0 && !isKeyword(child, symbolTypes) && !isString(child) && !isImage(child) || index > 1 && !isString(child) && !isImage(child)) || !even && !isSpace(child)) {
|
|
validSym = false;
|
|
}
|
|
return false;
|
|
});
|
|
return validSym;
|
|
}
|
|
|
|
function isCounterStyle(node) {
|
|
return isCustomIdent(node) || isKeyword(node, valid) || isSymbols(node);
|
|
}
|
|
|
|
var compositingOperators = ['add', 'subtract', 'intersect', 'exclude'];
|
|
|
|
var isCompositingOperator = function isCompositingOperator(node) {
|
|
return isKeyword(node, compositingOperators);
|
|
};
|
|
|
|
var maskingModes = ['alpha', 'luminance', 'match-source'];
|
|
|
|
var isMaskingMode = function isMaskingMode(node) {
|
|
return isKeyword(node, maskingModes);
|
|
};
|
|
|
|
var geometryBoxes = ['margin-box', 'fill-box', 'stroke-box', 'view-box'];
|
|
|
|
var nonStandardKeywords = ['content', 'padding', 'border'];
|
|
|
|
var isGeometryBox = function isGeometryBox(node) {
|
|
return isBox(node) || isKeyword(node, geometryBoxes) || isKeyword(node, nonStandardKeywords);
|
|
};
|
|
|
|
function validateShadow(nodes) {
|
|
var hasColor = false;
|
|
var hasLength = 0;
|
|
var hasVariable = false;
|
|
var startsWithLength = false;
|
|
var valid = true;
|
|
|
|
(0, _postcssValueParser.walk)(nodes, function (child, index) {
|
|
var even = index % 2 === 0;
|
|
if (even) {
|
|
if (isLength(child)) {
|
|
if (!index) {
|
|
startsWithLength = true;
|
|
}
|
|
if (hasLength && hasColor && startsWithLength) {
|
|
valid = false;
|
|
return false;
|
|
}
|
|
hasLength++;
|
|
if (hasLength > 3) {
|
|
valid = false;
|
|
}
|
|
} else if (isColor(child)) {
|
|
if (hasColor) {
|
|
valid = false;
|
|
} else {
|
|
hasColor = true;
|
|
}
|
|
} else if (isVariable(child)) {
|
|
hasVariable = true;
|
|
} else {
|
|
valid = false;
|
|
}
|
|
} else if (!even && !isSpace(child)) {
|
|
valid = false;
|
|
}
|
|
|
|
return false;
|
|
});
|
|
|
|
if (!hasVariable && hasLength < 2 || nodes.length > 7) {
|
|
return false;
|
|
}
|
|
|
|
return valid;
|
|
}
|
|
|
|
function isShadowT(parsed) {
|
|
return getArguments(parsed).every(validateShadow);
|
|
}
|
|
|
|
var matrix = 'matrix';
|
|
var matrix3d = 'matrix3d';
|
|
|
|
function isMatrix(node) {
|
|
if (!isFunction(node, [matrix, matrix3d])) {
|
|
return false;
|
|
}
|
|
if (node.value === matrix && node.nodes.length !== 11 || node.value === matrix3d && node.nodes.length !== 31) {
|
|
return false;
|
|
}
|
|
|
|
var valid = true;
|
|
|
|
(0, _postcssValueParser.walk)(node.nodes, function (child, index) {
|
|
var even = index % 2 === 0;
|
|
if (even && !isNumber(child) || !even && !isComma(child)) {
|
|
valid = false;
|
|
}
|
|
return false;
|
|
});
|
|
|
|
return valid;
|
|
}
|
|
|
|
function isMultipleValue(name, fn) {
|
|
return function (node) {
|
|
if (!isFunction(node, name)) {
|
|
return false;
|
|
}
|
|
if (node.nodes.length > 3) {
|
|
return false;
|
|
}
|
|
|
|
var valid = true;
|
|
|
|
(0, _postcssValueParser.walk)(node.nodes, function (child, index) {
|
|
var even = index % 2 === 0;
|
|
if (even && !fn(child) || !even && !isComma(child)) {
|
|
valid = false;
|
|
}
|
|
return false;
|
|
});
|
|
|
|
if (isComma(node.nodes[node.nodes.length - 1])) {
|
|
return false;
|
|
}
|
|
return valid;
|
|
};
|
|
}
|
|
|
|
var isTranslate = isMultipleValue('translate', isLengthPercentage);
|
|
var isScale = isMultipleValue('scale', isNumber);
|
|
var isSkew = isMultipleValue('skew', isAngle);
|
|
|
|
var singleNumbers = ['scaleX', 'scaleY', 'scaleZ'];
|
|
|
|
var singleAngles = ['rotate', 'skewX', 'skewY', 'rotateX', 'rotateY', 'rotateZ'];
|
|
|
|
var singleLengths = ['perspective', 'translateZ'];
|
|
|
|
var singleLPs = ['translateX', 'translateY'];
|
|
|
|
function isSingleValidator(name, fn) {
|
|
return function (node) {
|
|
if (!isFunction(node, name)) {
|
|
return false;
|
|
}
|
|
if (node.nodes.length !== 1) {
|
|
return false;
|
|
}
|
|
return fn(node.nodes[0]);
|
|
};
|
|
}
|
|
|
|
var isSingleLP = isSingleValidator(singleLPs, isLengthPercentage);
|
|
var isSingleNumber = isSingleValidator(singleNumbers, isNumber);
|
|
var isSingleAngle = isSingleValidator(singleAngles, isAngle);
|
|
var isSingleLength = isSingleValidator(singleLengths, isLength);
|
|
|
|
function isTranslate3d(node) {
|
|
if (!isFunction(node, 'translate3d')) {
|
|
return false;
|
|
}
|
|
var nodes = node.nodes;
|
|
|
|
if (nodes.length !== 5) {
|
|
return false;
|
|
}
|
|
return isLengthPercentage(nodes[0]) && isComma(nodes[1]) && isLengthPercentage(nodes[2]) && isComma(nodes[3]) && isLength(nodes[4]);
|
|
}
|
|
|
|
function isScale3d(node) {
|
|
if (!isFunction(node, 'scale3d')) {
|
|
return false;
|
|
}
|
|
var nodes = node.nodes;
|
|
|
|
if (nodes.length !== 5) {
|
|
return false;
|
|
}
|
|
return isNumber(nodes[0]) && isComma(nodes[1]) && isNumber(nodes[2]) && isComma(nodes[3]) && isNumber(nodes[4]);
|
|
}
|
|
|
|
function isRotate3d(node) {
|
|
if (!isFunction(node, 'rotate3d')) {
|
|
return false;
|
|
}
|
|
var nodes = node.nodes;
|
|
|
|
if (nodes.length !== 7) {
|
|
return false;
|
|
}
|
|
return isNumber(nodes[0]) && isComma(nodes[1]) && isNumber(nodes[2]) && isComma(nodes[3]) && isNumber(nodes[4]) && isComma(nodes[5]) && isAngle(nodes[6]);
|
|
}
|
|
|
|
function validateNode$1(node) {
|
|
return isMatrix(node) || isRotate3d(node) || isScale(node) || isScale3d(node) || isSkew(node) || isSingleAngle(node) || isSingleLength(node) || isSingleLP(node) || isSingleNumber(node) || isTranslate(node) || isTranslate3d(node) || isVariable(node);
|
|
}
|
|
|
|
function isTransformList(parsed) {
|
|
var valid = true;
|
|
|
|
parsed.walk(function (node, index) {
|
|
var even = index % 2 === 0;
|
|
if (even && !validateNode$1(node) || !even && !isSpace(node)) {
|
|
valid = false;
|
|
}
|
|
return false;
|
|
});
|
|
|
|
return valid;
|
|
}
|
|
|
|
var animateableFeatures = ['scroll-position', 'contents'];
|
|
|
|
var isAnimateableFeature = function isAnimateableFeature(node) {
|
|
return isKeyword(node, animateableFeatures) || isCustomIdent(node);
|
|
};
|
|
|
|
var msOverflowStyleValidator = isKeywordFactory(["auto", "none", "scrollbar", "-ms-autohiding-scrollbar"]);
|
|
var mozAppearanceValidator = isKeywordFactory(["none", "button", "button-arrow-down", "button-arrow-next", "button-arrow-previous", "button-arrow-up", "button-bevel", "button-focus", "caret", "checkbox", "checkbox-container", "checkbox-label", "checkmenuitem", "dualbutton", "groupbox", "listbox", "listitem", "menuarrow", "menubar", "menucheckbox", "menuimage", "menuitem", "menuitemtext", "menulist", "menulist-button", "menulist-text", "menulist-textfield", "menupopup", "menuradio", "menuseparator", "meterbar", "meterchunk", "progressbar", "progressbar-vertical", "progresschunk", "progresschunk-vertical", "radio", "radio-container", "radio-label", "radiomenuitem", "range", "range-thumb", "resizer", "resizerpanel", "scale-horizontal", "scalethumbend", "scalethumb-horizontal", "scalethumbstart", "scalethumbtick", "scalethumb-vertical", "scale-vertical", "scrollbarbutton-down", "scrollbarbutton-left", "scrollbarbutton-right", "scrollbarbutton-up", "scrollbarthumb-horizontal", "scrollbarthumb-vertical", "scrollbartrack-horizontal", "scrollbartrack-vertical", "searchfield", "separator", "sheet", "spinner", "spinner-downbutton", "spinner-textfield", "spinner-upbutton", "splitter", "statusbar", "statusbarpanel", "tab", "tabpanel", "tabpanels", "tab-scroll-arrow-back", "tab-scroll-arrow-forward", "textfield", "textfield-multiline", "toolbar", "toolbarbutton", "toolbarbutton-dropdown", "toolbargripper", "toolbox", "tooltip", "treeheader", "treeheadercell", "treeheadersortarrow", "treeitem", "treeline", "treetwisty", "treetwistyopen", "treeview", "-moz-mac-unified-toolbar", "-moz-win-borderless-glass", "-moz-win-browsertabbar-toolbox", "-moz-win-communicationstext", "-moz-win-communications-toolbox", "-moz-win-exclude-glass", "-moz-win-glass", "-moz-win-mediatext", "-moz-win-media-toolbox", "-moz-window-button-box", "-moz-window-button-box-maximized", "-moz-window-button-close", "-moz-window-button-maximize", "-moz-window-button-minimize", "-moz-window-button-restore", "-moz-window-frame-bottom", "-moz-window-frame-left", "-moz-window-frame-right", "-moz-window-titlebar", "-moz-window-titlebar-maximized"]);
|
|
|
|
var mozBindingValidator = function mozBindingValidator(parsed) {
|
|
if (parsed.nodes.length === 1) {
|
|
var node = parsed.nodes[0];
|
|
return isUrl(node) || isKeyword(node, "none");
|
|
}
|
|
|
|
return false;
|
|
};
|
|
|
|
var mozFloatEdgeValidator = isKeywordFactory(["border-box", "content-box", "margin-box", "padding-box"]);
|
|
|
|
var mozForceBrokenImageIconValidator = function mozForceBrokenImageIconValidator(parsed) {
|
|
if (parsed.nodes.length === 1) {
|
|
var node = parsed.nodes[0];
|
|
return isInteger(node);
|
|
}
|
|
|
|
return false;
|
|
};
|
|
|
|
var mozOrientValidator = isKeywordFactory(["inline", "block", "horizontal", "vertical"]);
|
|
var mozStackSizingValidator = isKeywordFactory(["ignore", "stretch-to-fit"]);
|
|
var mozTextBlinkValidator = isKeywordFactory(["none", "blink"]);
|
|
var mozUserFocusValidator = isKeywordFactory(["ignore", "normal", "select-after", "select-before", "select-menu", "select-same", "select-all", "none"]);
|
|
var mozUserInputValidator = isKeywordFactory(["none", "enabled", "disabled"]);
|
|
var mozUserModifyValidator = isKeywordFactory(["read-only", "read-write", "write-only"]);
|
|
var mozWindowShadowValidator = isKeywordFactory(["default", "menu", "tooltip", "sheet", "none"]);
|
|
|
|
var webkitBorderBeforeColorValidator = function webkitBorderBeforeColorValidator(parsed) {
|
|
if (parsed.nodes.length === 1) {
|
|
var node = parsed.nodes[0];
|
|
return isColor(node);
|
|
}
|
|
|
|
return false;
|
|
};
|
|
|
|
var webkitBorderBeforeStyleValidator = function webkitBorderBeforeStyleValidator(parsed) {
|
|
var valid = true;
|
|
parsed.walk(function (node, index) {
|
|
var even = index % 2 === 0;
|
|
|
|
if (even && !isBrStyle(node) && !isVariable(node) || !even && !isSpace(node)) {
|
|
valid = false;
|
|
}
|
|
|
|
return false;
|
|
});
|
|
return valid && parsed.nodes.length % 2 !== 0 && parsed.nodes.length <= 7;
|
|
};
|
|
|
|
var webkitBorderBeforeWidthValidator = function webkitBorderBeforeWidthValidator(parsed) {
|
|
var valid = true;
|
|
parsed.walk(function (node, index) {
|
|
var even = index % 2 === 0;
|
|
|
|
if (even && !isBrWidth(node) && !isVariable(node) || !even && !isSpace(node)) {
|
|
valid = false;
|
|
}
|
|
|
|
return false;
|
|
});
|
|
return valid && parsed.nodes.length % 2 !== 0 && parsed.nodes.length <= 7;
|
|
};
|
|
|
|
var webkitMaskAttachmentValidator = function webkitMaskAttachmentValidator(parsed) {
|
|
var valid = true;
|
|
parsed.walk(function (node, index) {
|
|
var even = index % 2 === 0;
|
|
|
|
if (even && !isAttachment(node) && !isVariable(node) || !even && !isComma(node)) {
|
|
valid = false;
|
|
}
|
|
|
|
return false;
|
|
});
|
|
return valid && parsed.nodes.length % 2 !== 0;
|
|
};
|
|
|
|
var webkitMaskRepeatValidator = isRepeatStyle;
|
|
var webkitMaskRepeatXValidator = isKeywordFactory(["repeat", "no-repeat", "space", "round"]);
|
|
|
|
var webkitTapHighlightColorValidator = function webkitTapHighlightColorValidator(parsed) {
|
|
var valid = true;
|
|
parsed.walk(function (node, index) {
|
|
var even = index % 2 === 0;
|
|
|
|
if (even && !isColor(node) && !isVariable(node) || !even && !isComma(node)) {
|
|
valid = false;
|
|
}
|
|
|
|
return false;
|
|
});
|
|
return valid && parsed.nodes.length % 2 !== 0;
|
|
};
|
|
|
|
var webkitTextStrokeWidthValidator = function webkitTextStrokeWidthValidator(parsed) {
|
|
if (parsed.nodes.length === 1) {
|
|
var node = parsed.nodes[0];
|
|
return isLength(node);
|
|
}
|
|
|
|
return false;
|
|
};
|
|
|
|
var webkitTouchCalloutValidator = isKeywordFactory(["default", "none"]);
|
|
var alignContentValidator = isKeywordFactory(["flex-start", "flex-end", "center", "space-between", "space-around", "stretch"]);
|
|
var msFlexLinePackValidator = isKeywordFactory(["flex-start", "flex-end", "center", "space-between", "space-around", "stretch", "start", "end", "justify", "distribute"]);
|
|
var msFlexAlignValidator = isKeywordFactory(["flex-start", "flex-end", "center", "baseline", "stretch", "start", "end"]);
|
|
var alignItemsValidator = isKeywordFactory(["flex-start", "flex-end", "center", "baseline", "stretch"]);
|
|
var alignSelfValidator = isKeywordFactory(["auto", "flex-start", "flex-end", "center", "baseline", "stretch"]);
|
|
var msFlexItemAlignValidator = isKeywordFactory(["auto", "flex-start", "flex-end", "center", "baseline", "stretch", "start", "end"]);
|
|
var allValidator = isKeywordFactory(["initial", "inherit", "unset"]);
|
|
|
|
var animationDelayValidator = function animationDelayValidator(parsed) {
|
|
var valid = true;
|
|
parsed.walk(function (node, index) {
|
|
var even = index % 2 === 0;
|
|
|
|
if (even && !isTime(node) && !isVariable(node) || !even && !isComma(node)) {
|
|
valid = false;
|
|
}
|
|
|
|
return false;
|
|
});
|
|
return valid && parsed.nodes.length % 2 !== 0;
|
|
};
|
|
|
|
var animationDirectionValidator = function animationDirectionValidator(parsed) {
|
|
var valid = true;
|
|
parsed.walk(function (node, index) {
|
|
var even = index % 2 === 0;
|
|
|
|
if (even && !isSingleAnimationDirection(node) && !isVariable(node) || !even && !isComma(node)) {
|
|
valid = false;
|
|
}
|
|
|
|
return false;
|
|
});
|
|
return valid && parsed.nodes.length % 2 !== 0;
|
|
};
|
|
|
|
var animationFillModeValidator = function animationFillModeValidator(parsed) {
|
|
var valid = true;
|
|
parsed.walk(function (node, index) {
|
|
var even = index % 2 === 0;
|
|
|
|
if (even && !isSingleAnimationFillMode(node) && !isVariable(node) || !even && !isComma(node)) {
|
|
valid = false;
|
|
}
|
|
|
|
return false;
|
|
});
|
|
return valid && parsed.nodes.length % 2 !== 0;
|
|
};
|
|
|
|
var animationIterationCountValidator = function animationIterationCountValidator(parsed) {
|
|
var valid = true;
|
|
parsed.walk(function (node, index) {
|
|
var even = index % 2 === 0;
|
|
|
|
if (even && !isSingleAnimationIterationCount(node) && !isVariable(node) || !even && !isComma(node)) {
|
|
valid = false;
|
|
}
|
|
|
|
return false;
|
|
});
|
|
return valid && parsed.nodes.length % 2 !== 0;
|
|
};
|
|
|
|
var animationNameValidator = function animationNameValidator(parsed) {
|
|
var valid = true;
|
|
parsed.walk(function (node, index) {
|
|
var even = index % 2 === 0;
|
|
|
|
if (even && !isSingleAnimationName(node) && !isVariable(node) || !even && !isComma(node)) {
|
|
valid = false;
|
|
}
|
|
|
|
return false;
|
|
});
|
|
return valid && parsed.nodes.length % 2 !== 0;
|
|
};
|
|
|
|
var animationPlayStateValidator = function animationPlayStateValidator(parsed) {
|
|
var valid = true;
|
|
parsed.walk(function (node, index) {
|
|
var even = index % 2 === 0;
|
|
|
|
if (even && !isSingleAnimationPlayState(node) && !isVariable(node) || !even && !isComma(node)) {
|
|
valid = false;
|
|
}
|
|
|
|
return false;
|
|
});
|
|
return valid && parsed.nodes.length % 2 !== 0;
|
|
};
|
|
|
|
var animationTimingFunctionValidator = function animationTimingFunctionValidator(parsed) {
|
|
var valid = true;
|
|
parsed.walk(function (node, index) {
|
|
var even = index % 2 === 0;
|
|
|
|
if (even && !isSingleTransitionTimingFunction(node) && !isVariable(node) || !even && !isComma(node)) {
|
|
valid = false;
|
|
}
|
|
|
|
return false;
|
|
});
|
|
return valid && parsed.nodes.length % 2 !== 0;
|
|
};
|
|
|
|
var appearanceValidator = isKeywordFactory(["auto", "none"]);
|
|
|
|
var backdropFilterValidator = function backdropFilterValidator(parsed) {
|
|
if (isFilterFunctionList(parsed)) {
|
|
return true;
|
|
}
|
|
|
|
if (parsed.nodes.length === 1) {
|
|
var node = parsed.nodes[0];
|
|
return isKeyword(node, "none");
|
|
}
|
|
|
|
return false;
|
|
};
|
|
|
|
var backfaceVisibilityValidator = isKeywordFactory(["visible", "hidden"]);
|
|
|
|
var backgroundBlendModeValidator = function backgroundBlendModeValidator(parsed) {
|
|
var valid = true;
|
|
parsed.walk(function (node, index) {
|
|
var even = index % 2 === 0;
|
|
|
|
if (even && !isBlendMode(node) && !isVariable(node) || !even && !isComma(node)) {
|
|
valid = false;
|
|
}
|
|
|
|
return false;
|
|
});
|
|
return valid && parsed.nodes.length % 2 !== 0;
|
|
};
|
|
|
|
var backgroundClipValidator = function backgroundClipValidator(parsed) {
|
|
var valid = true;
|
|
parsed.walk(function (node, index) {
|
|
var even = index % 2 === 0;
|
|
|
|
if (even && !isBox(node) && !isVariable(node) || !even && !isComma(node)) {
|
|
valid = false;
|
|
}
|
|
|
|
return false;
|
|
});
|
|
return valid && parsed.nodes.length % 2 !== 0;
|
|
};
|
|
|
|
var backgroundImageValidator = function backgroundImageValidator(parsed) {
|
|
var valid = true;
|
|
parsed.walk(function (node, index) {
|
|
var even = index % 2 === 0;
|
|
|
|
if (even && !isBgImage(node) && !isVariable(node) || !even && !isComma(node)) {
|
|
valid = false;
|
|
}
|
|
|
|
return false;
|
|
});
|
|
return valid && parsed.nodes.length % 2 !== 0;
|
|
};
|
|
|
|
var backgroundPositionValidator = isPositionFactory(true);
|
|
var backgroundSizeValidator = isBgSize;
|
|
|
|
var borderBottomLeftRadiusValidator = function borderBottomLeftRadiusValidator(parsed) {
|
|
var valid = true;
|
|
parsed.walk(function (node, index) {
|
|
var even = index % 2 === 0;
|
|
|
|
if (even && !isLengthPercentage(node) && !isVariable(node) || !even && !isSpace(node)) {
|
|
valid = false;
|
|
}
|
|
|
|
return false;
|
|
});
|
|
return valid && parsed.nodes.length % 2 !== 0 && parsed.nodes.length <= 3;
|
|
};
|
|
|
|
var borderBottomStyleValidator = function borderBottomStyleValidator(parsed) {
|
|
if (parsed.nodes.length === 1) {
|
|
var node = parsed.nodes[0];
|
|
return isBrStyle(node);
|
|
}
|
|
|
|
return false;
|
|
};
|
|
|
|
var borderBottomWidthValidator = function borderBottomWidthValidator(parsed) {
|
|
if (parsed.nodes.length === 1) {
|
|
var node = parsed.nodes[0];
|
|
return isBrWidth(node);
|
|
}
|
|
|
|
return false;
|
|
};
|
|
|
|
var borderCollapseValidator = isKeywordFactory(["collapse", "separate"]);
|
|
|
|
var borderColorValidator = function borderColorValidator(parsed) {
|
|
var valid = true;
|
|
parsed.walk(function (node, index) {
|
|
var even = index % 2 === 0;
|
|
|
|
if (even && !isColor(node) && !isVariable(node) || !even && !isSpace(node)) {
|
|
valid = false;
|
|
}
|
|
|
|
return false;
|
|
});
|
|
return valid && parsed.nodes.length % 2 !== 0 && parsed.nodes.length <= 7;
|
|
};
|
|
|
|
var borderImageSourceValidator = function borderImageSourceValidator(parsed) {
|
|
if (parsed.nodes.length === 1) {
|
|
var node = parsed.nodes[0];
|
|
return isImage(node) || isKeyword(node, "none");
|
|
}
|
|
|
|
return false;
|
|
};
|
|
|
|
var bottomValidator = function bottomValidator(parsed) {
|
|
if (parsed.nodes.length === 1) {
|
|
var node = parsed.nodes[0];
|
|
return isLengthPercentage(node) || isKeyword(node, "auto");
|
|
}
|
|
|
|
return false;
|
|
};
|
|
|
|
var boxAlignValidator = isKeywordFactory(["start", "center", "end", "baseline", "stretch"]);
|
|
var boxDecorationBreakValidator = isKeywordFactory(["slice", "clone"]);
|
|
var boxDirectionValidator = isKeywordFactory(["normal", "reverse", "inherit"]);
|
|
|
|
var boxFlexValidator = function boxFlexValidator(parsed) {
|
|
if (parsed.nodes.length === 1) {
|
|
var node = parsed.nodes[0];
|
|
return isNumber(node);
|
|
}
|
|
|
|
return false;
|
|
};
|
|
|
|
var boxLinesValidator = isKeywordFactory(["single", "multiple"]);
|
|
var boxOrientValidator = isKeywordFactory(["horizontal", "vertical", "inline-axis", "block-axis", "inherit"]);
|
|
var boxPackValidator = isKeywordFactory(["start", "center", "end", "justify"]);
|
|
var boxSizingValidator = isKeywordFactory(["content-box", "border-box"]);
|
|
var boxSuppressValidator = isKeywordFactory(["show", "discard", "hide"]);
|
|
var pageBreakAfterValidator = isKeywordFactory(["auto", "always", "avoid", "left", "right"]);
|
|
var webkitColumnBreakInsideValidator = isKeywordFactory(["auto", "avoid", "avoid-page", "avoid-column", "avoid-region"]);
|
|
var captionSideValidator = isKeywordFactory(["top", "bottom", "block-start", "block-end", "inline-start", "inline-end"]);
|
|
var clearValidator = isKeywordFactory(["none", "left", "right", "both", "inline-start", "inline-end"]);
|
|
|
|
var columnCountValidator = function columnCountValidator(parsed) {
|
|
if (parsed.nodes.length === 1) {
|
|
var node = parsed.nodes[0];
|
|
return isNumber(node) || isKeyword(node, "auto");
|
|
}
|
|
|
|
return false;
|
|
};
|
|
|
|
var columnFillValidator = isKeywordFactory(["auto", "balance"]);
|
|
|
|
var columnGapValidator = function columnGapValidator(parsed) {
|
|
if (parsed.nodes.length === 1) {
|
|
var node = parsed.nodes[0];
|
|
return isLength(node) || isKeyword(node, "normal");
|
|
}
|
|
|
|
return false;
|
|
};
|
|
|
|
var columnSpanValidator = isKeywordFactory(["none", "all"]);
|
|
|
|
var columnWidthValidator = function columnWidthValidator(parsed) {
|
|
if (parsed.nodes.length === 1) {
|
|
var node = parsed.nodes[0];
|
|
return isLength(node) || isKeyword(node, "auto");
|
|
}
|
|
|
|
return false;
|
|
};
|
|
|
|
var directionValidator = isKeywordFactory(["ltr", "rtl"]);
|
|
var displayValidator = isKeywordFactory(["none", "inline", "block", "list-item", "inline-list-item", "inline-block", "inline-table", "table", "table-cell", "table-column", "table-column-group", "table-footer-group", "table-header-group", "table-row", "table-row-group", "flex", "inline-flex", "grid", "inline-grid", "run-in", "ruby", "ruby-base", "ruby-text", "ruby-base-container", "ruby-text-container", "contents", "-webkit-box", "-webkit-flex", "-moz-box", "-ms-flexbox", "-webkit-inline-box", "-webkit-inline-flex", "-moz-inline-box", "-ms-inline-flexbox", "-ms-grid", "-ms-inline-grid"]);
|
|
var displayInsideValidator = isKeywordFactory(["auto", "block", "table", "flex", "grid", "ruby"]);
|
|
var displayListValidator = isKeywordFactory(["none", "list-item"]);
|
|
var displayOutsideValidator = isKeywordFactory(["block-level", "inline-level", "run-in", "contents", "none", "table-row-group", "table-header-group", "table-footer-group", "table-row", "table-cell", "table-column-group", "table-column", "table-caption", "ruby-base", "ruby-text", "ruby-base-container", "ruby-text-container"]);
|
|
var emptyCellsValidator = isKeywordFactory(["show", "hide"]);
|
|
var mozBoxOrientValidator = isKeywordFactory(["row", "row-reverse", "column", "column-reverse", "horizontal", "vertical"]);
|
|
var mozBoxDirectionValidator = isKeywordFactory(["row", "row-reverse", "column", "column-reverse", "normal", "reverse"]);
|
|
var flexDirectionValidator = isKeywordFactory(["row", "row-reverse", "column", "column-reverse"]);
|
|
var flexWrapValidator = isKeywordFactory(["nowrap", "wrap", "wrap-reverse"]);
|
|
var floatValidator = isKeywordFactory(["left", "right", "none", "inline-start", "inline-end"]);
|
|
var fontKerningValidator = isKeywordFactory(["auto", "normal", "none"]);
|
|
|
|
var fontLanguageOverrideValidator = function fontLanguageOverrideValidator(parsed) {
|
|
if (parsed.nodes.length === 1) {
|
|
var node = parsed.nodes[0];
|
|
return isString(node) || isKeyword(node, "normal");
|
|
}
|
|
|
|
return false;
|
|
};
|
|
|
|
var fontSizeValidator = function fontSizeValidator(parsed) {
|
|
if (parsed.nodes.length === 1) {
|
|
var node = parsed.nodes[0];
|
|
return isAbsoluteSize(node) || isRelativeSize(node) || isLengthPercentage(node);
|
|
}
|
|
|
|
return false;
|
|
};
|
|
|
|
var fontSizeAdjustValidator = function fontSizeAdjustValidator(parsed) {
|
|
if (parsed.nodes.length === 1) {
|
|
var node = parsed.nodes[0];
|
|
return isNumber(node) || isKeyword(node, "none");
|
|
}
|
|
|
|
return false;
|
|
};
|
|
|
|
var fontStretchValidator = isKeywordFactory(["normal", "ultra-condensed", "extra-condensed", "condensed", "semi-condensed", "semi-expanded", "expanded", "extra-expanded", "ultra-expanded"]);
|
|
var fontStyleValidator = isKeywordFactory(["normal", "italic", "oblique"]);
|
|
var fontVariantCapsValidator = isKeywordFactory(["normal", "small-caps", "all-small-caps", "petite-caps", "all-petite-caps", "unicase", "titling-caps"]);
|
|
var fontVariantPositionValidator = isKeywordFactory(["normal", "sub", "super"]);
|
|
var fontWeightValidator = isKeywordFactory(["normal", "bold", "bolder", "lighter", "100", "200", "300", "400", "500", "600", "700", "800", "900"]);
|
|
|
|
var gridAutoColumnsValidator = function gridAutoColumnsValidator(parsed) {
|
|
if (parsed.nodes.length === 1) {
|
|
var node = parsed.nodes[0];
|
|
return isTrackSize(node);
|
|
}
|
|
|
|
return false;
|
|
};
|
|
|
|
var gridColumnGapValidator = function gridColumnGapValidator(parsed) {
|
|
if (parsed.nodes.length === 1) {
|
|
var node = parsed.nodes[0];
|
|
return isLengthPercentage(node);
|
|
}
|
|
|
|
return false;
|
|
};
|
|
|
|
var gridTemplateAreasValidator = function gridTemplateAreasValidator(parsed) {
|
|
var node = parsed.nodes[0];
|
|
|
|
if (parsed.nodes.length === 1 && isKeyword(node, "none")) {
|
|
return true;
|
|
}
|
|
|
|
var valid = true;
|
|
parsed.walk(function (node, index) {
|
|
var even = index % 2 === 0;
|
|
|
|
if (even && !isString(node) && !isVariable(node) || !even && !isSpace(node)) {
|
|
valid = false;
|
|
}
|
|
|
|
return false;
|
|
});
|
|
return valid && parsed.nodes.length % 2 !== 0;
|
|
};
|
|
|
|
var hyphensValidator = isKeywordFactory(["none", "manual", "auto"]);
|
|
var imageRenderingValidator = isKeywordFactory(["auto", "crisp-edges", "pixelated", "-webkit-optimize-contrast", "-moz-crisp-edges", "-o-pixelated"]);
|
|
var msInterpolationModeValidator = isKeywordFactory(["auto", "crisp-edges", "pixelated", "nearest-neighbor"]);
|
|
var imeModeValidator = isKeywordFactory(["auto", "normal", "active", "inactive", "disabled"]);
|
|
var initialLetterAlignValidator = isKeywordFactory(["auto", "alphabetic", "hanging", "ideographic"]);
|
|
var isolationValidator = isKeywordFactory(["auto", "isolate"]);
|
|
var mozBoxPackValidator = isKeywordFactory(["flex-start", "flex-end", "center", "space-between", "space-around", "start", "end", "justify"]);
|
|
var justifyContentValidator = isKeywordFactory(["flex-start", "flex-end", "center", "space-between", "space-around"]);
|
|
var msFlexPackValidator = isKeywordFactory(["flex-start", "flex-end", "center", "space-between", "space-around", "start", "end", "justify", "distribute"]);
|
|
|
|
var letterSpacingValidator = function letterSpacingValidator(parsed) {
|
|
if (parsed.nodes.length === 1) {
|
|
var node = parsed.nodes[0];
|
|
return isLength(node) || isKeyword(node, "normal");
|
|
}
|
|
|
|
return false;
|
|
};
|
|
|
|
var lineBreakValidator = isKeywordFactory(["auto", "loose", "normal", "strict"]);
|
|
|
|
var lineHeightValidator = function lineHeightValidator(parsed) {
|
|
if (parsed.nodes.length === 1) {
|
|
var node = parsed.nodes[0];
|
|
return isNumber(node) || isLengthPercentage(node) || isKeyword(node, "normal");
|
|
}
|
|
|
|
return false;
|
|
};
|
|
|
|
var listStylePositionValidator = isKeywordFactory(["inside", "outside"]);
|
|
|
|
var listStyleTypeValidator = function listStyleTypeValidator(parsed) {
|
|
if (parsed.nodes.length === 1) {
|
|
var node = parsed.nodes[0];
|
|
return isCounterStyle(node) || isString(node) || isKeyword(node, "none");
|
|
}
|
|
|
|
return false;
|
|
};
|
|
|
|
var maskCompositeValidator = function maskCompositeValidator(parsed) {
|
|
var valid = true;
|
|
parsed.walk(function (node, index) {
|
|
var even = index % 2 === 0;
|
|
|
|
if (even && !isCompositingOperator(node) && !isVariable(node) || !even && !isComma(node)) {
|
|
valid = false;
|
|
}
|
|
|
|
return false;
|
|
});
|
|
return valid && parsed.nodes.length % 2 !== 0;
|
|
};
|
|
|
|
var maskModeValidator = function maskModeValidator(parsed) {
|
|
var valid = true;
|
|
parsed.walk(function (node, index) {
|
|
var even = index % 2 === 0;
|
|
|
|
if (even && !isMaskingMode(node) && !isVariable(node) || !even && !isComma(node)) {
|
|
valid = false;
|
|
}
|
|
|
|
return false;
|
|
});
|
|
return valid && parsed.nodes.length % 2 !== 0;
|
|
};
|
|
|
|
var maskOriginValidator = function maskOriginValidator(parsed) {
|
|
var valid = true;
|
|
parsed.walk(function (node, index) {
|
|
var even = index % 2 === 0;
|
|
|
|
if (even && !isGeometryBox(node) && !isVariable(node) || !even && !isComma(node)) {
|
|
valid = false;
|
|
}
|
|
|
|
return false;
|
|
});
|
|
return valid && parsed.nodes.length % 2 !== 0;
|
|
};
|
|
|
|
var maskTypeValidator = isKeywordFactory(["luminance", "alpha"]);
|
|
var maxBlockSizeValidatorKeywords = ["none", "max-content", "min-content", "fit-content", "fill-available", "-webkit-max-content", "-moz-max-content", "-webkit-min-content", "-moz-min-content", "-webkit-fit-content", "-moz-fit-content", "-webkit-fill-available", "-moz-available"];
|
|
|
|
var maxBlockSizeValidator = function maxBlockSizeValidator(parsed) {
|
|
if (parsed.nodes.length === 1) {
|
|
var node = parsed.nodes[0];
|
|
return isLengthPercentage(node) || isKeyword(node, maxBlockSizeValidatorKeywords);
|
|
}
|
|
|
|
return false;
|
|
};
|
|
|
|
var mixBlendModeValidator = function mixBlendModeValidator(parsed) {
|
|
if (parsed.nodes.length === 1) {
|
|
var node = parsed.nodes[0];
|
|
return isBlendMode(node);
|
|
}
|
|
|
|
return false;
|
|
};
|
|
|
|
var objectFitValidator = isKeywordFactory(["fill", "contain", "cover", "none", "scale-down"]);
|
|
var objectPositionValidator = isPositionFactory(false);
|
|
|
|
var outlineColorValidator = function outlineColorValidator(parsed) {
|
|
if (parsed.nodes.length === 1) {
|
|
var node = parsed.nodes[0];
|
|
return isColor(node) || isKeyword(node, "invert");
|
|
}
|
|
|
|
return false;
|
|
};
|
|
|
|
var outlineStyleValidator = function outlineStyleValidator(parsed) {
|
|
if (parsed.nodes.length === 1) {
|
|
var node = parsed.nodes[0];
|
|
return isBrStyle(node) || isKeyword(node, "auto");
|
|
}
|
|
|
|
return false;
|
|
};
|
|
|
|
var overflowValidator = isKeywordFactory(["visible", "hidden", "scroll", "auto"]);
|
|
var overflowClipBoxValidator = isKeywordFactory(["padding-box", "content-box"]);
|
|
var overflowWrapValidator = isKeywordFactory(["normal", "break-word"]);
|
|
var pageBreakInsideValidator = isKeywordFactory(["auto", "avoid"]);
|
|
|
|
var perspectiveValidator = function perspectiveValidator(parsed) {
|
|
if (parsed.nodes.length === 1) {
|
|
var node = parsed.nodes[0];
|
|
return isLength(node) || isKeyword(node, "none");
|
|
}
|
|
|
|
return false;
|
|
};
|
|
|
|
var pointerEventsValidator = isKeywordFactory(["auto", "none", "visiblePainted", "visibleFill", "visibleStroke", "visible", "painted", "fill", "stroke", "all", "inherit"]);
|
|
var positionValidator = isKeywordFactory(["static", "relative", "absolute", "sticky", "fixed", "-webkit-sticky"]);
|
|
var resizeValidator = isKeywordFactory(["none", "both", "horizontal", "vertical"]);
|
|
var rubyAlignValidator = isKeywordFactory(["start", "center", "space-between", "space-around"]);
|
|
var rubyMergeValidator = isKeywordFactory(["separate", "collapse", "auto"]);
|
|
var rubyPositionValidator = isKeywordFactory(["over", "under", "inter-character"]);
|
|
var scrollBehaviorValidator = isKeywordFactory(["auto", "smooth"]);
|
|
|
|
var scrollSnapCoordinateValidator = function scrollSnapCoordinateValidator(parsed) {
|
|
if (isPositionFactory(true)(parsed)) {
|
|
return true;
|
|
}
|
|
|
|
if (parsed.nodes.length === 1) {
|
|
var node = parsed.nodes[0];
|
|
return isKeyword(node, "none");
|
|
}
|
|
|
|
return false;
|
|
};
|
|
|
|
var scrollSnapTypeValidator = isKeywordFactory(["none", "mandatory", "proximity"]);
|
|
|
|
var tabSizeValidator = function tabSizeValidator(parsed) {
|
|
if (parsed.nodes.length === 1) {
|
|
var node = parsed.nodes[0];
|
|
return isInteger(node) || isLength(node);
|
|
}
|
|
|
|
return false;
|
|
};
|
|
|
|
var tableLayoutValidator = isKeywordFactory(["auto", "fixed"]);
|
|
var textAlignValidator = isKeywordFactory(["start", "end", "left", "right", "center", "justify", "match-parent"]);
|
|
var textAlignLastValidator = isKeywordFactory(["auto", "start", "end", "left", "right", "center", "justify"]);
|
|
var textDecorationStyleValidator = isKeywordFactory(["solid", "double", "dotted", "dashed", "wavy"]);
|
|
var textOrientationValidator = isKeywordFactory(["mixed", "upright", "sideways"]);
|
|
var textRenderingValidator = isKeywordFactory(["auto", "optimizeSpeed", "optimizeLegibility", "geometricPrecision"]);
|
|
|
|
var textShadowValidator = function textShadowValidator(parsed) {
|
|
if (isShadowT(parsed)) {
|
|
return true;
|
|
}
|
|
|
|
if (parsed.nodes.length === 1) {
|
|
var node = parsed.nodes[0];
|
|
return isKeyword(node, "none");
|
|
}
|
|
|
|
return false;
|
|
};
|
|
|
|
var textSizeAdjustValidatorKeywords = ["none", "auto"];
|
|
|
|
var textSizeAdjustValidator = function textSizeAdjustValidator(parsed) {
|
|
if (parsed.nodes.length === 1) {
|
|
var node = parsed.nodes[0];
|
|
return isPercentage(node) || isKeyword(node, textSizeAdjustValidatorKeywords);
|
|
}
|
|
|
|
return false;
|
|
};
|
|
|
|
var textTransformValidator = isKeywordFactory(["none", "capitalize", "uppercase", "lowercase", "full-width"]);
|
|
|
|
var transformValidator = function transformValidator(parsed) {
|
|
if (isTransformList(parsed)) {
|
|
return true;
|
|
}
|
|
|
|
if (parsed.nodes.length === 1) {
|
|
var node = parsed.nodes[0];
|
|
return isKeyword(node, "none");
|
|
}
|
|
|
|
return false;
|
|
};
|
|
|
|
var transformBoxValidator = isKeywordFactory(["border-box", "fill-box", "view-box"]);
|
|
var transformStyleValidator = isKeywordFactory(["flat", "preserve-3d"]);
|
|
var unicodeBidiValidator = isKeywordFactory(["normal", "embed", "isolate", "bidi-override", "isolate-override", "plaintext"]);
|
|
var userSelectValidator = isKeywordFactory(["auto", "text", "none", "contain", "all"]);
|
|
var verticalAlignValidatorKeywords = ["baseline", "sub", "super", "text-top", "text-bottom", "middle", "top", "bottom"];
|
|
|
|
var verticalAlignValidator = function verticalAlignValidator(parsed) {
|
|
if (parsed.nodes.length === 1) {
|
|
var node = parsed.nodes[0];
|
|
return isLengthPercentage(node) || isKeyword(node, verticalAlignValidatorKeywords);
|
|
}
|
|
|
|
return false;
|
|
};
|
|
|
|
var visibilityValidator = isKeywordFactory(["visible", "hidden", "collapse"]);
|
|
var whiteSpaceValidator = isKeywordFactory(["normal", "pre", "nowrap", "pre-wrap", "pre-line"]);
|
|
|
|
var willChangeValidator = function willChangeValidator(parsed) {
|
|
var node = parsed.nodes[0];
|
|
|
|
if (parsed.nodes.length === 1 && isKeyword(node, "auto")) {
|
|
return true;
|
|
}
|
|
|
|
var valid = true;
|
|
parsed.walk(function (node, index) {
|
|
var even = index % 2 === 0;
|
|
|
|
if (even && !isAnimateableFeature(node) && !isVariable(node) || !even && !isComma(node)) {
|
|
valid = false;
|
|
}
|
|
|
|
return false;
|
|
});
|
|
return valid && parsed.nodes.length % 2 !== 0;
|
|
};
|
|
|
|
var wordBreakValidator = isKeywordFactory(["normal", "break-all", "keep-all"]);
|
|
|
|
var wordSpacingValidator = function wordSpacingValidator(parsed) {
|
|
if (parsed.nodes.length === 1) {
|
|
var node = parsed.nodes[0];
|
|
return isLengthPercentage(node) || isKeyword(node, "normal");
|
|
}
|
|
|
|
return false;
|
|
};
|
|
|
|
var writingModeValidator = isKeywordFactory(["horizontal-tb", "vertical-rl", "vertical-lr", "sideways-rl", "sideways-lr"]);
|
|
var msWritingModeValidator = isKeywordFactory(["horizontal-tb", "vertical-rl", "vertical-lr", "sideways-rl", "sideways-lr", "lr-tb", "tb-rl", "tb-lr"]);
|
|
|
|
var zIndexValidator = function zIndexValidator(parsed) {
|
|
if (parsed.nodes.length === 1) {
|
|
var node = parsed.nodes[0];
|
|
return isInteger(node) || isKeyword(node, "auto");
|
|
}
|
|
|
|
return false;
|
|
};
|
|
|
|
var validators = {
|
|
"-moz-appearance": mozAppearanceValidator,
|
|
"-moz-backface-visibility": backfaceVisibilityValidator,
|
|
"-moz-binding": mozBindingValidator,
|
|
"-moz-box-align": msFlexAlignValidator,
|
|
"-moz-box-direction": mozBoxDirectionValidator,
|
|
"-moz-box-orient": mozBoxOrientValidator,
|
|
"-moz-box-pack": mozBoxPackValidator,
|
|
"-moz-box-sizing": boxSizingValidator,
|
|
"-moz-column-count": columnCountValidator,
|
|
"-moz-column-fill": columnFillValidator,
|
|
"-moz-column-gap": columnGapValidator,
|
|
"-moz-column-span": columnSpanValidator,
|
|
"-moz-column-width": columnWidthValidator,
|
|
"-moz-float-edge": mozFloatEdgeValidator,
|
|
"-moz-font-kerning": fontKerningValidator,
|
|
"-moz-font-language-override": fontLanguageOverrideValidator,
|
|
"-moz-force-broken-image-icon": mozForceBrokenImageIconValidator,
|
|
"-moz-hyphens": hyphensValidator,
|
|
"-moz-margin-end": bottomValidator,
|
|
"-moz-margin-start": bottomValidator,
|
|
"-moz-orient": mozOrientValidator,
|
|
"-moz-perspective": perspectiveValidator,
|
|
"-moz-stack-sizing": mozStackSizingValidator,
|
|
"-moz-text-align-last": textAlignLastValidator,
|
|
"-moz-text-blink": mozTextBlinkValidator,
|
|
"-moz-text-decoration-style": textDecorationStyleValidator,
|
|
"-moz-text-size-adjust": textSizeAdjustValidator,
|
|
"-moz-transform": transformValidator,
|
|
"-moz-transform-style": transformStyleValidator,
|
|
"-moz-user-focus": mozUserFocusValidator,
|
|
"-moz-user-input": mozUserInputValidator,
|
|
"-moz-user-modify": mozUserModifyValidator,
|
|
"-moz-user-select": userSelectValidator,
|
|
"-moz-window-shadow": mozWindowShadowValidator,
|
|
"-ms-flex-align": msFlexAlignValidator,
|
|
"-ms-flex-direction": flexDirectionValidator,
|
|
"-ms-flex-item-align": msFlexItemAlignValidator,
|
|
"-ms-flex-line-pack": msFlexLinePackValidator,
|
|
"-ms-flex-pack": msFlexPackValidator,
|
|
"-ms-flex-wrap": flexWrapValidator,
|
|
"-ms-grid-row-align": alignItemsValidator,
|
|
"-ms-hyphens": hyphensValidator,
|
|
"-ms-interpolation-mode": msInterpolationModeValidator,
|
|
"-ms-overflow-style": msOverflowStyleValidator,
|
|
"-ms-scroll-snap-coordinate": scrollSnapCoordinateValidator,
|
|
"-ms-scroll-snap-type": scrollSnapTypeValidator,
|
|
"-ms-text-size-adjust": textSizeAdjustValidator,
|
|
"-ms-transform": transformValidator,
|
|
"-ms-user-select": userSelectValidator,
|
|
"-ms-writing-mode": msWritingModeValidator,
|
|
"-o-object-fit": objectFitValidator,
|
|
"-o-transform": transformValidator,
|
|
"-webkit-align-content": alignContentValidator,
|
|
"-webkit-align-items": alignItemsValidator,
|
|
"-webkit-align-self": alignSelfValidator,
|
|
"-webkit-appearance": appearanceValidator,
|
|
"-webkit-backdrop-filter": backdropFilterValidator,
|
|
"-webkit-backface-visibility": backfaceVisibilityValidator,
|
|
"-webkit-border-before-color": webkitBorderBeforeColorValidator,
|
|
"-webkit-border-before-style": webkitBorderBeforeStyleValidator,
|
|
"-webkit-border-before-width": webkitBorderBeforeWidthValidator,
|
|
"-webkit-box-align": msFlexAlignValidator,
|
|
"-webkit-box-decoration-break": boxDecorationBreakValidator,
|
|
"-webkit-box-direction": mozBoxDirectionValidator,
|
|
"-webkit-box-orient": mozBoxOrientValidator,
|
|
"-webkit-box-pack": mozBoxPackValidator,
|
|
"-webkit-box-sizing": boxSizingValidator,
|
|
"-webkit-column-break-inside": webkitColumnBreakInsideValidator,
|
|
"-webkit-column-count": columnCountValidator,
|
|
"-webkit-column-fill": columnFillValidator,
|
|
"-webkit-column-gap": columnGapValidator,
|
|
"-webkit-column-span": columnSpanValidator,
|
|
"-webkit-column-width": columnWidthValidator,
|
|
"-webkit-filter": backdropFilterValidator,
|
|
"-webkit-flex-direction": flexDirectionValidator,
|
|
"-webkit-flex-wrap": flexWrapValidator,
|
|
"-webkit-font-kerning": fontKerningValidator,
|
|
"-webkit-font-language-override": fontLanguageOverrideValidator,
|
|
"-webkit-hyphens": hyphensValidator,
|
|
"-webkit-justify-content": justifyContentValidator,
|
|
"-webkit-margin-after": bottomValidator,
|
|
"-webkit-margin-before": bottomValidator,
|
|
"-webkit-margin-end": bottomValidator,
|
|
"-webkit-margin-start": bottomValidator,
|
|
"-webkit-mask-attachment": webkitMaskAttachmentValidator,
|
|
"-webkit-mask-repeat": webkitMaskRepeatValidator,
|
|
"-webkit-mask-repeat-x": webkitMaskRepeatXValidator,
|
|
"-webkit-mask-repeat-y": webkitMaskRepeatXValidator,
|
|
"-webkit-perspective": perspectiveValidator,
|
|
"-webkit-scroll-snap-coordinate": scrollSnapCoordinateValidator,
|
|
"-webkit-scroll-snap-type": scrollSnapTypeValidator,
|
|
"-webkit-tap-highlight-color": webkitTapHighlightColorValidator,
|
|
"-webkit-text-decoration-style": textDecorationStyleValidator,
|
|
"-webkit-text-fill-color": webkitBorderBeforeColorValidator,
|
|
"-webkit-text-size-adjust": textSizeAdjustValidator,
|
|
"-webkit-text-stroke-color": webkitBorderBeforeColorValidator,
|
|
"-webkit-text-stroke-width": webkitTextStrokeWidthValidator,
|
|
"-webkit-touch-callout": webkitTouchCalloutValidator,
|
|
"-webkit-transform": transformValidator,
|
|
"-webkit-transform-style": transformStyleValidator,
|
|
"-webkit-user-select": userSelectValidator,
|
|
"-webkit-writing-mode": writingModeValidator,
|
|
"align-content": alignContentValidator,
|
|
"align-items": alignItemsValidator,
|
|
"align-self": alignSelfValidator,
|
|
"all": allValidator,
|
|
"animation-delay": animationDelayValidator,
|
|
"animation-direction": animationDirectionValidator,
|
|
"animation-duration": animationDelayValidator,
|
|
"animation-fill-mode": animationFillModeValidator,
|
|
"animation-iteration-count": animationIterationCountValidator,
|
|
"animation-name": animationNameValidator,
|
|
"animation-play-state": animationPlayStateValidator,
|
|
"animation-timing-function": animationTimingFunctionValidator,
|
|
"appearance": appearanceValidator,
|
|
"backdrop-filter": backdropFilterValidator,
|
|
"backface-visibility": backfaceVisibilityValidator,
|
|
"background-attachment": webkitMaskAttachmentValidator,
|
|
"background-blend-mode": backgroundBlendModeValidator,
|
|
"background-clip": backgroundClipValidator,
|
|
"background-color": webkitBorderBeforeColorValidator,
|
|
"background-image": backgroundImageValidator,
|
|
"background-origin": backgroundClipValidator,
|
|
"background-position": backgroundPositionValidator,
|
|
"background-repeat": webkitMaskRepeatValidator,
|
|
"background-size": backgroundSizeValidator,
|
|
"border-block-end-color": webkitBorderBeforeColorValidator,
|
|
"border-block-end-style": webkitBorderBeforeStyleValidator,
|
|
"border-block-end-width": webkitBorderBeforeWidthValidator,
|
|
"border-block-start-color": webkitBorderBeforeColorValidator,
|
|
"border-block-start-style": webkitBorderBeforeStyleValidator,
|
|
"border-block-start-width": webkitBorderBeforeWidthValidator,
|
|
"border-bottom-color": webkitBorderBeforeColorValidator,
|
|
"border-bottom-left-radius": borderBottomLeftRadiusValidator,
|
|
"border-bottom-right-radius": borderBottomLeftRadiusValidator,
|
|
"border-bottom-style": borderBottomStyleValidator,
|
|
"border-bottom-width": borderBottomWidthValidator,
|
|
"border-collapse": borderCollapseValidator,
|
|
"border-color": borderColorValidator,
|
|
"border-image-source": borderImageSourceValidator,
|
|
"border-inline-end-color": webkitBorderBeforeColorValidator,
|
|
"border-inline-end-style": webkitBorderBeforeStyleValidator,
|
|
"border-inline-end-width": webkitBorderBeforeWidthValidator,
|
|
"border-inline-start-color": webkitBorderBeforeColorValidator,
|
|
"border-inline-start-style": webkitBorderBeforeStyleValidator,
|
|
"border-inline-start-width": webkitBorderBeforeWidthValidator,
|
|
"border-left-color": webkitBorderBeforeColorValidator,
|
|
"border-left-style": borderBottomStyleValidator,
|
|
"border-left-width": borderBottomWidthValidator,
|
|
"border-right-color": webkitBorderBeforeColorValidator,
|
|
"border-right-style": borderBottomStyleValidator,
|
|
"border-right-width": borderBottomWidthValidator,
|
|
"border-style": webkitBorderBeforeStyleValidator,
|
|
"border-top-color": webkitBorderBeforeColorValidator,
|
|
"border-top-left-radius": borderBottomLeftRadiusValidator,
|
|
"border-top-right-radius": borderBottomLeftRadiusValidator,
|
|
"border-top-style": borderBottomStyleValidator,
|
|
"border-top-width": borderBottomWidthValidator,
|
|
"border-width": webkitBorderBeforeWidthValidator,
|
|
"bottom": bottomValidator,
|
|
"box-align": boxAlignValidator,
|
|
"box-decoration-break": boxDecorationBreakValidator,
|
|
"box-direction": boxDirectionValidator,
|
|
"box-flex": boxFlexValidator,
|
|
"box-flex-group": mozForceBrokenImageIconValidator,
|
|
"box-lines": boxLinesValidator,
|
|
"box-ordinal-group": mozForceBrokenImageIconValidator,
|
|
"box-orient": boxOrientValidator,
|
|
"box-pack": boxPackValidator,
|
|
"box-sizing": boxSizingValidator,
|
|
"box-suppress": boxSuppressValidator,
|
|
"break-inside": webkitColumnBreakInsideValidator,
|
|
"caption-side": captionSideValidator,
|
|
"clear": clearValidator,
|
|
"color": webkitBorderBeforeColorValidator,
|
|
"column-count": columnCountValidator,
|
|
"column-fill": columnFillValidator,
|
|
"column-gap": columnGapValidator,
|
|
"column-rule-color": webkitBorderBeforeColorValidator,
|
|
"column-rule-style": borderBottomStyleValidator,
|
|
"column-rule-width": borderBottomWidthValidator,
|
|
"column-span": columnSpanValidator,
|
|
"column-width": columnWidthValidator,
|
|
"direction": directionValidator,
|
|
"display": displayValidator,
|
|
"display-inside": displayInsideValidator,
|
|
"display-list": displayListValidator,
|
|
"display-outside": displayOutsideValidator,
|
|
"empty-cells": emptyCellsValidator,
|
|
"filter": backdropFilterValidator,
|
|
"flex-direction": flexDirectionValidator,
|
|
"flex-grow": boxFlexValidator,
|
|
"flex-shrink": boxFlexValidator,
|
|
"flex-wrap": flexWrapValidator,
|
|
"float": floatValidator,
|
|
"font-kerning": fontKerningValidator,
|
|
"font-language-override": fontLanguageOverrideValidator,
|
|
"font-size": fontSizeValidator,
|
|
"font-size-adjust": fontSizeAdjustValidator,
|
|
"font-stretch": fontStretchValidator,
|
|
"font-style": fontStyleValidator,
|
|
"font-variant-caps": fontVariantCapsValidator,
|
|
"font-variant-position": fontVariantPositionValidator,
|
|
"font-weight": fontWeightValidator,
|
|
"grid-auto-columns": gridAutoColumnsValidator,
|
|
"grid-auto-rows": gridAutoColumnsValidator,
|
|
"grid-column-gap": gridColumnGapValidator,
|
|
"grid-row-gap": gridColumnGapValidator,
|
|
"grid-template-areas": gridTemplateAreasValidator,
|
|
"hyphens": hyphensValidator,
|
|
"image-rendering": imageRenderingValidator,
|
|
"ime-mode": imeModeValidator,
|
|
"initial-letter-align": initialLetterAlignValidator,
|
|
"isolation": isolationValidator,
|
|
"justify-content": justifyContentValidator,
|
|
"left": bottomValidator,
|
|
"letter-spacing": letterSpacingValidator,
|
|
"line-break": lineBreakValidator,
|
|
"line-height": lineHeightValidator,
|
|
"list-style-image": mozBindingValidator,
|
|
"list-style-position": listStylePositionValidator,
|
|
"list-style-type": listStyleTypeValidator,
|
|
"margin-block-end": bottomValidator,
|
|
"margin-block-start": bottomValidator,
|
|
"margin-bottom": bottomValidator,
|
|
"margin-inline-end": bottomValidator,
|
|
"margin-inline-start": bottomValidator,
|
|
"margin-left": bottomValidator,
|
|
"margin-right": bottomValidator,
|
|
"margin-top": bottomValidator,
|
|
"marker-offset": columnWidthValidator,
|
|
"mask-composite": maskCompositeValidator,
|
|
"mask-mode": maskModeValidator,
|
|
"mask-origin": maskOriginValidator,
|
|
"mask-position": backgroundPositionValidator,
|
|
"mask-repeat": webkitMaskRepeatValidator,
|
|
"mask-size": backgroundSizeValidator,
|
|
"mask-type": maskTypeValidator,
|
|
"max-block-size": maxBlockSizeValidator,
|
|
"max-height": maxBlockSizeValidator,
|
|
"max-inline-size": maxBlockSizeValidator,
|
|
"max-width": maxBlockSizeValidator,
|
|
"min-block-size": maxBlockSizeValidator,
|
|
"min-height": maxBlockSizeValidator,
|
|
"min-inline-size": maxBlockSizeValidator,
|
|
"min-width": maxBlockSizeValidator,
|
|
"mix-blend-mode": mixBlendModeValidator,
|
|
"motion-offset": gridColumnGapValidator,
|
|
"object-fit": objectFitValidator,
|
|
"object-position": objectPositionValidator,
|
|
"offset-block-end": bottomValidator,
|
|
"offset-block-start": bottomValidator,
|
|
"offset-inline-end": bottomValidator,
|
|
"offset-inline-start": bottomValidator,
|
|
"opacity": boxFlexValidator,
|
|
"order": mozForceBrokenImageIconValidator,
|
|
"orphans": mozForceBrokenImageIconValidator,
|
|
"outline-color": outlineColorValidator,
|
|
"outline-offset": webkitTextStrokeWidthValidator,
|
|
"outline-style": outlineStyleValidator,
|
|
"outline-width": borderBottomWidthValidator,
|
|
"overflow": overflowValidator,
|
|
"overflow-clip-box": overflowClipBoxValidator,
|
|
"overflow-wrap": overflowWrapValidator,
|
|
"overflow-x": overflowValidator,
|
|
"overflow-y": overflowValidator,
|
|
"padding-block-end": gridColumnGapValidator,
|
|
"padding-block-start": gridColumnGapValidator,
|
|
"padding-bottom": gridColumnGapValidator,
|
|
"padding-inline-end": gridColumnGapValidator,
|
|
"padding-inline-start": gridColumnGapValidator,
|
|
"padding-left": gridColumnGapValidator,
|
|
"padding-right": gridColumnGapValidator,
|
|
"padding-top": gridColumnGapValidator,
|
|
"page-break-after": pageBreakAfterValidator,
|
|
"page-break-before": pageBreakAfterValidator,
|
|
"page-break-inside": webkitColumnBreakInsideValidator,
|
|
"perspective": perspectiveValidator,
|
|
"perspective-origin": objectPositionValidator,
|
|
"pointer-events": pointerEventsValidator,
|
|
"position": positionValidator,
|
|
"resize": resizeValidator,
|
|
"right": bottomValidator,
|
|
"ruby-align": rubyAlignValidator,
|
|
"ruby-merge": rubyMergeValidator,
|
|
"ruby-position": rubyPositionValidator,
|
|
"scroll-behavior": scrollBehaviorValidator,
|
|
"scroll-snap-coordinate": scrollSnapCoordinateValidator,
|
|
"scroll-snap-destination": objectPositionValidator,
|
|
"scroll-snap-type": scrollSnapTypeValidator,
|
|
"scroll-snap-type-x": scrollSnapTypeValidator,
|
|
"scroll-snap-type-y": scrollSnapTypeValidator,
|
|
"shape-image-threshold": boxFlexValidator,
|
|
"shape-margin": gridColumnGapValidator,
|
|
"tab-size": tabSizeValidator,
|
|
"table-layout": tableLayoutValidator,
|
|
"text-align": textAlignValidator,
|
|
"text-align-last": textAlignLastValidator,
|
|
"text-decoration-color": webkitBorderBeforeColorValidator,
|
|
"text-decoration-style": textDecorationStyleValidator,
|
|
"text-emphasis-color": webkitBorderBeforeColorValidator,
|
|
"text-orientation": textOrientationValidator,
|
|
"text-rendering": textRenderingValidator,
|
|
"text-shadow": textShadowValidator,
|
|
"text-size-adjust": textSizeAdjustValidator,
|
|
"text-transform": textTransformValidator,
|
|
"top": bottomValidator,
|
|
"transform": transformValidator,
|
|
"transform-box": transformBoxValidator,
|
|
"transform-style": transformStyleValidator,
|
|
"transition-delay": animationDelayValidator,
|
|
"transition-duration": animationDelayValidator,
|
|
"transition-timing-function": animationTimingFunctionValidator,
|
|
"unicode-bidi": unicodeBidiValidator,
|
|
"user-select": userSelectValidator,
|
|
"vertical-align": verticalAlignValidator,
|
|
"visibility": visibilityValidator,
|
|
"white-space": whiteSpaceValidator,
|
|
"widows": mozForceBrokenImageIconValidator,
|
|
"will-change": willChangeValidator,
|
|
"word-break": wordBreakValidator,
|
|
"word-spacing": wordSpacingValidator,
|
|
"word-wrap": overflowWrapValidator,
|
|
"writing-mode": writingModeValidator,
|
|
"z-index": zIndexValidator
|
|
};
|
|
var cssGlobals = ["inherit", "initial", "revert", "unset"];
|
|
function cssValues(property, value) {
|
|
if (typeof value === 'string') {
|
|
value = (0, _postcssValueParser2.default)(value);
|
|
}
|
|
|
|
var first = value.nodes[0];
|
|
|
|
if (value.nodes.length === 1 && (isKeyword(first, cssGlobals) || isVariable(first))) {
|
|
return true;
|
|
}
|
|
|
|
if (validators[property]) {
|
|
if (!!validators[property](value) === false) {
|
|
return {
|
|
type: 'invalid',
|
|
message: '"' + value + '" is not a valid value for "' + property + '".'
|
|
};
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
return {
|
|
type: 'unknown',
|
|
message: '"' + property + '" is not a recognised property.'
|
|
};
|
|
}
|
|
|
|
exports.default = cssValues; |