diff options
Diffstat (limited to 'node_modules/clean-css/lib/optimizer/configuration')
4 files changed, 1279 insertions, 0 deletions
diff --git a/node_modules/clean-css/lib/optimizer/configuration/break-up.js b/node_modules/clean-css/lib/optimizer/configuration/break-up.js new file mode 100644 index 00000000..da069bf2 --- /dev/null +++ b/node_modules/clean-css/lib/optimizer/configuration/break-up.js @@ -0,0 +1,656 @@ +var InvalidPropertyError = require('../invalid-property-error'); + +var wrapSingle = require('../wrap-for-optimizing').single; + +var Token = require('../../tokenizer/token'); +var Marker = require('../../tokenizer/marker'); + +var formatPosition = require('../../utils/format-position'); + +function _anyIsInherit(values) { + var i, l; + + for (i = 0, l = values.length; i < l; i++) { + if (values[i][1] == 'inherit') { + return true; + } + } + + return false; +} + +function _colorFilter(validator) { + return function(value) { + return value[1] == 'invert' || validator.isColor(value[1]) || validator.isPrefixed(value[1]); + }; +} + +function _styleFilter(validator) { + return function(value) { + return value[1] != 'inherit' && validator.isStyleKeyword(value[1]) && !validator.isColorFunction(value[1]); + }; +} + +function _wrapDefault(name, property, configuration) { + var descriptor = configuration[name]; + if (descriptor.doubleValues && descriptor.defaultValue.length == 2) { + return wrapSingle([ + Token.PROPERTY, + [Token.PROPERTY_NAME, name], + [Token.PROPERTY_VALUE, descriptor.defaultValue[0]], + [Token.PROPERTY_VALUE, descriptor.defaultValue[1]] + ]); + } if (descriptor.doubleValues && descriptor.defaultValue.length == 1) { + return wrapSingle([ + Token.PROPERTY, + [Token.PROPERTY_NAME, name], + [Token.PROPERTY_VALUE, descriptor.defaultValue[0]] + ]); + } + return wrapSingle([ + Token.PROPERTY, + [Token.PROPERTY_NAME, name], + [Token.PROPERTY_VALUE, descriptor.defaultValue] + ]); +} + +function _widthFilter(validator) { + return function(value) { + return value[1] != 'inherit' + && (validator.isWidth(value[1]) || validator.isUnit(value[1]) || validator.isDynamicUnit(value[1])) + && !validator.isStyleKeyword(value[1]) + && !validator.isColorFunction(value[1]); + }; +} + +function animation(property, configuration, validator) { + var duration = _wrapDefault(property.name + '-duration', property, configuration); + var timing = _wrapDefault(property.name + '-timing-function', property, configuration); + var delay = _wrapDefault(property.name + '-delay', property, configuration); + var iteration = _wrapDefault(property.name + '-iteration-count', property, configuration); + var direction = _wrapDefault(property.name + '-direction', property, configuration); + var fill = _wrapDefault(property.name + '-fill-mode', property, configuration); + var play = _wrapDefault(property.name + '-play-state', property, configuration); + var name = _wrapDefault(property.name + '-name', property, configuration); + var components = [duration, timing, delay, iteration, direction, fill, play, name]; + var values = property.value; + var value; + var durationSet = false; + var timingSet = false; + var delaySet = false; + var iterationSet = false; + var directionSet = false; + var fillSet = false; + var playSet = false; + var nameSet = false; + var i; + var l; + + if (property.value.length == 1 && property.value[0][1] == 'inherit') { + // eslint-disable-next-line max-len + duration.value = timing.value = delay.value = iteration.value = direction.value = fill.value = play.value = name.value = property.value; + return components; + } + + if (values.length > 1 && _anyIsInherit(values)) { + throw new InvalidPropertyError('Invalid animation values at ' + formatPosition(values[0][2][0]) + '. Ignoring.'); + } + + for (i = 0, l = values.length; i < l; i++) { + value = values[i]; + + if (validator.isTime(value[1]) && !durationSet) { + duration.value = [value]; + durationSet = true; + } else if (validator.isTime(value[1]) && !delaySet) { + delay.value = [value]; + delaySet = true; + } else if ((validator.isGlobal(value[1]) || validator.isTimingFunction(value[1])) && !timingSet) { + timing.value = [value]; + timingSet = true; + } else if ((validator.isAnimationIterationCountKeyword(value[1]) + || validator.isPositiveNumber(value[1])) + && !iterationSet) { + iteration.value = [value]; + iterationSet = true; + } else if (validator.isAnimationDirectionKeyword(value[1]) && !directionSet) { + direction.value = [value]; + directionSet = true; + } else if (validator.isAnimationFillModeKeyword(value[1]) && !fillSet) { + fill.value = [value]; + fillSet = true; + } else if (validator.isAnimationPlayStateKeyword(value[1]) && !playSet) { + play.value = [value]; + playSet = true; + } else if ((validator.isAnimationNameKeyword(value[1]) || validator.isIdentifier(value[1])) && !nameSet) { + name.value = [value]; + nameSet = true; + } else { + throw new InvalidPropertyError('Invalid animation value at ' + formatPosition(value[2][0]) + '. Ignoring.'); + } + } + + return components; +} + +function background(property, configuration, validator) { + var image = _wrapDefault('background-image', property, configuration); + var position = _wrapDefault('background-position', property, configuration); + var size = _wrapDefault('background-size', property, configuration); + var repeat = _wrapDefault('background-repeat', property, configuration); + var attachment = _wrapDefault('background-attachment', property, configuration); + var origin = _wrapDefault('background-origin', property, configuration); + var clip = _wrapDefault('background-clip', property, configuration); + var color = _wrapDefault('background-color', property, configuration); + var components = [image, position, size, repeat, attachment, origin, clip, color]; + var values = property.value; + + var positionSet = false; + var clipSet = false; + var originSet = false; + var repeatSet = false; + + var anyValueSet = false; + + if (property.value.length == 1 && property.value[0][1] == 'inherit') { + // NOTE: 'inherit' is not a valid value for background-attachment + color.value = image.value = repeat.value = position.value = size.value = origin.value = clip.value = property.value; + return components; + } + + if (property.value.length == 1 && property.value[0][1] == '0 0') { + return components; + } + + for (var i = values.length - 1; i >= 0; i--) { + var value = values[i]; + + if (validator.isBackgroundAttachmentKeyword(value[1])) { + attachment.value = [value]; + anyValueSet = true; + } else if (validator.isBackgroundClipKeyword(value[1]) || validator.isBackgroundOriginKeyword(value[1])) { + if (clipSet) { + origin.value = [value]; + originSet = true; + } else { + clip.value = [value]; + clipSet = true; + } + anyValueSet = true; + } else if (validator.isBackgroundRepeatKeyword(value[1])) { + if (repeatSet) { + repeat.value.unshift(value); + } else { + repeat.value = [value]; + repeatSet = true; + } + anyValueSet = true; + } else if (validator.isBackgroundPositionKeyword(value[1]) + || validator.isBackgroundSizeKeyword(value[1]) + || validator.isUnit(value[1]) + || validator.isDynamicUnit(value[1])) { + if (i > 0) { + var previousValue = values[i - 1]; + + if (previousValue[1] == Marker.FORWARD_SLASH) { + size.value = [value]; + } else if (i > 1 && values[i - 2][1] == Marker.FORWARD_SLASH) { + size.value = [previousValue, value]; + i -= 2; + } else { + if (!positionSet) { position.value = []; } + + position.value.unshift(value); + positionSet = true; + } + } else { + if (!positionSet) { position.value = []; } + + position.value.unshift(value); + positionSet = true; + } + anyValueSet = true; + } else if ((color.value[0][1] == configuration[color.name].defaultValue || color.value[0][1] == 'none') && (validator.isColor(value[1]) || validator.isPrefixed(value[1]))) { + color.value = [value]; + anyValueSet = true; + } else if (validator.isUrl(value[1]) || validator.isFunction(value[1])) { + image.value = [value]; + anyValueSet = true; + } + } + + if (clipSet && !originSet) { origin.value = clip.value.slice(0); } + + if (!anyValueSet) { + throw new InvalidPropertyError('Invalid background value at ' + formatPosition(values[0][2][0]) + '. Ignoring.'); + } + + return components; +} + +function borderRadius(property, configuration) { + var values = property.value; + var splitAt = -1; + + for (var i = 0, l = values.length; i < l; i++) { + if (values[i][1] == Marker.FORWARD_SLASH) { + splitAt = i; + break; + } + } + + if (splitAt === 0 || splitAt === values.length - 1) { + throw new InvalidPropertyError('Invalid border-radius value at ' + formatPosition(values[0][2][0]) + '. Ignoring.'); + } + + var target = _wrapDefault(property.name, property, configuration); + target.value = splitAt > -1 + ? values.slice(0, splitAt) + : values.slice(0); + target.components = fourValues(target, configuration); + + var remainder = _wrapDefault(property.name, property, configuration); + remainder.value = splitAt > -1 + ? values.slice(splitAt + 1) + : values.slice(0); + remainder.components = fourValues(remainder, configuration); + + for (var j = 0; j < 4; j++) { + target.components[j].multiplex = true; + target.components[j].value = target.components[j].value.concat(remainder.components[j].value); + } + + return target.components; +} + +function font(property, configuration, validator) { + var style = _wrapDefault('font-style', property, configuration); + var variant = _wrapDefault('font-variant', property, configuration); + var weight = _wrapDefault('font-weight', property, configuration); + var stretch = _wrapDefault('font-stretch', property, configuration); + var size = _wrapDefault('font-size', property, configuration); + var height = _wrapDefault('line-height', property, configuration); + var family = _wrapDefault('font-family', property, configuration); + var components = [style, variant, weight, stretch, size, height, family]; + var values = property.value; + var fuzzyMatched = 4; // style, variant, weight, and stretch + var index = 0; + var isStretchSet = false; + var isStretchValid; + var isStyleSet = false; + var isStyleValid; + var isVariantSet = false; + var isVariantValid; + var isWeightSet = false; + var isWeightValid; + var appendableFamilyName = false; + + if (!values[index]) { + throw new InvalidPropertyError('Missing font values at ' + formatPosition(property.all[property.position][1][2][0]) + '. Ignoring.'); + } + + if (values.length == 1 && values[0][1] == 'inherit') { + style.value = variant.value = weight.value = stretch.value = size.value = height.value = family.value = values; + return components; + } + + if (values.length == 1 + && (validator.isFontKeyword(values[0][1]) + || validator.isGlobal(values[0][1]) + || validator.isPrefixed(values[0][1])) + ) { + values[0][1] = Marker.INTERNAL + values[0][1]; + style.value = variant.value = weight.value = stretch.value = size.value = height.value = family.value = values; + return components; + } + + if (values.length < 2 || !_anyIsFontSize(values, validator) || !_anyIsFontFamily(values, validator)) { + throw new InvalidPropertyError('Invalid font values at ' + formatPosition(property.all[property.position][1][2][0]) + '. Ignoring.'); + } + + if (values.length > 1 && _anyIsInherit(values)) { + throw new InvalidPropertyError('Invalid font values at ' + formatPosition(values[0][2][0]) + '. Ignoring.'); + } + + // fuzzy match style, variant, weight, and stretch on first elements + while (index < fuzzyMatched) { + isStretchValid = validator.isFontStretchKeyword(values[index][1]) || validator.isGlobal(values[index][1]); + isStyleValid = validator.isFontStyleKeyword(values[index][1]) || validator.isGlobal(values[index][1]); + isVariantValid = validator.isFontVariantKeyword(values[index][1]) || validator.isGlobal(values[index][1]); + isWeightValid = validator.isFontWeightKeyword(values[index][1]) || validator.isGlobal(values[index][1]); + + if (isStyleValid && !isStyleSet) { + style.value = [values[index]]; + isStyleSet = true; + } else if (isVariantValid && !isVariantSet) { + variant.value = [values[index]]; + isVariantSet = true; + } else if (isWeightValid && !isWeightSet) { + weight.value = [values[index]]; + isWeightSet = true; + } else if (isStretchValid && !isStretchSet) { + stretch.value = [values[index]]; + isStretchSet = true; + } else if (isStyleValid + && isStyleSet + || isVariantValid + && isVariantSet + || isWeightValid + && isWeightSet + || isStretchValid + && isStretchSet) { + throw new InvalidPropertyError('Invalid font style / variant / weight / stretch value at ' + formatPosition(values[0][2][0]) + '. Ignoring.'); + } else { + break; + } + + index++; + } + + // now comes font-size ... + if (validator.isFontSizeKeyword(values[index][1]) + || validator.isUnit(values[index][1]) + && !validator.isDynamicUnit(values[index][1])) { + size.value = [values[index]]; + index++; + } else { + throw new InvalidPropertyError('Missing font size at ' + formatPosition(values[0][2][0]) + '. Ignoring.'); + } + + if (!values[index]) { + throw new InvalidPropertyError('Missing font family at ' + formatPosition(values[0][2][0]) + '. Ignoring.'); + } + + // ... and perhaps line-height + if (values[index] + && values[index][1] == Marker.FORWARD_SLASH + && values[index + 1] + && (validator.isLineHeightKeyword(values[index + 1][1]) + || validator.isUnit(values[index + 1][1]) + || validator.isNumber(values[index + 1][1]))) { + height.value = [values[index + 1]]; + index++; + index++; + } + + // ... and whatever comes next is font-family + family.value = []; + + while (values[index]) { + if (values[index][1] == Marker.COMMA) { + appendableFamilyName = false; + } else { + if (appendableFamilyName) { + family.value[family.value.length - 1][1] += Marker.SPACE + values[index][1]; + } else { + family.value.push(values[index]); + } + + appendableFamilyName = true; + } + + index++; + } + + if (family.value.length === 0) { + throw new InvalidPropertyError('Missing font family at ' + formatPosition(values[0][2][0]) + '. Ignoring.'); + } + + return components; +} + +function _anyIsFontSize(values, validator) { + var value; + var i, l; + + for (i = 0, l = values.length; i < l; i++) { + value = values[i]; + + if (validator.isFontSizeKeyword(value[1]) + || validator.isUnit(value[1]) + && !validator.isDynamicUnit(value[1]) + || validator.isFunction(value[1])) { + return true; + } + } + + return false; +} + +function _anyIsFontFamily(values, validator) { + var value; + var i, l; + + for (i = 0, l = values.length; i < l; i++) { + value = values[i]; + + if (validator.isIdentifier(value[1]) || validator.isQuotedText(value[1])) { + return true; + } + } + + return false; +} + +function fourValues(property, configuration) { + var componentNames = configuration[property.name].components; + var components = []; + var value = property.value; + + if (value.length < 1) { return []; } + + if (value.length < 2) { value[1] = value[0].slice(0); } + if (value.length < 3) { value[2] = value[0].slice(0); } + if (value.length < 4) { value[3] = value[1].slice(0); } + + for (var i = componentNames.length - 1; i >= 0; i--) { + var component = wrapSingle([ + Token.PROPERTY, + [Token.PROPERTY_NAME, componentNames[i]] + ]); + component.value = [value[i]]; + components.unshift(component); + } + + return components; +} + +function multiplex(splitWith) { + return function(property, configuration, validator) { + var splitsAt = []; + var values = property.value; + var i, j, l, m; + + // find split commas + for (i = 0, l = values.length; i < l; i++) { + if (values[i][1] == ',') { splitsAt.push(i); } + } + + if (splitsAt.length === 0) { return splitWith(property, configuration, validator); } + + var splitComponents = []; + + // split over commas, and into components + for (i = 0, l = splitsAt.length; i <= l; i++) { + var from = i === 0 ? 0 : splitsAt[i - 1] + 1; + var to = i < l ? splitsAt[i] : values.length; + + var _property = _wrapDefault(property.name, property, configuration); + _property.value = values.slice(from, to); + + if (_property.value.length > 0) { + splitComponents.push(splitWith(_property, configuration, validator)); + } + } + + var components = splitComponents[0]; + + // group component values from each split + for (i = 0, l = components.length; i < l; i++) { + components[i].multiplex = true; + + for (j = 1, m = splitComponents.length; j < m; j++) { + components[i].value.push([Token.PROPERTY_VALUE, Marker.COMMA]); + Array.prototype.push.apply(components[i].value, splitComponents[j][i].value); + } + } + + return components; + }; +} + +function listStyle(property, configuration, validator) { + var type = _wrapDefault('list-style-type', property, configuration); + var position = _wrapDefault('list-style-position', property, configuration); + var image = _wrapDefault('list-style-image', property, configuration); + var components = [type, position, image]; + + if (property.value.length == 1 && property.value[0][1] == 'inherit') { + type.value = position.value = image.value = [property.value[0]]; + return components; + } + + var values = property.value.slice(0); + var total = values.length; + var index = 0; + + // `image` first... + for (index = 0, total = values.length; index < total; index++) { + if (validator.isUrl(values[index][1]) || values[index][1] == '0') { + image.value = [values[index]]; + values.splice(index, 1); + break; + } + } + + // ... then `position` + for (index = 0, total = values.length; index < total; index++) { + if (validator.isListStylePositionKeyword(values[index][1])) { + position.value = [values[index]]; + values.splice(index, 1); + break; + } + } + + // ... and what's left is a `type` + if (values.length > 0 && (validator.isListStyleTypeKeyword(values[0][1]) || validator.isIdentifier(values[0][1]))) { + type.value = [values[0]]; + } + + return components; +} + +function transition(property, configuration, validator) { + var prop = _wrapDefault(property.name + '-property', property, configuration); + var duration = _wrapDefault(property.name + '-duration', property, configuration); + var timing = _wrapDefault(property.name + '-timing-function', property, configuration); + var delay = _wrapDefault(property.name + '-delay', property, configuration); + var components = [prop, duration, timing, delay]; + var values = property.value; + var value; + var durationSet = false; + var delaySet = false; + var propSet = false; + var timingSet = false; + var i; + var l; + + if (property.value.length == 1 && property.value[0][1] == 'inherit') { + prop.value = duration.value = timing.value = delay.value = property.value; + return components; + } + + if (values.length > 1 && _anyIsInherit(values)) { + throw new InvalidPropertyError('Invalid animation values at ' + formatPosition(values[0][2][0]) + '. Ignoring.'); + } + + for (i = 0, l = values.length; i < l; i++) { + value = values[i]; + + if (validator.isTime(value[1]) && !durationSet) { + duration.value = [value]; + durationSet = true; + } else if (validator.isTime(value[1]) && !delaySet) { + delay.value = [value]; + delaySet = true; + } else if ((validator.isGlobal(value[1]) || validator.isTimingFunction(value[1])) && !timingSet) { + timing.value = [value]; + timingSet = true; + } else if (validator.isIdentifier(value[1]) && !propSet) { + prop.value = [value]; + propSet = true; + } else { + throw new InvalidPropertyError('Invalid animation value at ' + formatPosition(value[2][0]) + '. Ignoring.'); + } + } + + return components; +} + +function widthStyleColor(property, configuration, validator) { + var descriptor = configuration[property.name]; + var components = [ + _wrapDefault(descriptor.components[0], property, configuration), + _wrapDefault(descriptor.components[1], property, configuration), + _wrapDefault(descriptor.components[2], property, configuration) + ]; + var color, style, width; + + for (var i = 0; i < 3; i++) { + var component = components[i]; + + if (component.name.indexOf('color') > 0) { color = component; } else if (component.name.indexOf('style') > 0) { style = component; } else { width = component; } + } + + if ((property.value.length == 1 && property.value[0][1] == 'inherit') + || (property.value.length == 3 && property.value[0][1] == 'inherit' && property.value[1][1] == 'inherit' && property.value[2][1] == 'inherit')) { + color.value = style.value = width.value = [property.value[0]]; + return components; + } + + var values = property.value.slice(0); + var match, matches; + + // NOTE: usually users don't follow the required order of parts in this shorthand, + // so we'll try to parse it caring as little about order as possible + + if (values.length > 0) { + matches = values.filter(_widthFilter(validator)); + match = matches.length > 1 && (matches[0][1] == 'none' || matches[0][1] == 'auto') ? matches[1] : matches[0]; + if (match) { + width.value = [match]; + values.splice(values.indexOf(match), 1); + } + } + + if (values.length > 0) { + match = values.filter(_styleFilter(validator))[0]; + if (match) { + style.value = [match]; + values.splice(values.indexOf(match), 1); + } + } + + if (values.length > 0) { + match = values.filter(_colorFilter(validator))[0]; + if (match) { + color.value = [match]; + values.splice(values.indexOf(match), 1); + } + } + + return components; +} + +module.exports = { + animation: animation, + background: background, + border: widthStyleColor, + borderRadius: borderRadius, + font: font, + fourValues: fourValues, + listStyle: listStyle, + multiplex: multiplex, + outline: widthStyleColor, + transition: transition +}; diff --git a/node_modules/clean-css/lib/optimizer/configuration/can-override.js b/node_modules/clean-css/lib/optimizer/configuration/can-override.js new file mode 100644 index 00000000..d5cb3fa0 --- /dev/null +++ b/node_modules/clean-css/lib/optimizer/configuration/can-override.js @@ -0,0 +1,314 @@ +var understandable = require('./properties/understandable'); + +function animationIterationCount(validator, value1, value2) { + if (!understandable(validator, value1, value2, 0, true) + && !(validator.isAnimationIterationCountKeyword(value2) || validator.isPositiveNumber(value2))) { + return false; + } if (validator.isVariable(value1) && validator.isVariable(value2)) { + return true; + } + + return validator.isAnimationIterationCountKeyword(value2) || validator.isPositiveNumber(value2); +} + +function animationName(validator, value1, value2) { + if (!understandable(validator, value1, value2, 0, true) + && !(validator.isAnimationNameKeyword(value2) || validator.isIdentifier(value2))) { + return false; + } if (validator.isVariable(value1) && validator.isVariable(value2)) { + return true; + } + + return validator.isAnimationNameKeyword(value2) || validator.isIdentifier(value2); +} + +function areSameFunction(validator, value1, value2) { + if (!validator.isFunction(value1) || !validator.isFunction(value2)) { + return false; + } + + var function1Name = value1.substring(0, value1.indexOf('(')); + var function2Name = value2.substring(0, value2.indexOf('(')); + + var function1Value = value1.substring(function1Name.length + 1, value1.length - 1); + var function2Value = value2.substring(function2Name.length + 1, value2.length - 1); + + if (validator.isFunction(function1Value) || validator.isFunction(function2Value)) { + return function1Name === function2Name && areSameFunction(validator, function1Value, function2Value); + } + return function1Name === function2Name; +} + +function backgroundPosition(validator, value1, value2) { + if (!understandable(validator, value1, value2, 0, true) + && !(validator.isBackgroundPositionKeyword(value2) || validator.isGlobal(value2))) { + return false; + } if (validator.isVariable(value1) && validator.isVariable(value2)) { + return true; + } if (validator.isBackgroundPositionKeyword(value2) || validator.isGlobal(value2)) { + return true; + } + + return unit(validator, value1, value2); +} + +function backgroundSize(validator, value1, value2) { + if (!understandable(validator, value1, value2, 0, true) + && !(validator.isBackgroundSizeKeyword(value2) || validator.isGlobal(value2))) { + return false; + } if (validator.isVariable(value1) && validator.isVariable(value2)) { + return true; + } if (validator.isBackgroundSizeKeyword(value2) || validator.isGlobal(value2)) { + return true; + } + + return unit(validator, value1, value2); +} + +function color(validator, value1, value2) { + if (!understandable(validator, value1, value2, 0, true) && !validator.isColor(value2)) { + return false; + } if (validator.isVariable(value1) && validator.isVariable(value2)) { + return true; + } if (!validator.colorOpacity && (validator.isRgbColor(value1) || validator.isHslColor(value1))) { + return false; + } if (!validator.colorOpacity && (validator.isRgbColor(value2) || validator.isHslColor(value2))) { + return false; + } if (!validator.colorHexAlpha && (validator.isHexAlphaColor(value1) || validator.isHexAlphaColor(value2))) { + return false; + } if (validator.isColor(value1) && validator.isColor(value2)) { + return true; + } + + return sameFunctionOrValue(validator, value1, value2); +} + +function components(overrideCheckers) { + return function(validator, value1, value2, position) { + return overrideCheckers[position](validator, value1, value2); + }; +} + +function fontFamily(validator, value1, value2) { + return understandable(validator, value1, value2, 0, true); +} + +function image(validator, value1, value2) { + if (!understandable(validator, value1, value2, 0, true) && !validator.isImage(value2)) { + return false; + } if (validator.isVariable(value1) && validator.isVariable(value2)) { + return true; + } if (validator.isImage(value2)) { + return true; + } if (validator.isImage(value1)) { + return false; + } + + return sameFunctionOrValue(validator, value1, value2); +} + +function keyword(propertyName) { + return function(validator, value1, value2) { + if (!understandable(validator, value1, value2, 0, true) && !validator.isKeyword(propertyName)(value2)) { + return false; + } if (validator.isVariable(value1) && validator.isVariable(value2)) { + return true; + } + + return validator.isKeyword(propertyName)(value2); + }; +} + +function keywordWithGlobal(propertyName) { + return function(validator, value1, value2) { + if (!understandable(validator, value1, value2, 0, true) + && !(validator.isKeyword(propertyName)(value2) || validator.isGlobal(value2))) { + return false; + } if (validator.isVariable(value1) && validator.isVariable(value2)) { + return true; + } + + return validator.isKeyword(propertyName)(value2) || validator.isGlobal(value2); + }; +} + +function propertyName(validator, value1, value2) { + if (!understandable(validator, value1, value2, 0, true) && !validator.isIdentifier(value2)) { + return false; + } if (validator.isVariable(value1) && validator.isVariable(value2)) { + return true; + } + + return validator.isIdentifier(value2); +} + +function sameFunctionOrValue(validator, value1, value2) { + return areSameFunction(validator, value1, value2) + ? true + : value1 === value2; +} + +function textShadow(validator, value1, value2) { + if (!understandable(validator, value1, value2, 0, true) + && !(validator.isUnit(value2) + || validator.isColor(value2) + || validator.isGlobal(value2))) { + return false; + } if (validator.isVariable(value1) && validator.isVariable(value2)) { + return true; + } + + return validator.isUnit(value2) || validator.isColor(value2) || validator.isGlobal(value2); +} + +function time(validator, value1, value2) { + if (!understandable(validator, value1, value2, 0, true) && !validator.isTime(value2)) { + return false; + } if (validator.isVariable(value1) && validator.isVariable(value2)) { + return true; + } if (validator.isTime(value1) && !validator.isTime(value2)) { + return false; + } if (validator.isTime(value2)) { + return true; + } if (validator.isTime(value1)) { + return false; + } if (validator.isFunction(value1) + && !validator.isPrefixed(value1) + && validator.isFunction(value2) + && !validator.isPrefixed(value2)) { + return true; + } + + return sameFunctionOrValue(validator, value1, value2); +} + +function timingFunction(validator, value1, value2) { + if (!understandable(validator, value1, value2, 0, true) + && !(validator.isTimingFunction(value2) || validator.isGlobal(value2))) { + return false; + } if (validator.isVariable(value1) && validator.isVariable(value2)) { + return true; + } + + return validator.isTimingFunction(value2) || validator.isGlobal(value2); +} + +function unit(validator, value1, value2) { + if (!understandable(validator, value1, value2, 0, true) && !validator.isUnit(value2)) { + return false; + } if (validator.isVariable(value1) && validator.isVariable(value2)) { + return true; + } if (validator.isUnit(value1) && !validator.isUnit(value2)) { + return false; + } if (validator.isUnit(value2)) { + return true; + } if (validator.isUnit(value1)) { + return false; + } if (validator.isFunction(value1) + && !validator.isPrefixed(value1) + && validator.isFunction(value2) + && !validator.isPrefixed(value2)) { + return true; + } + + return sameFunctionOrValue(validator, value1, value2); +} + +function unitOrKeywordWithGlobal(propertyName) { + var byKeyword = keywordWithGlobal(propertyName); + + return function(validator, value1, value2) { + return unit(validator, value1, value2) || byKeyword(validator, value1, value2); + }; +} + +function unitOrNumber(validator, value1, value2) { + if (!understandable(validator, value1, value2, 0, true) + && !(validator.isUnit(value2) + || validator.isNumber(value2))) { + return false; + } if (validator.isVariable(value1) && validator.isVariable(value2)) { + return true; + } if ((validator.isUnit(value1) + || validator.isNumber(value1)) + && !(validator.isUnit(value2) + || validator.isNumber(value2))) { + return false; + } if (validator.isUnit(value2) || validator.isNumber(value2)) { + return true; + } if (validator.isUnit(value1) || validator.isNumber(value1)) { + return false; + } if (validator.isFunction(value1) + && !validator.isPrefixed(value1) + && validator.isFunction(value2) + && !validator.isPrefixed(value2)) { + return true; + } + + return sameFunctionOrValue(validator, value1, value2); +} + +function zIndex(validator, value1, value2) { + if (!understandable(validator, value1, value2, 0, true) && !validator.isZIndex(value2)) { + return false; + } if (validator.isVariable(value1) && validator.isVariable(value2)) { + return true; + } + + return validator.isZIndex(value2); +} + +module.exports = { + generic: { + color: color, + components: components, + image: image, + propertyName: propertyName, + time: time, + timingFunction: timingFunction, + unit: unit, + unitOrNumber: unitOrNumber + }, + property: { + animationDirection: keywordWithGlobal('animation-direction'), + animationFillMode: keyword('animation-fill-mode'), + animationIterationCount: animationIterationCount, + animationName: animationName, + animationPlayState: keywordWithGlobal('animation-play-state'), + backgroundAttachment: keyword('background-attachment'), + backgroundClip: keywordWithGlobal('background-clip'), + backgroundOrigin: keyword('background-origin'), + backgroundPosition: backgroundPosition, + backgroundRepeat: keyword('background-repeat'), + backgroundSize: backgroundSize, + bottom: unitOrKeywordWithGlobal('bottom'), + borderCollapse: keyword('border-collapse'), + borderStyle: keywordWithGlobal('*-style'), + clear: keywordWithGlobal('clear'), + cursor: keywordWithGlobal('cursor'), + display: keywordWithGlobal('display'), + float: keywordWithGlobal('float'), + left: unitOrKeywordWithGlobal('left'), + fontFamily: fontFamily, + fontStretch: keywordWithGlobal('font-stretch'), + fontStyle: keywordWithGlobal('font-style'), + fontVariant: keywordWithGlobal('font-variant'), + fontWeight: keywordWithGlobal('font-weight'), + listStyleType: keywordWithGlobal('list-style-type'), + listStylePosition: keywordWithGlobal('list-style-position'), + outlineStyle: keywordWithGlobal('*-style'), + overflow: keywordWithGlobal('overflow'), + position: keywordWithGlobal('position'), + right: unitOrKeywordWithGlobal('right'), + textAlign: keywordWithGlobal('text-align'), + textDecoration: keywordWithGlobal('text-decoration'), + textOverflow: keywordWithGlobal('text-overflow'), + textShadow: textShadow, + top: unitOrKeywordWithGlobal('top'), + transform: sameFunctionOrValue, + verticalAlign: unitOrKeywordWithGlobal('vertical-align'), + visibility: keywordWithGlobal('visibility'), + whiteSpace: keywordWithGlobal('white-space'), + zIndex: zIndex + } +}; diff --git a/node_modules/clean-css/lib/optimizer/configuration/properties/understandable.js b/node_modules/clean-css/lib/optimizer/configuration/properties/understandable.js new file mode 100644 index 00000000..60f34293 --- /dev/null +++ b/node_modules/clean-css/lib/optimizer/configuration/properties/understandable.js @@ -0,0 +1,15 @@ +var sameVendorPrefixes = require('../../vendor-prefixes').same; + +function understandable(validator, value1, value2, _position, isPaired) { + if (!sameVendorPrefixes(value1, value2)) { + return false; + } + + if (isPaired && validator.isVariable(value1) !== validator.isVariable(value2)) { + return false; + } + + return true; +} + +module.exports = understandable; diff --git a/node_modules/clean-css/lib/optimizer/configuration/restore.js b/node_modules/clean-css/lib/optimizer/configuration/restore.js new file mode 100644 index 00000000..af902088 --- /dev/null +++ b/node_modules/clean-css/lib/optimizer/configuration/restore.js @@ -0,0 +1,294 @@ +var shallowClone = require('../clone').shallow; + +var Token = require('../../tokenizer/token'); +var Marker = require('../../tokenizer/marker'); + +function isInheritOnly(values) { + for (var i = 0, l = values.length; i < l; i++) { + var value = values[i][1]; + + if (value != 'inherit' && value != Marker.COMMA && value != Marker.FORWARD_SLASH) { return false; } + } + + return true; +} + +function background(property, configuration, lastInMultiplex) { + var components = property.components; + var restored = []; + var needsOne, needsBoth; + + function restoreValue(component) { + Array.prototype.unshift.apply(restored, component.value); + } + + function isDefaultValue(component) { + var descriptor = configuration[component.name]; + + if (descriptor.doubleValues && descriptor.defaultValue.length == 1) { + return component.value[0][1] == descriptor.defaultValue[0] + && (component.value[1] + ? component.value[1][1] == descriptor.defaultValue[0] + : true); + } if (descriptor.doubleValues && descriptor.defaultValue.length != 1) { + return component.value[0][1] == descriptor.defaultValue[0] + && ((component.value[1] ? component.value[1][1] : component.value[0][1]) + == descriptor.defaultValue[1]); + } + return component.value[0][1] == descriptor.defaultValue; + } + + for (var i = components.length - 1; i >= 0; i--) { + var component = components[i]; + var isDefault = isDefaultValue(component); + + if (component.name == 'background-clip') { + var originComponent = components[i - 1]; + var isOriginDefault = isDefaultValue(originComponent); + + needsOne = component.value[0][1] == originComponent.value[0][1]; + + needsBoth = !needsOne && ( + (isOriginDefault && !isDefault) + || (!isOriginDefault && !isDefault) + || (!isOriginDefault && isDefault && component.value[0][1] != originComponent.value[0][1])); + + if (needsOne) { + restoreValue(originComponent); + } else if (needsBoth) { + restoreValue(component); + restoreValue(originComponent); + } + + i--; + } else if (component.name == 'background-size') { + var positionComponent = components[i - 1]; + var isPositionDefault = isDefaultValue(positionComponent); + + needsOne = !isPositionDefault && isDefault; + + needsBoth = !needsOne + && (isPositionDefault && !isDefault || !isPositionDefault && !isDefault); + + if (needsOne) { + restoreValue(positionComponent); + } else if (needsBoth) { + restoreValue(component); + restored.unshift([Token.PROPERTY_VALUE, Marker.FORWARD_SLASH]); + restoreValue(positionComponent); + } else if (positionComponent.value.length == 1) { + restoreValue(positionComponent); + } + + i--; + } else { + if (isDefault || configuration[component.name].multiplexLastOnly && !lastInMultiplex) { continue; } + + restoreValue(component); + } + } + + if (restored.length === 0 && property.value.length == 1 && property.value[0][1] == '0') { restored.push(property.value[0]); } + + if (restored.length === 0) { restored.push([Token.PROPERTY_VALUE, configuration[property.name].defaultValue]); } + + if (isInheritOnly(restored)) { return [restored[0]]; } + + return restored; +} + +function borderRadius(property) { + if (property.multiplex) { + var horizontal = shallowClone(property); + var vertical = shallowClone(property); + + for (var i = 0; i < 4; i++) { + var component = property.components[i]; + + var horizontalComponent = shallowClone(property); + horizontalComponent.value = [component.value[0]]; + horizontal.components.push(horizontalComponent); + + var verticalComponent = shallowClone(property); + // FIXME: only shorthand compactor (see breakup#borderRadius) knows that border radius + // longhands have two values, whereas tokenizer does not care about populating 2nd value + // if it's missing, hence this fallback + verticalComponent.value = [component.value[1] || component.value[0]]; + vertical.components.push(verticalComponent); + } + + var horizontalValues = fourValues(horizontal); + var verticalValues = fourValues(vertical); + + if (horizontalValues.length == verticalValues.length + && horizontalValues[0][1] == verticalValues[0][1] + && (horizontalValues.length > 1 ? horizontalValues[1][1] == verticalValues[1][1] : true) + && (horizontalValues.length > 2 ? horizontalValues[2][1] == verticalValues[2][1] : true) + && (horizontalValues.length > 3 ? horizontalValues[3][1] == verticalValues[3][1] : true)) { + return horizontalValues; + } + return horizontalValues.concat([[Token.PROPERTY_VALUE, Marker.FORWARD_SLASH]]).concat(verticalValues); + } + return fourValues(property); +} + +function font(property, configuration) { + var components = property.components; + var restored = []; + var component; + var componentIndex = 0; + var fontFamilyIndex = 0; + + if (property.value[0][1].indexOf(Marker.INTERNAL) === 0) { + property.value[0][1] = property.value[0][1].substring(Marker.INTERNAL.length); + return property.value; + } + + // first four components are optional + while (componentIndex < 4) { + component = components[componentIndex]; + + if (component.value[0][1] != configuration[component.name].defaultValue) { + Array.prototype.push.apply(restored, component.value); + } + + componentIndex++; + } + + // then comes font-size + Array.prototype.push.apply(restored, components[componentIndex].value); + componentIndex++; + + // then may come line-height + if (components[componentIndex].value[0][1] != configuration[components[componentIndex].name].defaultValue) { + Array.prototype.push.apply(restored, [[Token.PROPERTY_VALUE, Marker.FORWARD_SLASH]]); + Array.prototype.push.apply(restored, components[componentIndex].value); + } + + componentIndex++; + + // then comes font-family + while (components[componentIndex].value[fontFamilyIndex]) { + restored.push(components[componentIndex].value[fontFamilyIndex]); + + if (components[componentIndex].value[fontFamilyIndex + 1]) { + restored.push([Token.PROPERTY_VALUE, Marker.COMMA]); + } + + fontFamilyIndex++; + } + + if (isInheritOnly(restored)) { + return [restored[0]]; + } + + return restored; +} + +function fourValues(property) { + var components = property.components; + var value1 = components[0].value[0]; + var value2 = components[1].value[0]; + var value3 = components[2].value[0]; + var value4 = components[3].value[0]; + + if (value1[1] == value2[1] && value1[1] == value3[1] && value1[1] == value4[1]) { + return [value1]; + } if (value1[1] == value3[1] && value2[1] == value4[1]) { + return [value1, value2]; + } if (value2[1] == value4[1]) { + return [value1, value2, value3]; + } + return [value1, value2, value3, value4]; +} + +function multiplex(restoreWith) { + return function(property, configuration) { + if (!property.multiplex) { return restoreWith(property, configuration, true); } + + var multiplexSize = 0; + var restored = []; + var componentMultiplexSoFar = {}; + var i, l; + + // At this point we don't know what's the multiplex size, e.g. how many background layers are there + for (i = 0, l = property.components[0].value.length; i < l; i++) { + if (property.components[0].value[i][1] == Marker.COMMA) { multiplexSize++; } + } + + for (i = 0; i <= multiplexSize; i++) { + var _property = shallowClone(property); + + // We split multiplex into parts and restore them one by one + for (var j = 0, m = property.components.length; j < m; j++) { + var componentToClone = property.components[j]; + var _component = shallowClone(componentToClone); + _property.components.push(_component); + + // The trick is some properties has more than one value, so we iterate over values looking for + // a multiplex separator - a comma + for (var k = componentMultiplexSoFar[_component.name] || 0, n = componentToClone.value.length; k < n; k++) { + if (componentToClone.value[k][1] == Marker.COMMA) { + componentMultiplexSoFar[_component.name] = k + 1; + break; + } + + _component.value.push(componentToClone.value[k]); + } + } + + // No we can restore shorthand value + var lastInMultiplex = i == multiplexSize; + var _restored = restoreWith(_property, configuration, lastInMultiplex); + Array.prototype.push.apply(restored, _restored); + + if (i < multiplexSize) { restored.push([Token.PROPERTY_VALUE, Marker.COMMA]); } + } + + return restored; + }; +} + +function withoutDefaults(property, configuration) { + var components = property.components; + var restored = []; + + for (var i = components.length - 1; i >= 0; i--) { + var component = components[i]; + var descriptor = configuration[component.name]; + + if (component.value[0][1] != descriptor.defaultValue || ('keepUnlessDefault' in descriptor) && !isDefault(components, configuration, descriptor.keepUnlessDefault)) { + restored.unshift(component.value[0]); + } + } + + if (restored.length === 0) { restored.push([Token.PROPERTY_VALUE, configuration[property.name].defaultValue]); } + + if (isInheritOnly(restored)) { return [restored[0]]; } + + return restored; +} + +function isDefault(components, configuration, propertyName) { + var component; + var i, l; + + for (i = 0, l = components.length; i < l; i++) { + component = components[i]; + + if (component.name == propertyName && component.value[0][1] == configuration[propertyName].defaultValue) { + return true; + } + } + + return false; +} + +module.exports = { + background: background, + borderRadius: borderRadius, + font: font, + fourValues: fourValues, + multiplex: multiplex, + withoutDefaults: withoutDefaults +}; |
