text: /*
  	MIT License http://www.opensource.org/licenses/mit-license.php
  	Author Tobias Koppers @sokra
  */
  var Tokenizer = require("css-selector-tokenizer");
  var postcss = require("postcss");
  var loaderUtils = require("loader-utils");
  var getLocalIdent = require("./getLocalIdent");
  
  var localByDefault = require("postcss-modules-local-by-default");
  var extractImports = require("postcss-modules-extract-imports");
  var modulesScope = require("postcss-modules-scope");
  var cssnano = require("cssnano");
  
  var parserPlugin = postcss.plugin("css-loader-parser", function(options) {
  	return function(css) {
  		var imports = {};
  		var exports = {};
  		var importItems = [];
  		var urlItems = [];
  
  		function replaceImportsInString(str) {
  			var tokens = str.split(/(\S+)/);
  			tokens = tokens.map(function(token) {
  				var importIndex = imports["$" + token];
  				if(typeof importIndex === "number") {
  					return "___CSS_LOADER_IMPORT___" + importIndex + "___";
  				}
  				return token;
  			});
  			return tokens.join("");
  		}
  
  		css.eachAtRule("import", function(rule) {
  			var values = Tokenizer.parseValues(rule.params);
  			var url = values.nodes[0].nodes[0];
  			if(url.type === "url") {
  				url = url.url;
  			} else if(url.type === "string") {
  				url = url.value;
  			} else throw rule.error("Unexpected format" + rule.params);
  			values.nodes[0].nodes.shift();
  			var mediaQuery = Tokenizer.stringifyValues(values);
  			if(loaderUtils.isUrlRequest(url, options.root) && options.mode === "global") {
  				url = loaderUtils.urlToRequest(url, options.root);
  			}
  			importItems.push({
  				url: url,
  				mediaQuery: mediaQuery
  			});
  			rule.removeSelf();
  		});
  
  		css.eachRule(function(rule) {
  			if(rule.selector === ":export") {
  				rule.eachDecl(function(decl) {
  					exports[decl.prop] = decl.value;
  				});
  				rule.removeSelf();
  			} else if(/^:import\(.+\)$/.test(rule.selector)) {
  				var match = /^:import\((.+)\)$/.exec(rule.selector);
  				var url = loaderUtils.parseString(match[1]);
  				rule.eachDecl(function(decl) {
  					imports["$" + decl.prop] = importItems.length;
  					importItems.push({
  						url: url,
  						export: decl.value
  					});
  				});
  				rule.removeSelf();
  			}
  		});
  
  		Object.keys(exports).forEach(function(exportName) {
  			exports[exportName] = replaceImportsInString(exports[exportName]);
  		});
  
  		css.eachDecl(function(decl) {
  			var values = Tokenizer.parseValues(decl.value);
  			values.nodes.forEach(function(value) {
  				value.nodes.forEach(function(item) {
  					switch(item.type) {
  					case "item":
  						var importIndex = imports["$" + item.name];
  						if(typeof importIndex === "number") {
  							item.name = "___CSS_LOADER_IMPORT___" + importIndex + "___";
  						}
  						break;
  					case "url":
  						if(!/^#/.test(item.url) && loaderUtils.isUrlRequest(item.url, options.root)) {
  							item.stringType = "";
  							delete item.innerSpacingBefore;
  							delete item.innerSpacingAfter;
  							var url = item.url;
  							item.url = "___CSS_LOADER_URL___" + urlItems.length + "___";
  							urlItems.push({
  								url: url
  							});
  						}
  						break;
  					}
  				});
  			});
  			decl.value = Tokenizer.stringifyValues(values);
  		});
  		css.eachAtRule(function(atrule) {
  			if(typeof atrule.params === "string") {
  				atrule.params = replaceImportsInString(atrule.params);
  			}
  		});
  
  		options.importItems = importItems;
  		options.urlItems = urlItems;
  		options.exports = exports;
  	};
  });
  
  module.exports = function processCss(inputSource, inputMap, options) {
  
  	var query = options.query;
  	var root = query.root;
  	var localIdentName = query.localIdentName || "[hash:base64]";
  	var localIdentRegExp = query.localIdentRegExp;
  	var forceMinimize = query.minimize;
  	var minimize = typeof forceMinimize !== "undefined" ? !!forceMinimize : options.minimize;
  
  
  	var parserOptions = {
  		root: root,
  		mode: options.mode
  	};
  
  	var pipeline = postcss([
  		localByDefault({
  			mode: options.mode,
  			rewriteUrl: function(global, url) {
  				if(!loaderUtils.isUrlRequest(url, root)) {
  					return url;
  				}
  				if(global) {
  					return loaderUtils.urlToRequest(url, root);
  				}
  				return url;
  			}
  		}),
  		extractImports({
  			createImportedName: function(importName) {
  				return "___" + importName;
  			}
  		}),
  		modulesScope({
  			generateScopedName: function(exportName) {
  				return getLocalIdent(options.loaderContext, localIdentName, exportName, {
  					regExp: localIdentRegExp
  				});
  			}
  		}),
  		parserPlugin(parserOptions)
  	]);
  
  	if(minimize) {
  		pipeline.use(cssnano({
  			zindex: false,
  			urls: false,
  			unused: false,
  			idents: false
  		}));
  	}
  
  	var result = pipeline.process(inputSource, {
  		from: options.from,
  		to: options.to,
  		map: {
  			prev: inputMap,
  			sourcesContent: true,
  			inline: false,
  			annotation: false
  		}
  	});
  
  
  	return {
  		source: result.css,
  		map: result.map && result.map.toJSON(),
  		exports: parserOptions.exports,
  		importItems: parserOptions.importItems,
  		importItemRegExpG: /___CSS_LOADER_IMPORT___([0-9]+)___/g,
  		importItemRegExp: /___CSS_LOADER_IMPORT___([0-9]+)___/,
  		urlItems: parserOptions.urlItems,
  		urlItemRegExpG: /___CSS_LOADER_URL___([0-9]+)___/g,
  		urlItemRegExp: /___CSS_LOADER_URL___([0-9]+)___/
  	};
  };
  