summaryrefslogtreecommitdiff
path: root/node_modules/clean-css/lib/optimizer/configuration
diff options
context:
space:
mode:
Diffstat (limited to 'node_modules/clean-css/lib/optimizer/configuration')
-rw-r--r--node_modules/clean-css/lib/optimizer/configuration/break-up.js656
-rw-r--r--node_modules/clean-css/lib/optimizer/configuration/can-override.js314
-rw-r--r--node_modules/clean-css/lib/optimizer/configuration/properties/understandable.js15
-rw-r--r--node_modules/clean-css/lib/optimizer/configuration/restore.js294
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
+};