switch to vuepress

9 files changed, 675 insertions, 0 deletions

diff --git a/node_modules/css-loader/lib/compile-exports.js b/node_modules/css-loader/lib/compile-exports.js
new file mode 100644
index 00000000..8e14087d
--- /dev/null
+++ b/node_modules/css-loader/lib/compile-exports.js
@@ -0,0 +1,51 @@
+var camelCase = require("lodash.camelcase");
+
+function dashesCamelCase(str) {
+  return str.replace(/-+(\w)/g, function(match, firstLetter) {
+    return firstLetter.toUpperCase();
+  });
+}
+
+module.exports = function compileExports(result, importItemMatcher, camelCaseKeys) {
+  if (!Object.keys(result.exports).length) {
+    return "";
+  }
+
+  var exportJs = Object.keys(result.exports).reduce(function(res, key) {
+    var valueAsString = JSON.stringify(result.exports[key]);
+    valueAsString = valueAsString.replace(result.importItemRegExpG, importItemMatcher);
+    function addEntry(k) {
+      res.push("\t" + JSON.stringify(k) + ": " + valueAsString);
+    }
+
+    var targetKey;
+    switch(camelCaseKeys) {
+      case true:
+        addEntry(key);
+        targetKey = camelCase(key);
+        if (targetKey !== key) {
+          addEntry(targetKey);
+        }
+        break;
+      case 'dashes':
+        addEntry(key);
+        targetKey = dashesCamelCase(key);
+        if (targetKey !== key) {
+          addEntry(targetKey);
+        }
+        break;
+      case 'only':
+        addEntry(camelCase(key));
+        break;
+      case 'dashesOnly':
+        addEntry(dashesCamelCase(key));
+        break;
+      default:
+        addEntry(key);
+        break;
+    }
+    return res;
+  }, []).join(",\n");
+
+  return "{\n" + exportJs + "\n}";
+};
diff --git a/node_modules/css-loader/lib/createResolver.js b/node_modules/css-loader/lib/createResolver.js
new file mode 100644
index 00000000..c0d89701
--- /dev/null
+++ b/node_modules/css-loader/lib/createResolver.js
@@ -0,0 +1,36 @@
+module.exports = function createResolver(alias) {
+	if(typeof alias !== "object" || Array.isArray(alias)) {
+		return function(url) {
+			return url
+		};
+	}
+
+	alias = Object.keys(alias).map(function(key) {
+		var onlyModule = false;
+		var obj = alias[key];
+		if(/\$$/.test(key)) {
+			onlyModule = true;
+			key = key.substr(0, key.length - 1);
+		}
+		if(typeof obj === "string") {
+			obj = {
+				alias: obj
+			};
+		}
+		obj = Object.assign({
+			name: key,
+			onlyModule: onlyModule
+		}, obj);
+		return obj;
+	});
+
+	return function(url) {
+		alias.forEach(function(obj) {
+			var name = obj.name;
+			if(url === name || (!obj.onlyModule && url.startsWith(name + "/"))) {
+				url = obj.alias + url.substr(name.length);
+			}
+		});
+		return url;
+	}
+}
diff --git a/node_modules/css-loader/lib/css-base.js b/node_modules/css-loader/lib/css-base.js
new file mode 100644
index 00000000..59af87df
--- /dev/null
+++ b/node_modules/css-loader/lib/css-base.js
@@ -0,0 +1,76 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+// css base code, injected by the css-loader
+module.exports = function(useSourceMap) {
+	var list = [];
+
+	// return the list of modules as css string
+	list.toString = function toString() {
+		return this.map(function (item) {
+			var content = cssWithMappingToString(item, useSourceMap);
+			if(item[2]) {
+				return "@media " + item[2] + "{" + content + "}";
+			} else {
+				return content;
+			}
+		}).join("");
+	};
+
+	// import a list of modules into the list
+	list.i = function(modules, mediaQuery) {
+		if(typeof modules === "string")
+			modules = [[null, modules, ""]];
+		var alreadyImportedModules = {};
+		for(var i = 0; i < this.length; i++) {
+			var id = this[i][0];
+			if(typeof id === "number")
+				alreadyImportedModules[id] = true;
+		}
+		for(i = 0; i < modules.length; i++) {
+			var item = modules[i];
+			// skip already imported module
+			// this implementation is not 100% perfect for weird media query combinations
+			//  when a module is imported multiple times with different media queries.
+			//  I hope this will never occur (Hey this way we have smaller bundles)
+			if(typeof item[0] !== "number" || !alreadyImportedModules[item[0]]) {
+				if(mediaQuery && !item[2]) {
+					item[2] = mediaQuery;
+				} else if(mediaQuery) {
+					item[2] = "(" + item[2] + ") and (" + mediaQuery + ")";
+				}
+				list.push(item);
+			}
+		}
+	};
+	return list;
+};
+
+function cssWithMappingToString(item, useSourceMap) {
+	var content = item[1] || '';
+	var cssMapping = item[3];
+	if (!cssMapping) {
+		return content;
+	}
+
+	if (useSourceMap && typeof btoa === 'function') {
+		var sourceMapping = toComment(cssMapping);
+		var sourceURLs = cssMapping.sources.map(function (source) {
+			return '/*# sourceURL=' + cssMapping.sourceRoot + source + ' */'
+		});
+
+		return [content].concat(sourceURLs).concat([sourceMapping]).join('\n');
+	}
+
+	return [content].join('\n');
+}
+
+// Adapted from convert-source-map (MIT)
+function toComment(sourceMap) {
+	// eslint-disable-next-line no-undef
+	var base64 = btoa(unescape(encodeURIComponent(JSON.stringify(sourceMap))));
+	var data = 'sourceMappingURL=data:application/json;charset=utf-8;base64,' + base64;
+
+	return '/*# ' + data + ' */';
+}
diff --git a/node_modules/css-loader/lib/getImportPrefix.js b/node_modules/css-loader/lib/getImportPrefix.js
new file mode 100644
index 00000000..5d3be772
--- /dev/null
+++ b/node_modules/css-loader/lib/getImportPrefix.js
@@ -0,0 +1,14 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+module.exports = function getImportPrefix(loaderContext, query) {
+	if(query.importLoaders === false)
+		return "";
+	var importLoaders = parseInt(query.importLoaders, 10) || 0;
+	var loadersRequest = loaderContext.loaders.slice(
+		loaderContext.loaderIndex,
+		loaderContext.loaderIndex + 1 + importLoaders
+	).map(function(x) { return x.request; }).join("!");
+	return "-!" + loadersRequest + "!";
+};
diff --git a/node_modules/css-loader/lib/getLocalIdent.js b/node_modules/css-loader/lib/getLocalIdent.js
new file mode 100644
index 00000000..79c7ab57
--- /dev/null
+++ b/node_modules/css-loader/lib/getLocalIdent.js
@@ -0,0 +1,23 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+var loaderUtils = require("loader-utils");
+var path = require("path");
+
+module.exports = function getLocalIdent(loaderContext, localIdentName, localName, options) {
+	if(!options.context) {
+		if (loaderContext.rootContext) {
+			options.context = loaderContext.rootContext;
+		} else if (loaderContext.options && typeof loaderContext.options.context === "string") {
+			options.context = loaderContext.options.context;
+		} else {
+			options.context = loaderContext.context;
+		}
+	}
+	var request = path.relative(options.context, loaderContext.resourcePath);
+	options.content = options.hashPrefix + request + "+" + localName;
+	localIdentName = localIdentName.replace(/\[local\]/gi, localName);
+	var hash = loaderUtils.interpolateName(loaderContext, localIdentName, options);
+	return hash.replace(new RegExp("[^a-zA-Z0-9\\-_\u00A0-\uFFFF]", "g"), "-").replace(/^((-?[0-9])|--)/, "_$1");
+};
diff --git a/node_modules/css-loader/lib/loader.js b/node_modules/css-loader/lib/loader.js
new file mode 100644
index 00000000..3d5033f6
--- /dev/null
+++ b/node_modules/css-loader/lib/loader.js
@@ -0,0 +1,146 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+var loaderUtils = require("loader-utils");
+var processCss = require("./processCss");
+var getImportPrefix = require("./getImportPrefix");
+var compileExports = require("./compile-exports");
+var createResolver = require("./createResolver");
+
+
+module.exports = function(content, map) {
+	if(this.cacheable) this.cacheable();
+	var callback = this.async();
+	var query = loaderUtils.getOptions(this) || {};
+	var root = query.root;
+	var moduleMode = query.modules || query.module;
+	var camelCaseKeys = query.camelCase || query.camelcase;
+	var sourceMap = query.sourceMap || false;
+	var resolve = createResolver(query.alias);
+
+	if(sourceMap) {
+		if (map) {
+			if (typeof map === "string") {
+				map = JSON.stringify(map);
+			}
+
+			if (map.sources) {
+				map.sources = map.sources.map(function (source) {
+					return source.replace(/\\/g, '/');
+				});
+				map.sourceRoot = '';
+			}
+		}
+	} else {
+		// Some loaders (example `"postcss-loader": "1.x.x"`) always generates source map, we should remove it
+		map = null;
+	}
+
+	processCss(content, map, {
+		mode: moduleMode ? "local" : "global",
+		from: loaderUtils.getRemainingRequest(this).split("!").pop(),
+		to: loaderUtils.getCurrentRequest(this).split("!").pop(),
+		query: query,
+		resolve: resolve,
+		minimize: this.minimize,
+		loaderContext: this,
+		sourceMap: sourceMap
+	}, function(err, result) {
+		if(err) return callback(err);
+
+		var cssAsString = JSON.stringify(result.source);
+
+		// for importing CSS
+		var importUrlPrefix = getImportPrefix(this, query);
+
+		var alreadyImported = {};
+		var importJs = result.importItems.filter(function(imp) {
+			if(!imp.mediaQuery) {
+				if(alreadyImported[imp.url])
+					return false;
+				alreadyImported[imp.url] = true;
+			}
+			return true;
+		}).map(function(imp) {
+			if(!loaderUtils.isUrlRequest(imp.url, root)) {
+				return "exports.push([module.id, " +
+					JSON.stringify("@import url(" + imp.url + ");") + ", " +
+					JSON.stringify(imp.mediaQuery) + "]);";
+			} else {
+				var importUrl = importUrlPrefix + imp.url;
+				return "exports.i(require(" + loaderUtils.stringifyRequest(this, importUrl) + "), " + JSON.stringify(imp.mediaQuery) + ");";
+			}
+		}, this).join("\n");
+
+		function importItemMatcher(item) {
+			var match = result.importItemRegExp.exec(item);
+			var idx = +match[1];
+			var importItem = result.importItems[idx];
+			var importUrl = importUrlPrefix + importItem.url;
+			return "\" + require(" + loaderUtils.stringifyRequest(this, importUrl) + ").locals" +
+				"[" + JSON.stringify(importItem.export) + "] + \"";
+		}
+
+		cssAsString = cssAsString.replace(result.importItemRegExpG, importItemMatcher.bind(this));
+
+		// helper for ensuring valid CSS strings from requires
+		var urlEscapeHelper = "";
+
+		if(query.url !== false && result.urlItems.length > 0) {
+			urlEscapeHelper = "var escape = require(" + loaderUtils.stringifyRequest(this, require.resolve("./url/escape.js")) + ");\n";
+
+			cssAsString = cssAsString.replace(result.urlItemRegExpG, function(item) {
+				var match = result.urlItemRegExp.exec(item);
+				var idx = +match[1];
+				var urlItem = result.urlItems[idx];
+				var url = resolve(urlItem.url);
+				idx = url.indexOf("?#");
+				if(idx < 0) idx = url.indexOf("#");
+				var urlRequest;
+				if(idx > 0) { // idx === 0 is catched by isUrlRequest
+					// in cases like url('webfont.eot?#iefix')
+					urlRequest = url.substr(0, idx);
+					return "\" + escape(require(" + loaderUtils.stringifyRequest(this, urlRequest) + ")) + \"" +
+							url.substr(idx);
+				}
+				urlRequest = url;
+				return "\" + escape(require(" + loaderUtils.stringifyRequest(this, urlRequest) + ")) + \"";
+			}.bind(this));
+		}
+		
+		var exportJs = compileExports(result, importItemMatcher.bind(this), camelCaseKeys);
+		if (exportJs) {
+			exportJs = "exports.locals = " + exportJs + ";";
+		}
+
+		var moduleJs;
+		if(sourceMap && result.map) {
+			// add a SourceMap
+			map = result.map;
+			if(map.sources) {
+				map.sources = map.sources.map(function(source) {
+					return source.split("!").pop().replace(/\\/g, '/');
+				}, this);
+				map.sourceRoot = "";
+			}
+			map.file = map.file.split("!").pop().replace(/\\/g, '/');
+			map = JSON.stringify(map);
+			moduleJs = "exports.push([module.id, " + cssAsString + ", \"\", " + map + "]);";
+		} else {
+			moduleJs = "exports.push([module.id, " + cssAsString + ", \"\"]);";
+		}
+
+		// embed runtime
+		callback(null, urlEscapeHelper +
+			"exports = module.exports = require(" +
+			loaderUtils.stringifyRequest(this, require.resolve("./css-base.js")) +
+			")(" + sourceMap + ");\n" +
+			"// imports\n" +
+			importJs + "\n\n" +
+			"// module\n" +
+			moduleJs + "\n\n" +
+			"// exports\n" +
+			exportJs);
+	}.bind(this));
+};
diff --git a/node_modules/css-loader/lib/localsLoader.js b/node_modules/css-loader/lib/localsLoader.js
new file mode 100644
index 00000000..73d5757a
--- /dev/null
+++ b/node_modules/css-loader/lib/localsLoader.js
@@ -0,0 +1,49 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+var loaderUtils = require("loader-utils");
+var processCss = require("./processCss");
+var getImportPrefix = require("./getImportPrefix");
+var compileExports = require("./compile-exports");
+var createResolver = require("./createResolver");
+
+
+module.exports = function(content) {
+	if(this.cacheable) this.cacheable();
+	var callback = this.async();
+	var query = loaderUtils.getOptions(this) || {};
+	var moduleMode = query.modules || query.module;
+	var camelCaseKeys = query.camelCase || query.camelcase;
+	var resolve = createResolver(query.alias);
+
+	processCss(content, null, {
+		mode: moduleMode ? "local" : "global",
+		query: query,
+		minimize: this.minimize,
+		loaderContext: this,
+		resolve: resolve
+	}, function(err, result) {
+		if(err) return callback(err);
+
+		// for importing CSS
+		var importUrlPrefix = getImportPrefix(this, query);
+
+		function importItemMatcher(item) {
+			var match = result.importItemRegExp.exec(item);
+			var idx = +match[1];
+			var importItem = result.importItems[idx];
+			var importUrl = importUrlPrefix + importItem.url;
+			return "\" + require(" + loaderUtils.stringifyRequest(this, importUrl) + ")" +
+				"[" + JSON.stringify(importItem.export) + "] + \"";
+		}
+
+		var exportJs = compileExports(result, importItemMatcher.bind(this), camelCaseKeys);
+		if (exportJs) {
+			exportJs = "module.exports = " + exportJs + ";";
+		}
+
+
+		callback(null, exportJs);
+	}.bind(this));
+};
diff --git a/node_modules/css-loader/lib/processCss.js b/node_modules/css-loader/lib/processCss.js
new file mode 100644
index 00000000..ac65af16
--- /dev/null
+++ b/node_modules/css-loader/lib/processCss.js
@@ -0,0 +1,264 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+var formatCodeFrame = require("babel-code-frame");
+var Tokenizer = require("css-selector-tokenizer");
+var postcss = require("postcss");
+var loaderUtils = require("loader-utils");
+var assign = require("object-assign");
+var getLocalIdent = require("./getLocalIdent");
+
+var icssUtils = require('icss-utils');
+var localByDefault = require("postcss-modules-local-by-default");
+var extractImports = require("postcss-modules-extract-imports");
+var modulesScope = require("postcss-modules-scope");
+var modulesValues = require("postcss-modules-values");
+var valueParser = require('postcss-value-parser');
+
+var parserPlugin = postcss.plugin("css-loader-parser", function(options) {
+	return function(css) {
+		var imports = {};
+		var exports = {};
+		var importItems = [];
+		var urlItems = [];
+
+		function replaceImportsInString(str) {
+			if(options.import) {
+				var tokens = valueParser(str);
+				tokens.walk(function (node) {
+					if (node.type !== 'word') {
+						return;
+					}
+					var token = node.value;
+					var importIndex = imports["$" + token];
+					if(typeof importIndex === "number") {
+						node.value = "___CSS_LOADER_IMPORT___" + importIndex + "___";
+					}
+				})
+				return tokens.toString();
+			}
+			return str;
+		}
+
+		if(options.import) {
+			css.walkAtRules(/^import$/i, function(rule) {
+				var values = Tokenizer.parseValues(rule.params);
+				var url = values.nodes[0].nodes[0];
+				if(url && url.type === "url") {
+					url = url.url;
+				} else if(url && url.type === "string") {
+					url = url.value;
+				} else throw rule.error("Unexpected format " + rule.params);
+				if (!url.replace(/\s/g, '').length) {
+					return;
+				}
+				values.nodes[0].nodes.shift();
+				var mediaQuery = Tokenizer.stringifyValues(values);
+
+				if(loaderUtils.isUrlRequest(url, options.root)) {
+					url = loaderUtils.urlToRequest(url, options.root);
+				}
+
+				importItems.push({
+					url: url,
+					mediaQuery: mediaQuery
+				});
+				rule.remove();
+			});
+		}
+
+		var icss = icssUtils.extractICSS(css);
+		exports = icss.icssExports;
+		Object.keys(icss.icssImports).forEach(function(key) {
+			var url = loaderUtils.parseString(key);
+			Object.keys(icss.icssImports[key]).forEach(function(prop) {
+				imports["$" + prop] = importItems.length;
+				importItems.push({
+					url: url,
+					export: icss.icssImports[key][prop]
+				});
+			})
+		});
+
+		Object.keys(exports).forEach(function(exportName) {
+			exports[exportName] = replaceImportsInString(exports[exportName]);
+		});
+
+		function isAlias(url) {
+			// Handle alias starting by / and root disabled
+			return url !== options.resolve(url)
+		}
+
+		function processNode(item) {
+			switch (item.type) {
+				case "value":
+					item.nodes.forEach(processNode);
+					break;
+				case "nested-item":
+					item.nodes.forEach(processNode);
+					break;
+				case "item":
+					var importIndex = imports["$" + item.name];
+					if (typeof importIndex === "number") {
+						item.name = "___CSS_LOADER_IMPORT___" + importIndex + "___";
+					}
+					break;
+				case "url":
+					if (options.url && item.url.replace(/\s/g, '').length && !/^#/.test(item.url) && (isAlias(item.url) || loaderUtils.isUrlRequest(item.url, options.root))) {
+						// Strip quotes, they will be re-added if the module needs them
+						item.stringType = "";
+						delete item.innerSpacingBefore;
+						delete item.innerSpacingAfter;
+						var url = item.url;
+						item.url = "___CSS_LOADER_URL___" + urlItems.length + "___";
+						urlItems.push({
+							url: url
+						});
+					}
+					break;
+			}
+		}
+
+		css.walkDecls(function(decl) {
+			var values = Tokenizer.parseValues(decl.value);
+			values.nodes.forEach(function(value) {
+				value.nodes.forEach(processNode);
+			});
+			decl.value = Tokenizer.stringifyValues(values);
+		});
+		css.walkAtRules(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, callback) {
+	var query = options.query;
+	var root = query.root && query.root.length > 0 ? query.root.replace(/\/$/, "") : query.root;
+	var context = query.context;
+	var localIdentName = query.localIdentName || "[hash:base64]";
+	var localIdentRegExp = query.localIdentRegExp;
+	var forceMinimize = query.minimize;
+	var minimize = typeof forceMinimize !== "undefined" ? !!forceMinimize : options.minimize;
+
+	var customGetLocalIdent = query.getLocalIdent || getLocalIdent;
+
+	var parserOptions = {
+		root: root,
+		mode: options.mode,
+		url: query.url !== false,
+		import: query.import !== false,
+		resolve: options.resolve
+	};
+
+	var pipeline = postcss([
+		modulesValues,
+		localByDefault({
+			mode: options.mode,
+			rewriteUrl: function(global, url) {
+				if(parserOptions.url){
+                    url = url.trim();
+
+					if(!url.replace(/\s/g, '').length || !loaderUtils.isUrlRequest(url, root)) {
+						return url;
+					}
+					if(global) {
+						return loaderUtils.urlToRequest(url, root);
+					}
+				}
+				return url;
+			}
+		}),
+		extractImports(),
+		modulesScope({
+			generateScopedName: function generateScopedName (exportName) {
+				return customGetLocalIdent(options.loaderContext, localIdentName, exportName, {
+					regExp: localIdentRegExp,
+					hashPrefix: query.hashPrefix || "",
+					context: context
+				});
+			}
+		}),
+		parserPlugin(parserOptions)
+	]);
+
+	if(minimize) {
+		var cssnano = require("cssnano");
+		var minimizeOptions = assign({}, query.minimize);
+		["zindex", "normalizeUrl", "discardUnused", "mergeIdents", "reduceIdents", "autoprefixer"].forEach(function(name) {
+			if(typeof minimizeOptions[name] === "undefined")
+				minimizeOptions[name] = false;
+		});
+		pipeline.use(cssnano(minimizeOptions));
+	}
+
+	pipeline.process(inputSource, {
+		// we need a prefix to avoid path rewriting of PostCSS
+		from: "/css-loader!" + options.from,
+		to: options.to,
+		map: options.sourceMap ? {
+			prev: inputMap,
+			sourcesContent: true,
+			inline: false,
+			annotation: false
+		} : null
+	}).then(function(result) {
+		callback(null, {
+			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]+)___/
+		});
+	}).catch(function(err) {
+		if (err.name === 'CssSyntaxError') {
+			var wrappedError = new CSSLoaderError(
+				'Syntax Error',
+				err.reason,
+				err.line != null && err.column != null
+					? {line: err.line, column: err.column}
+					: null,
+				err.input.source
+			);
+			callback(wrappedError);
+		} else {
+			callback(err);
+		}
+	});
+};
+
+function formatMessage(message, loc, source) {
+	var formatted = message;
+	if (loc) {
+		formatted = formatted
+			+ ' (' + loc.line + ':' + loc.column + ')';
+	}
+	if (loc && source) {
+		formatted = formatted
+			+ '\n\n' + formatCodeFrame(source, loc.line, loc.column) + '\n';
+	}
+	return formatted;
+}
+
+function CSSLoaderError(name, message, loc, source, error) {
+	Error.call(this);
+	Error.captureStackTrace(this, CSSLoaderError);
+	this.name = name;
+	this.error = error;
+	this.message = formatMessage(message, loc, source);
+	this.hideStack = true;
+}
+
+CSSLoaderError.prototype = Object.create(Error.prototype);
+CSSLoaderError.prototype.constructor = CSSLoaderError;
diff --git a/node_modules/css-loader/lib/url/escape.js b/node_modules/css-loader/lib/url/escape.js
new file mode 100644
index 00000000..25074a6e
--- /dev/null
+++ b/node_modules/css-loader/lib/url/escape.js
@@ -0,0 +1,16 @@
+module.exports = function escape(url) {
+    if (typeof url !== 'string') {
+        return url
+    }
+    // If url is already wrapped in quotes, remove them
+    if (/^['"].*['"]$/.test(url)) {
+        url = url.slice(1, -1);
+    }
+    // Should url be wrapped?
+    // See https://drafts.csswg.org/css-values-3/#urls
+    if (/["'() \t\n]/.test(url)) {
+        return '"' + url.replace(/"/g, '\\"').replace(/\n/g, '\\n') + '"'
+    }
+
+    return url
+}