first commit

app_vue/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
+};

app_vue/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
+  }
+};

app_vue/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;

app_vue/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
+};