var JSON5 = require("json5");
|
var path = require("path");
|
var util = require("util");
|
var os = require("os");
|
var assign = require("object-assign");
|
var emojiRegex = /[\uD800-\uDFFF]./;
|
var emojiList = require("emojis-list").filter(function(emoji) {
|
return emojiRegex.test(emoji)
|
});
|
var matchAbsolutePath = /^\/|^[A-Z]:[/\\]|^\\\\/i; // node 0.10 does not support path.isAbsolute()
|
var matchAbsoluteWin32Path = /^[A-Z]:[/\\]|^\\\\/i;
|
var matchRelativePath = /^\.\.?[/\\]/;
|
|
var baseEncodeTables = {
|
26: "abcdefghijklmnopqrstuvwxyz",
|
32: "123456789abcdefghjkmnpqrstuvwxyz", // no 0lio
|
36: "0123456789abcdefghijklmnopqrstuvwxyz",
|
49: "abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ", // no lIO
|
52: "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ",
|
58: "123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ", // no 0lIO
|
62: "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ",
|
64: "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-_"
|
};
|
var emojiCache = {};
|
var parseQueryDeprecationWarning = util.deprecate(function() {},
|
"loaderUtils.parseQuery() received a non-string value which can be problematic, " +
|
"see https://github.com/webpack/loader-utils/issues/56" + os.EOL +
|
"parseQuery() will be replaced with getOptions() in the next major version of loader-utils."
|
);
|
|
function encodeStringToEmoji(content, length) {
|
if (emojiCache[content]) return emojiCache[content];
|
length = length || 1;
|
var emojis = [];
|
do {
|
var index = Math.floor(Math.random() * emojiList.length);
|
emojis.push(emojiList[index]);
|
emojiList.splice(index, 1);
|
} while (--length > 0);
|
var emojiEncoding = emojis.join('');
|
emojiCache[content] = emojiEncoding;
|
return emojiEncoding;
|
}
|
|
function encodeBufferToBase(buffer, base) {
|
var encodeTable = baseEncodeTables[base];
|
if (!encodeTable) throw new Error("Unknown encoding base" + base);
|
|
var readLength = buffer.length;
|
|
var Big = require('big.js');
|
Big.RM = Big.DP = 0;
|
var b = new Big(0);
|
for (var i = readLength - 1; i >= 0; i--) {
|
b = b.times(256).plus(buffer[i]);
|
}
|
|
var output = "";
|
while (b.gt(0)) {
|
output = encodeTable[b.mod(base)] + output;
|
b = b.div(base);
|
}
|
|
Big.DP = 20;
|
Big.RM = 1;
|
|
return output;
|
}
|
|
exports.parseQuery = function parseQuery(query) {
|
var specialValues = {
|
'null': null,
|
'true': true,
|
'false': false
|
};
|
if(!query) return {};
|
if(typeof query !== "string") {
|
parseQueryDeprecationWarning();
|
return query;
|
}
|
if(query.substr(0, 1) !== "?")
|
throw new Error("a valid query string passed to parseQuery should begin with '?'");
|
query = query.substr(1);
|
var queryLength = query.length;
|
if(query.substr(0, 1) === "{" && query.substr(-1) === "}") {
|
return JSON5.parse(query);
|
}
|
var queryArgs = query.split(/[,\&]/g);
|
var result = {};
|
queryArgs.forEach(function(arg) {
|
var idx = arg.indexOf("=");
|
if(idx >= 0) {
|
var name = arg.substr(0, idx);
|
var value = decodeURIComponent(arg.substr(idx+1));
|
if (specialValues.hasOwnProperty(value)) {
|
value = specialValues[value];
|
}
|
if(name.substr(-2) === "[]") {
|
name = decodeURIComponent(name.substr(0, name.length-2));
|
if(!Array.isArray(result[name]))
|
result[name] = [];
|
result[name].push(value);
|
} else {
|
name = decodeURIComponent(name);
|
result[name] = value;
|
}
|
} else {
|
if(arg.substr(0, 1) === "-") {
|
result[decodeURIComponent(arg.substr(1))] = false;
|
} else if(arg.substr(0, 1) === "+") {
|
result[decodeURIComponent(arg.substr(1))] = true;
|
} else {
|
result[decodeURIComponent(arg)] = true;
|
}
|
}
|
});
|
return result;
|
};
|
|
exports.getLoaderConfig = function(loaderContext, defaultConfigKey) {
|
var query = exports.parseQuery(loaderContext.query);
|
var configKey = query.config || defaultConfigKey;
|
if (configKey) {
|
var config = loaderContext.options[configKey] || {};
|
delete query.config;
|
return assign({}, config, query);
|
}
|
|
return query;
|
};
|
|
exports.stringifyRequest = function(loaderContext, request) {
|
var splitted = request.split("!");
|
var context = loaderContext.context || (loaderContext.options && loaderContext.options.context);
|
return JSON.stringify(splitted.map(function(part) {
|
// First, separate singlePath from query, because the query might contain paths again
|
var splittedPart = part.match(/^(.*?)(\?.*)/);
|
var singlePath = splittedPart ? splittedPart[1] : part;
|
var query = splittedPart ? splittedPart[2] : "";
|
if(matchAbsolutePath.test(singlePath) && context) {
|
singlePath = path.relative(context, singlePath);
|
if(matchAbsolutePath.test(singlePath)) {
|
// If singlePath still matches an absolute path, singlePath was on a different drive than context.
|
// In this case, we leave the path platform-specific without replacing any separators.
|
// @see https://github.com/webpack/loader-utils/pull/14
|
return singlePath + query;
|
}
|
if(matchRelativePath.test(singlePath) === false) {
|
// Ensure that the relative path starts at least with ./ otherwise it would be a request into the modules directory (like node_modules).
|
singlePath = "./" + singlePath;
|
}
|
}
|
return singlePath.replace(/\\/g, "/") + query;
|
}).join("!"));
|
};
|
|
function dotRequest(obj) {
|
return obj.request;
|
}
|
|
exports.getRemainingRequest = function(loaderContext) {
|
if(loaderContext.remainingRequest)
|
return loaderContext.remainingRequest;
|
var request = loaderContext.loaders.slice(loaderContext.loaderIndex+1).map(dotRequest).concat([loaderContext.resource]);
|
return request.join("!");
|
};
|
|
exports.getCurrentRequest = function(loaderContext) {
|
if(loaderContext.currentRequest)
|
return loaderContext.currentRequest;
|
var request = loaderContext.loaders.slice(loaderContext.loaderIndex).map(dotRequest).concat([loaderContext.resource]);
|
return request.join("!");
|
};
|
|
exports.isUrlRequest = function(url, root) {
|
// An URL is not an request if
|
// 1. it's a Data Url
|
// 2. it's an absolute url or and protocol-relative
|
// 3. it's some kind of url for a template
|
if(/^data:|^chrome-extension:|^(https?:)?\/\/|^[\{\}\[\]#*;,'§\$%&\(=?`´\^°<>]/.test(url)) return false;
|
// 4. It's also not an request if root isn't set and it's a root-relative url
|
if((root === undefined || root === false) && /^\//.test(url)) return false;
|
return true;
|
};
|
|
exports.urlToRequest = function(url, root) {
|
var moduleRequestRegex = /^[^?]*~/;
|
var request;
|
|
if(matchAbsoluteWin32Path.test(url)) {
|
// absolute windows path, keep it
|
request = url;
|
} else if(root !== undefined && root !== false && /^\//.test(url)) {
|
// if root is set and the url is root-relative
|
switch(typeof root) {
|
// 1. root is a string: root is prefixed to the url
|
case "string":
|
// special case: `~` roots convert to module request
|
if (moduleRequestRegex.test(root)) {
|
request = root.replace(/([^~\/])$/, "$1/") + url.slice(1);
|
} else {
|
request = root + url;
|
}
|
break;
|
// 2. root is `true`: absolute paths are allowed
|
// *nix only, windows-style absolute paths are always allowed as they doesn't start with a `/`
|
case "boolean":
|
request = url;
|
break;
|
default:
|
throw new Error("Unexpected parameters to loader-utils 'urlToRequest': url = " + url + ", root = " + root + ".");
|
}
|
} else if(/^\.\.?\//.test(url)) {
|
// A relative url stays
|
request = url;
|
} else {
|
// every other url is threaded like a relative url
|
request = "./" + url;
|
}
|
|
// A `~` makes the url an module
|
if (moduleRequestRegex.test(request)) {
|
request = request.replace(moduleRequestRegex, "");
|
}
|
|
return request;
|
};
|
|
exports.parseString = function parseString(str) {
|
try {
|
if(str[0] === '"') return JSON.parse(str);
|
if(str[0] === "'" && str.substr(str.length - 1) === "'") {
|
return parseString(str.replace(/\\.|"/g, function(x) {
|
if(x === '"') return '\\"';
|
return x;
|
}).replace(/^'|'$/g, '"'));
|
}
|
return JSON.parse('"' + str + '"');
|
} catch(e) {
|
return str;
|
}
|
};
|
|
exports.getHashDigest = function getHashDigest(buffer, hashType, digestType, maxLength) {
|
hashType = hashType || "md5";
|
maxLength = maxLength || 9999;
|
var hash = require("crypto").createHash(hashType);
|
hash.update(buffer);
|
if (digestType === "base26" || digestType === "base32" || digestType === "base36" ||
|
digestType === "base49" || digestType === "base52" || digestType === "base58" ||
|
digestType === "base62" || digestType === "base64") {
|
return encodeBufferToBase(hash.digest(), digestType.substr(4)).substr(0, maxLength);
|
} else {
|
return hash.digest(digestType || "hex").substr(0, maxLength);
|
}
|
};
|
|
exports.interpolateName = function interpolateName(loaderContext, name, options) {
|
var filename;
|
if (typeof name === "function") {
|
filename = name(loaderContext.resourcePath);
|
} else {
|
filename = name || "[hash].[ext]";
|
}
|
var context = options.context;
|
var content = options.content;
|
var regExp = options.regExp;
|
var ext = "bin";
|
var basename = "file";
|
var directory = "";
|
var folder = "";
|
if(loaderContext.resourcePath) {
|
var resourcePath = loaderContext.resourcePath;
|
var idx = resourcePath.lastIndexOf(".");
|
var i = resourcePath.lastIndexOf("\\");
|
var j = resourcePath.lastIndexOf("/");
|
var p = i < 0 ? j : j < 0 ? i : i < j ? i : j;
|
if(idx >= 0) {
|
ext = resourcePath.substr(idx+1);
|
resourcePath = resourcePath.substr(0, idx);
|
}
|
if(p >= 0) {
|
basename = resourcePath.substr(p+1);
|
resourcePath = resourcePath.substr(0, p+1);
|
}
|
if (typeof context !== 'undefined') {
|
directory = path.relative(context, resourcePath + "_").replace(/\\/g, "/").replace(/\.\.(\/)?/g, "_$1");
|
directory = directory.substr(0, directory.length-1);
|
}
|
else {
|
directory = resourcePath.replace(/\\/g, "/").replace(/\.\.(\/)?/g, "_$1");
|
}
|
if (directory.length === 1) {
|
directory = "";
|
} else if (directory.length > 1) {
|
folder = path.basename(directory);
|
}
|
}
|
var url = filename;
|
if(content) {
|
// Match hash template
|
url = url.replace(/\[(?:(\w+):)?hash(?::([a-z]+\d*))?(?::(\d+))?\]/ig, function() {
|
return exports.getHashDigest(content, arguments[1], arguments[2], parseInt(arguments[3], 10));
|
}).replace(/\[emoji(?::(\d+))?\]/ig, function() {
|
return encodeStringToEmoji(content, arguments[1]);
|
});
|
}
|
url = url.replace(/\[ext\]/ig, function() {
|
return ext;
|
}).replace(/\[name\]/ig, function() {
|
return basename;
|
}).replace(/\[path\]/ig, function() {
|
return directory;
|
}).replace(/\[folder\]/ig, function() {
|
return folder;
|
});
|
if(regExp && loaderContext.resourcePath) {
|
var re = new RegExp(regExp);
|
var match = loaderContext.resourcePath.match(re);
|
if(match) {
|
for (var i = 0; i < match.length; i++) {
|
var re = new RegExp("\\[" + i + "\\]", "ig");
|
url = url.replace(re, match[i]);
|
}
|
}
|
}
|
if(typeof loaderContext.options === "object" && typeof loaderContext.options.customInterpolateName === "function") {
|
url = loaderContext.options.customInterpolateName.call(loaderContext, url, name, options);
|
}
|
return url;
|
};
|
