Destruction of shorthand 'background' by prop 'background-image' and the rest props.
@param {string} css
545170
function destructShorthand(css) {
    css.walkDecls(PATTERN_BACKGROUND, (decl) => {
        if (!isNodeIgnored(decl)) {
            const value = decl.value;
            const hasURL = PATTERN_URL.test(value);

            if (hasURL) {
                let valueStartBgColor = '';
                let valueEndBgColor = '';
                const layers = value
                    .replace(PATTERN_START_BACKGROUND_COLOR, (match) => {
                        valueStartBgColor = match;

                        return '';
                    })
                    .replace(PATTERN_END_BACKGROUND_COLOR, (match) => {
                        valueEndBgColor = match;

                        return '';
                    })
                    .split(/,/)
                    .reduce((result, subLine, index) => {
                        if (index === 0) {
                            return [
                                subLine,
                            ];
                        }

                        const indexLast = result.length - 1;
                        const subLineLast = result[indexLast];

                        if ((subLineLast.match(/\(/g) || []).length !== (subLineLast.match(/\)/g) || []).length) {
                            const lastItem = `${result[indexLast]},${subLine}`;

                            return [
                                ...result.slice(0, -1),
                                lastItem,
                            ];
                        }

                        return [
                            ...result,
                            subLine,
                        ];
                    }, []);
                const isMultiple = layers.length > 1;

                // Calculate 'background-image' value
                const valueURL = layers
                    .map((layer) => {
                        const hasURLValue = PATTERN_URL.test(layer);
                        const valueGradient = layer.match(PATTERN_GRADIENT) ? layer.match(PATTERN_GRADIENT)[0] : null;

                        if (hasURLValue) {
                            return layer
                                .replace(/(?:[^\s]+[\s]+)*(url\([^)]*\))(?:[\s]+[^\s]+)*/ig, '$1');
                        }

                        if (valueGradient) {
                            return layer
                                .replace(/([^\s]+(?:[\s]+[^\s]+)*)/ig, valueGradient);
                        }

                        return layer
                            .replace(/[^\s]+(?:[\s]+[^\s]+)*/ig, 'initial');
                    })
                    .join(',');

                decl.cloneAfter({
                    prop: 'background-image',
                    value: valueURL.trim(),
                });

                // Calculate 'background' value
                const valueRest = layers
                    .map((layer) => {
                        const hasURLValue = PATTERN_URL.test(layer);

                        if (!hasURLValue) {
                            return layer;
                        }

                        return layer
                            .replace(
                                /([^\s]+[\s]+)*(?:url\([^)]*\)(?:[\s]+(?=[^\s]))?)([^\s]+[\s]*[^\s]+)*/ig,
                                (match, group1, group2) => {
                                    const startPart = group1 || '';
                                    const endPart = group2 || '';
                                    const result = (`${startPart}${endPart}`);

                                    if (isMultiple && !result.trim()) {
                                        return `${startPart}initial${endPart}`;
                                    }

                                    return result;
                                }
                            );
                    })
                    .join(',');

                if (
                    !valueStartBgColor.trim() &&
                    !valueEndBgColor.trim() &&
                    !valueRest.replace(/(?:initial)|[\s,]+/ig, '')
                ) {
                    decl.remove();
                } else {
                    decl.replaceWith(decl.clone({
                        value: `${valueStartBgColor}${valueRest}${valueEndBgColor}`.trim(),
                    }));
                }
            }
        }
    });
}
1310517
function destroy() {
         me.pool.push(this.color);
         this.color = undefined;

         this._super(me.Renderable, "destroy");
       }
1178295
function removeStyleProperties(styles, properties) {
  _(styles).each(function(value, key) {
    if(_(properties).include(key)) {
      delete styles[key]
    }
  });
  return styles;
}
414604
async function processCss({ from, to, banner }) {
  const src = await readFile(from, 'utf8');

  const { plugins, options } = await postcssLoadConfig({
    from,
    to,
    map: { inline: false },
  });

  const sourceCss = banner + src;
  const result = await postcss(plugins).process(sourceCss, options);

  compileWarn('PostCSS', 'WARN', result.warnings());

  // minify resulting CSS
  const min = await new CleanCSS({
    level: {
      1: { all: true },
      2: { all: true },
    },
    returnPromise: true,
    sourceMap: true,
  }).minify(result.css, result.map.toString());

  compileWarn('CleanCSS', 'ERR', min.errors);
  compileWarn('CleanCSS', 'WARN', min.warnings);

  // clean-css removes the source map comment so we need to add it back in
  min.styles = `${min.styles}\n/*# sourceMappingURL=${basename(
    options.to,
  )}.map */`;

  writeFile(options.to, min.styles);
  writeFile(`${options.to}.map`, min.sourceMap.toString());

  return {
    min,
    result,
  };
}
226476
function stopDefaultBrowserBehavior(element, css_class) {
      // changed from making many style changes to just adding a preset classname
      // less DOM manipulations, less code, and easier to control in the CSS side of things
      // hammer.js doesn't come with CSS, but ionic does, which is why we prefer this method
      if(element && element.classList) {
        element.classList.add(css_class);
        element.onselectstart = function() {
          return false;
        };
      }
    }
160618
function(css,retinaobject,properties){
        var _tmpSlice = retinaobject.slicekey;
        var _retinaCSSCode = "";
        var _sprite ;
            _retinaCSSCode +='\n\n@media only screen and (-webkit-min-device-pixel-ratio: 1.5),only screen and (min--moz-device-pixel-ratio: 1.5),only screen and (min-resolution: 240dpi){';
            for(var key in _tmpSlice){
                _sprite = _tmpSlice[key].code;
                _retinaCSSCode += _tmpSlice[key].className;
                _retinaCSSCode += "{background-image:url(.";
                _retinaCSSCode += _outSpritePath.slice(_outSpritePath.lastIndexOf("/"),_outSpritePath.length);
                _retinaCSSCode += "/";
                _retinaCSSCode += _outSpriteName.replace(".png","@2x.png")+");";
                _retinaCSSCode += "background-position: -";
                _retinaCSSCode += (_sprite.x) / 2;
                _retinaCSSCode += "px -";
                _retinaCSSCode += (_sprite.y) / 2;
                _retinaCSSCode += "px;background-size:";
                _retinaCSSCode += (properties.width) / 2 + 'px;}';
            }
            _retinaCSSCode += '\n}\n';
        css = css + _retinaCSSCode;
        return css;
    }
1270795
function fixRelativeCssUrls(cssText, baseUrl) {
    const cssUrls = cssText
        // Remove comments
        .replace(regex.cssComments, '')
        // Match url(...) values
        .match(regex.cssUrls) || [];

    cssUrls.forEach(cssUrl => {
        const oldUrl = cssUrl.replace(regex.cssUrls, '$1');
        const newUrl = getFullUrl(oldUrl, baseUrl);

        cssText = cssText.replace(cssUrl, cssUrl.replace(oldUrl, newUrl));
    });

    return cssText;
}
1188356
function (css) {
                        return function () {
                            var currentCss = d3.select(this).attr("class") || "";
                            if (currentCss.indexOf(css) === -1) {
                                currentCss += " " + css;
                            }
                            return currentCss.trim();
                        };
                    }
914138
protected function removeCss($css)
    {
        $key=array_keys($this->data['css']['internal'],$css);
        if($key){
            array_splice($this->data['css']['internal'],$key[0],1);
        }

        $key=array_keys($this->data['css']['external'],$css);
        if($key){
            array_splice($this->data['css']['external'],$key[0],1);
        }
    }
731507
function() {

        this.id = null;
        this.lonlat = null;
        this.size = null;
        this.contentHTML = null;
        
        this.backgroundColor = null;
        this.opacity = null;
        this.border = null;
        
        if (this.closeOnMove && this.map) {
            this.map.events.unregister("movestart", this, this.hide);
        }

        this.events.destroy();
        this.events = null;
        
        if (this.closeDiv) {
            OpenLayers.Event.stopObservingElement(this.closeDiv); 
            this.groupDiv.removeChild(this.closeDiv);
        }
        this.closeDiv = null;
        
        this.div.removeChild(this.groupDiv);
        this.groupDiv = null;

        if (this.map != null) {
            this.map.removePopup(this);
        }
        this.map = null;
        this.div = null;
        
        this.autoSize = null;
        this.minSize = null;
        this.maxSize = null;
        this.padding = null;
        this.panMapIfOutOfView = null;
    }
641027
function createStyledElement(component, props, children) {
  return (...chunks) => {
    const classNames = chunks.map(chunk => (chunk ? glamor(chunk) : ''))

    if (props) {
      const { innerRef, forwardRef, css, className, ...restProps } = props

      if (css) {
        classNames.push(glamor(css))
      }

      if (className) {
        classNames.push(className)
      }

      return createElement(
        component,
        {
          [forwardRef ? 'innerRef' : 'ref']: innerRef,
          className: classNames.join(' ').trim(),
          ...restProps,
        },
        restProps.children || children
      )
    } else {
      return ({ innerRef, forwardRef, css, className = '', ...restProps }) => {
        const glamorClass = css ? glamor(css) : ''

        return createElement(component, {
          [forwardRef ? 'innerRef' : 'ref']: innerRef,
          className: classNames.concat(glamorClass, className).join(' ').trim(),
          ...restProps,
        })
      }
    }
  }
}
1210728
function background(options) {
    options = options || {};
    // ReSharper disable once UnusedParameter
    return function (config) {
        var values = [];
        [
            'attachment',
            'clip',
            'color',
            'image',
            'origin',
            'position',
            'repeat',
            'size'
        ].forEach(function (prop) {
            if (options.hasOwnProperty(prop)) {
                values.push(options[prop]);
            }
        });
        if (values.length) {
            return [['background', values.join(' ')]];
        }
        return [];
    };
}
844658
function cssVarsDebounced(settings, delay = 100) {
    clearTimeout(debounceTimer);
    debounceTimer = setTimeout(function() {
        settings.__benchmark = null;
        cssVars(settings);
    }, delay);
}
462839
function dedupeCss() {
  const prefixRegex = /-(webkit|moz|ms|o)-.+/;

  return insert.transform(function(contents) {
    // Parse the CSS into an AST.
    const parsed = postcss.parse(contents);

    // Walk through all the rules, skipping comments, media queries etc.
    parsed.walk(function(rule) {
      // Skip over any comments, media queries and rules that have less than 2 properties.
      if (rule.type !== 'rule' || !rule.nodes || rule.nodes.length < 2) return;

      // Walk all of the properties within a rule.
      rule.walk(function(prop) {
        // Check if there's a similar property that comes after the current one.
        const hasDuplicate = validateProp(prop) && _.find(rule.nodes, function(otherProp) {
          return prop !== otherProp && prop.prop === otherProp.prop && validateProp(otherProp);
        });

        // Remove the declaration if it's duplicated.
        if (hasDuplicate) {
          prop.remove();

          gutil.log(gutil.colors.yellow(
            'Removed duplicate property: "' +
            prop.prop + ': ' + prop.value + '" from "' + rule.selector + '"...'
          ));
        }
      });
    });

    // Turn the AST back into CSS.
    return parsed.toResult().css;
  });

  // Checks if a property is a style declaration and that it
  // doesn't contain any vendor prefixes.
  function validateProp(prop) {
    return prop && prop.type === 'decl' && ![prop.prop, prop.value].some(function(value) {
      return value.indexOf('-') > -1 && prefixRegex.test(value);
    });
  }
}
959229
function processCSSFiles(optionsIn = null, configFileLocationIn = '') {


		var continueCSSFilesProcess = function(optionsIn2){
			// console.log(optionsIn2)
				// console.log(optionsIn2.css)
			CPEVENTS.removeListener('CONFIG_READ_REDUCE_PROPS_END', continueCSSFilesProcess);

			var continueCSSFilesProcessAfterConfig = function(optionsIn3){

				
				CPEVENTS.removeListener('continueCSSFilesProcessAfterConfig', continueCSSFilesProcessAfterConfig);

				//config
				if (OPTIONS.css === undefined && CONFIG.options.css) {
					OPTIONS.css = CONFIG.options.css;
				}

				//Options
				if (optionsIn !== null && optionsIn !== undefined) {

					for (key in optionsIn) {

						OPTIONS[key] = optionsIn[key];	
						
					}
				}
				// console.log(CONFIG)
				// console.log(optionsIn.css)
				// console.log(optionsIn3)
				//CSS Files
				// var files = CONFIG.options.css;

				// if (optionsIn.css !== null && optionsIn.css !== undefined) {

				// files = optionsIn.css;
					
				// }

				files = OPTIONS.css;

				if (files !== undefined && files !== '') {
					tmpCSSPaths = [];

					//check for file or files
					switch (typeof files) {
						case 'object':
						case 'array':
								
							for (i = 0; i < files.length; ++i) {

								getFilePaths(files[i], ['.css']);
							}

							if (tmpCSSPaths.length) {
								files = tmpCSSPaths;
							}

							break;
						case 'string':
							//formats
							files = files.replace(/ /g, '');
							// comma delimited list - filename1.css, filename2.css
							if (files.indexOf(',') > -1) { 
								files = files.replace(/^\s+|\s+$/g,'').split(',');
								
								for (i = 0; i < files.length; ++i) {

									getFilePaths(files[i], ['.css']);

								}

								if (tmpCSSPaths.length) {
									files = tmpCSSPaths;
								}


							} else {

								//string path
								getFilePaths(files, ['.css']);

								if (tmpCSSPaths.length) {
									files = tmpCSSPaths;
								}

							}

							break;
					} //end of switch

					fileLocation = files.toString();

					CPEVENTS.on('CSS_READ_AGAIN', function(){

						readCSSFile(files);
					});
					CPEVENTS.on('CSS_READ_END', function(){
						// CPEVENTS.emit('CONFIG_READ_REDUCE_PROPS_END');
						processCSS(null,OPTIONS,function(){

						});	
						
					});

					readCSSFile(files);


				} else { //end of files nothing check

					//
				}




			};

			if (currentConfig != configFileLocationIn) { //don't read same config
				CPEVENTS.on('CONFIG_READ_END', continueCSSFilesProcessAfterConfig); //end of config read
			}

			currentConfig = configFileLocationIn;

			if (configFileLocationIn != 'cmd_default') {
				readConfig(configFileLocationIn);	
			} else if (configFileLocationIn == 'cmd_default') {
				readConfig(configFileLocationIn, optionsIn);	
			}
		};

		CPEVENTS.on('CONFIG_READ_REDUCE_PROPS_END', continueCSSFilesProcess); //end of reduce config read
		

		if (!hasReadReduceDeclarations && fs.existsSync(OPTIONS.reduce_declarations_file_location)) {
			
			readReduceDeclarations();
		}

		if (!hasReadReduceDeclarations && !fs.existsSync(OPTIONS.reduce_declarations_file_location)) {

			//default process settings
			var default_reduce_declarations_config = {
				"declaration_names" : [
					"font",
					"margin",
					"padding",
					"list-style",
					"outline",
					"border",
					"border-top",
					"border-right",
					"border-bottom",
					"border-left",
					"border-radius",
					"border-color",
					"border-top-color",
					"border-right-color",
					"border-bottom-color",
					"border-left-color",
					"color",
					"background-color",
					"font-color",
					"outline-color",
					"box-shadow",
					"text-shadow",
					"float",
					"font-family",
					"font-size",
					"font-weight",
					"font-style",
					"font-variant",
					"font-stretch"
				]
			};

			if (optionsIn !== null && (optionsIn['reduceConfig'] === undefined || optionsIn['reduceConfig'] === null)) {

				optionsIn['reduceConfig'] = default_reduce_declarations_config;
				readReduceDeclarations(optionsIn['reduceConfig']);
			} else {

				readReduceDeclarations();
			}
		}

	}
889446
function removeCss(ids) {
  ids.forEach((id) => {
    if (--inserted[id] <= 0) {
      const elem = document.getElementById(id)
      if (elem) {
        elem.parentNode.removeChild(elem)
      }
    }
  })
}
1304121
function (context) {
		var file = context.file;

		try {
			file.data = cleanCSS.process(file.data);
		} catch (err) {
			context.error('CSS syntax error: "%s"',
				file.pathname);
		}
	}