Add rollup-plugin-minify-html-template-literals to node_modules
R=jacktfranklin@chromium.org
Bug: 1213034
Change-Id: I5da8225f60b53870a1c67d6b5d02a464c08f4eb2
Reviewed-on: https://chromium-review.googlesource.com/c/devtools/devtools-frontend/+/2917088
Commit-Queue: Tim van der Lippe <tvanderlippe@chromium.org>
Reviewed-by: Jack Franklin <jacktfranklin@chromium.org>
diff --git a/node_modules/clean-css/lib/reader/apply-source-maps.js b/node_modules/clean-css/lib/reader/apply-source-maps.js
new file mode 100644
index 0000000..7c5a928
--- /dev/null
+++ b/node_modules/clean-css/lib/reader/apply-source-maps.js
@@ -0,0 +1,245 @@
+var fs = require('fs');
+var path = require('path');
+
+var isAllowedResource = require('./is-allowed-resource');
+var matchDataUri = require('./match-data-uri');
+var rebaseLocalMap = require('./rebase-local-map');
+var rebaseRemoteMap = require('./rebase-remote-map');
+
+var Token = require('../tokenizer/token');
+var hasProtocol = require('../utils/has-protocol');
+var isDataUriResource = require('../utils/is-data-uri-resource');
+var isRemoteResource = require('../utils/is-remote-resource');
+
+var MAP_MARKER_PATTERN = /^\/\*# sourceMappingURL=(\S+) \*\/$/;
+
+function applySourceMaps(tokens, context, callback) {
+ var applyContext = {
+ callback: callback,
+ fetch: context.options.fetch,
+ index: 0,
+ inline: context.options.inline,
+ inlineRequest: context.options.inlineRequest,
+ inlineTimeout: context.options.inlineTimeout,
+ inputSourceMapTracker: context.inputSourceMapTracker,
+ localOnly: context.localOnly,
+ processedTokens: [],
+ rebaseTo: context.options.rebaseTo,
+ sourceTokens: tokens,
+ warnings: context.warnings
+ };
+
+ return context.options.sourceMap && tokens.length > 0 ?
+ doApplySourceMaps(applyContext) :
+ callback(tokens);
+}
+
+function doApplySourceMaps(applyContext) {
+ var singleSourceTokens = [];
+ var lastSource = findTokenSource(applyContext.sourceTokens[0]);
+ var source;
+ var token;
+ var l;
+
+ for (l = applyContext.sourceTokens.length; applyContext.index < l; applyContext.index++) {
+ token = applyContext.sourceTokens[applyContext.index];
+ source = findTokenSource(token);
+
+ if (source != lastSource) {
+ singleSourceTokens = [];
+ lastSource = source;
+ }
+
+ singleSourceTokens.push(token);
+ applyContext.processedTokens.push(token);
+
+ if (token[0] == Token.COMMENT && MAP_MARKER_PATTERN.test(token[1])) {
+ return fetchAndApplySourceMap(token[1], source, singleSourceTokens, applyContext);
+ }
+ }
+
+ return applyContext.callback(applyContext.processedTokens);
+}
+
+function findTokenSource(token) {
+ var scope;
+ var metadata;
+
+ if (token[0] == Token.AT_RULE || token[0] == Token.COMMENT) {
+ metadata = token[2][0];
+ } else {
+ scope = token[1][0];
+ metadata = scope[2][0];
+ }
+
+ return metadata[2];
+}
+
+function fetchAndApplySourceMap(sourceMapComment, source, singleSourceTokens, applyContext) {
+ return extractInputSourceMapFrom(sourceMapComment, applyContext, function (inputSourceMap) {
+ if (inputSourceMap) {
+ applyContext.inputSourceMapTracker.track(source, inputSourceMap);
+ applySourceMapRecursively(singleSourceTokens, applyContext.inputSourceMapTracker);
+ }
+
+ applyContext.index++;
+ return doApplySourceMaps(applyContext);
+ });
+}
+
+function extractInputSourceMapFrom(sourceMapComment, applyContext, whenSourceMapReady) {
+ var uri = MAP_MARKER_PATTERN.exec(sourceMapComment)[1];
+ var absoluteUri;
+ var sourceMap;
+ var rebasedMap;
+
+ if (isDataUriResource(uri)) {
+ sourceMap = extractInputSourceMapFromDataUri(uri);
+ return whenSourceMapReady(sourceMap);
+ } else if (isRemoteResource(uri)) {
+ return loadInputSourceMapFromRemoteUri(uri, applyContext, function (sourceMap) {
+ var parsedMap;
+
+ if (sourceMap) {
+ parsedMap = JSON.parse(sourceMap);
+ rebasedMap = rebaseRemoteMap(parsedMap, uri);
+ whenSourceMapReady(rebasedMap);
+ } else {
+ whenSourceMapReady(null);
+ }
+ });
+ } else {
+ // at this point `uri` is already rebased, see lib/reader/rebase.js#rebaseSourceMapComment
+ // it is rebased to be consistent with rebasing other URIs
+ // however here we need to resolve it back to read it from disk
+ absoluteUri = path.resolve(applyContext.rebaseTo, uri);
+ sourceMap = loadInputSourceMapFromLocalUri(absoluteUri, applyContext);
+
+ if (sourceMap) {
+ rebasedMap = rebaseLocalMap(sourceMap, absoluteUri, applyContext.rebaseTo);
+ return whenSourceMapReady(rebasedMap);
+ } else {
+ return whenSourceMapReady(null);
+ }
+ }
+}
+
+function extractInputSourceMapFromDataUri(uri) {
+ var dataUriMatch = matchDataUri(uri);
+ var charset = dataUriMatch[2] ? dataUriMatch[2].split(/[=;]/)[2] : 'us-ascii';
+ var encoding = dataUriMatch[3] ? dataUriMatch[3].split(';')[1] : 'utf8';
+ var data = encoding == 'utf8' ? global.unescape(dataUriMatch[4]) : dataUriMatch[4];
+
+ var buffer = new Buffer(data, encoding);
+ buffer.charset = charset;
+
+ return JSON.parse(buffer.toString());
+}
+
+function loadInputSourceMapFromRemoteUri(uri, applyContext, whenLoaded) {
+ var isAllowed = isAllowedResource(uri, true, applyContext.inline);
+ var isRuntimeResource = !hasProtocol(uri);
+
+ if (applyContext.localOnly) {
+ applyContext.warnings.push('Cannot fetch remote resource from "' + uri + '" as no callback given.');
+ return whenLoaded(null);
+ } else if (isRuntimeResource) {
+ applyContext.warnings.push('Cannot fetch "' + uri + '" as no protocol given.');
+ return whenLoaded(null);
+ } else if (!isAllowed) {
+ applyContext.warnings.push('Cannot fetch "' + uri + '" as resource is not allowed.');
+ return whenLoaded(null);
+ }
+
+ applyContext.fetch(uri, applyContext.inlineRequest, applyContext.inlineTimeout, function (error, body) {
+ if (error) {
+ applyContext.warnings.push('Missing source map at "' + uri + '" - ' + error);
+ return whenLoaded(null);
+ }
+
+ whenLoaded(body);
+ });
+}
+
+function loadInputSourceMapFromLocalUri(uri, applyContext) {
+ var isAllowed = isAllowedResource(uri, false, applyContext.inline);
+ var sourceMap;
+
+ if (!fs.existsSync(uri) || !fs.statSync(uri).isFile()) {
+ applyContext.warnings.push('Ignoring local source map at "' + uri + '" as resource is missing.');
+ return null;
+ } else if (!isAllowed) {
+ applyContext.warnings.push('Cannot fetch "' + uri + '" as resource is not allowed.');
+ return null;
+ }
+
+ sourceMap = fs.readFileSync(uri, 'utf-8');
+ return JSON.parse(sourceMap);
+}
+
+function applySourceMapRecursively(tokens, inputSourceMapTracker) {
+ var token;
+ var i, l;
+
+ for (i = 0, l = tokens.length; i < l; i++) {
+ token = tokens[i];
+
+ switch (token[0]) {
+ case Token.AT_RULE:
+ applySourceMapTo(token, inputSourceMapTracker);
+ break;
+ case Token.AT_RULE_BLOCK:
+ applySourceMapRecursively(token[1], inputSourceMapTracker);
+ applySourceMapRecursively(token[2], inputSourceMapTracker);
+ break;
+ case Token.AT_RULE_BLOCK_SCOPE:
+ applySourceMapTo(token, inputSourceMapTracker);
+ break;
+ case Token.NESTED_BLOCK:
+ applySourceMapRecursively(token[1], inputSourceMapTracker);
+ applySourceMapRecursively(token[2], inputSourceMapTracker);
+ break;
+ case Token.NESTED_BLOCK_SCOPE:
+ applySourceMapTo(token, inputSourceMapTracker);
+ break;
+ case Token.COMMENT:
+ applySourceMapTo(token, inputSourceMapTracker);
+ break;
+ case Token.PROPERTY:
+ applySourceMapRecursively(token, inputSourceMapTracker);
+ break;
+ case Token.PROPERTY_BLOCK:
+ applySourceMapRecursively(token[1], inputSourceMapTracker);
+ break;
+ case Token.PROPERTY_NAME:
+ applySourceMapTo(token, inputSourceMapTracker);
+ break;
+ case Token.PROPERTY_VALUE:
+ applySourceMapTo(token, inputSourceMapTracker);
+ break;
+ case Token.RULE:
+ applySourceMapRecursively(token[1], inputSourceMapTracker);
+ applySourceMapRecursively(token[2], inputSourceMapTracker);
+ break;
+ case Token.RULE_SCOPE:
+ applySourceMapTo(token, inputSourceMapTracker);
+ }
+ }
+
+ return tokens;
+}
+
+function applySourceMapTo(token, inputSourceMapTracker) {
+ var value = token[1];
+ var metadata = token[2];
+ var newMetadata = [];
+ var i, l;
+
+ for (i = 0, l = metadata.length; i < l; i++) {
+ newMetadata.push(inputSourceMapTracker.originalPositionFor(metadata[i], value.length));
+ }
+
+ token[2] = newMetadata;
+}
+
+module.exports = applySourceMaps;