css-loader 6.1.0 → 6.5.0

package/dist/plugins/postcss-import-parser.js

@@ -11,7 +11,7 @@ var _utils = require("../utils");
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-function parseNode(atRule, key) {
+function parseNode(atRule, key, options) {
   // Convert only top-level @import
   if (atRule.parent.type !== "root") {
     return;
@@ -43,9 +43,10 @@ function parseNode(atRule, key) {
     throw error;
   }
 
+  const rawParams = atRule.raws && atRule.raws[key] && typeof atRule.raws[key].raw !== "undefined" ? atRule.raws[key].raw : atRule[key];
   const {
     nodes: paramsNodes
-  } = (0, _postcssValueParser.default)(atRule[key]); // No nodes - `@import ;`
+  } = (0, _postcssValueParser.default)(rawParams); // No nodes - `@import ;`
   // Invalid type - `@import foo-bar;`
 
   if (paramsNodes.length === 0 || paramsNodes[0].type !== "string" && paramsNodes[0].type !== "function") {
@@ -73,10 +74,13 @@ function parseNode(atRule, key) {
   }
 
   url = (0, _utils.normalizeUrl)(url, isStringValue);
-  const isRequestable = (0, _utils.isUrlRequestable)(url);
+  const {
+    requestable,
+    needResolve
+  } = (0, _utils.isURLRequestable)(url, options);
   let prefix;
 
-  if (isRequestable) {
+  if (requestable && needResolve) {
     const queryParts = url.split("!");
 
     if (queryParts.length > 1) {
@@ -92,11 +96,42 @@ function parseNode(atRule, key) {
     throw error;
   }
 
-  const mediaNodes = paramsNodes.slice(1);
+  const additionalNodes = paramsNodes.slice(1);
+  let supports;
+  let layer;
   let media;
 
-  if (mediaNodes.length > 0) {
-    media = _postcssValueParser.default.stringify(mediaNodes).trim().toLowerCase();
+  if (additionalNodes.length > 0) {
+    let nodes = [];
+
+    for (const node of additionalNodes) {
+      nodes.push(node);
+      const isLayerFunction = node.type === "function" && node.value.toLowerCase() === "layer";
+      const isLayerWord = node.type === "word" && node.value.toLowerCase() === "layer";
+
+      if (isLayerFunction || isLayerWord) {
+        if (isLayerFunction) {
+          nodes.splice(nodes.length - 1, 1, ...node.nodes);
+        } else {
+          nodes.splice(nodes.length - 1, 1, {
+            type: "string",
+            value: "",
+            unclosed: false
+          });
+        }
+
+        layer = _postcssValueParser.default.stringify(nodes).trim().toLowerCase();
+        nodes = [];
+      } else if (node.type === "function" && node.value.toLowerCase() === "supports") {
+        nodes.splice(nodes.length - 1, 1, ...node.nodes);
+        supports = _postcssValueParser.default.stringify(nodes).trim().toLowerCase();
+        nodes = [];
+      }
+    }
+
+    if (nodes.length > 0) {
+      media = _postcssValueParser.default.stringify(nodes).trim().toLowerCase();
+    }
   } // eslint-disable-next-line consistent-return
 
 
@@ -104,8 +139,11 @@ function parseNode(atRule, key) {
     atRule,
     prefix,
     url,
+    layer,
+    supports,
     media,
-    isRequestable
+    requestable,
+    needResolve
   };
 }
 
@@ -118,10 +156,22 @@ const plugin = (options = {}) => {
       return {
         AtRule: {
           import(atRule) {
+            if (options.isCSSStyleSheet) {
+              options.loaderContext.emitError(new Error(atRule.error("'@import' rules are not allowed here and will not be processed").message));
+              return;
+            }
+
+            const {
+              isSupportDataURL,
+              isSupportAbsoluteURL
+            } = options;
             let parsedAtRule;
 
             try {
-              parsedAtRule = parseNode(atRule, "params", result);
+              parsedAtRule = parseNode(atRule, "params", {
+                isSupportAbsoluteURL,
+                isSupportDataURL
+              });
             } catch (error) {
               result.warn(error.message, {
                 node: error.node
@@ -142,36 +192,46 @@ const plugin = (options = {}) => {
             return;
           }
 
+          const {
+            loaderContext
+          } = options;
+          const resolver = loaderContext.getResolve({
+            dependencyType: "css",
+            conditionNames: ["style"],
+            mainFields: ["css", "style", "main", "..."],
+            mainFiles: ["index", "..."],
+            extensions: [".css", "..."],
+            preferRelative: true
+          });
           const resolvedAtRules = await Promise.all(parsedAtRules.map(async parsedAtRule => {
             const {
               atRule,
-              isRequestable,
+              requestable,
+              needResolve,
               prefix,
               url,
+              layer,
+              supports,
               media
             } = parsedAtRule;
 
             if (options.filter) {
-              const needKeep = await options.filter(url, media);
+              const needKeep = await options.filter(url, media, loaderContext.resourcePath, supports, layer);
 
               if (!needKeep) {
                 return;
               }
             }
 
-            if (isRequestable) {
-              const request = (0, _utils.requestify)(url, options.rootContext);
-              const {
-                resolver,
-                context
-              } = options;
-              const resolvedUrl = await (0, _utils.resolveRequests)(resolver, context, [...new Set([request, url])]);
+            if (needResolve) {
+              const request = (0, _utils.requestify)(url, loaderContext.rootContext);
+              const resolvedUrl = await (0, _utils.resolveRequests)(resolver, loaderContext.context, [...new Set([request, url])]);
 
               if (!resolvedUrl) {
                 return;
               }
 
-              if (resolvedUrl === options.resourcePath) {
+              if (resolvedUrl === loaderContext.resourcePath) {
                 atRule.remove();
                 return;
               }
@@ -180,9 +240,11 @@ const plugin = (options = {}) => {
 
               return {
                 url: resolvedUrl,
+                layer,
+                supports,
                 media,
                 prefix,
-                isRequestable
+                requestable
               };
             }
 
@@ -190,9 +252,11 @@ const plugin = (options = {}) => {
 
             return {
               url,
+              layer,
+              supports,
               media,
               prefix,
-              isRequestable
+              requestable
             };
           }));
           const urlToNameMap = new Map();
@@ -207,13 +271,17 @@ const plugin = (options = {}) => {
 
             const {
               url,
-              isRequestable,
+              requestable,
+              layer,
+              supports,
               media
             } = resolvedAtRule;
 
-            if (!isRequestable) {
+            if (!requestable) {
               options.api.push({
                 url,
+                layer,
+                supports,
                 media,
                 index
               }); // eslint-disable-next-line no-continue
@@ -240,6 +308,8 @@ const plugin = (options = {}) => {
 
             options.api.push({
               importName,
+              layer,
+              supports,
               media,
               index
             });

package/dist/plugins/postcss-url-parser.js

@@ -49,32 +49,21 @@ function getWebpackIgnoreCommentValue(index, nodes, inBetween) {
   return matched && matched[2] === "true";
 }
 
-function shouldHandleURL(url, declaration, result, isSupportDataURLInNewURL) {
+function shouldHandleURL(url, declaration, result, options) {
   if (url.length === 0) {
     result.warn(`Unable to find uri in '${declaration.toString()}'`, {
       node: declaration
     });
-    return false;
+    return {
+      requestable: false,
+      needResolve: false
+    };
   }
 
-  if ((0, _utils.isDataUrl)(url) && isSupportDataURLInNewURL) {
-    try {
-      decodeURIComponent(url);
-    } catch (ignoreError) {
-      return false;
-    }
-
-    return true;
-  }
-
-  if (!(0, _utils.isUrlRequestable)(url)) {
-    return false;
-  }
-
-  return true;
+  return (0, _utils.isURLRequestable)(url, options);
 }
 
-function parseDeclaration(declaration, key, result, isSupportDataURLInNewURL) {
+function parseDeclaration(declaration, key, result, options) {
   if (!needParseDeclaration.test(declaration[key])) {
     return;
   }
@@ -126,9 +115,13 @@ function parseDeclaration(declaration, key, result, isSupportDataURLInNewURL) {
       } = valueNode;
       const isStringValue = nodes.length !== 0 && nodes[0].type === "string";
       let url = isStringValue ? nodes[0].value : _postcssValueParser.default.stringify(nodes);
-      url = (0, _utils.normalizeUrl)(url, isStringValue); // Do not traverse inside `url`
+      url = (0, _utils.normalizeUrl)(url, isStringValue);
+      const {
+        requestable,
+        needResolve
+      } = shouldHandleURL(url, declaration, result, options); // Do not traverse inside `url`
 
-      if (!shouldHandleURL(url, declaration, result, isSupportDataURLInNewURL)) {
+      if (!requestable) {
         // eslint-disable-next-line consistent-return
         return false;
       }
@@ -147,7 +140,8 @@ function parseDeclaration(declaration, key, result, isSupportDataURLInNewURL) {
         node: getNodeFromUrlFunc(valueNode),
         prefix,
         url,
-        needQuotes: false
+        needQuotes: false,
+        needResolve
       }); // eslint-disable-next-line consistent-return
 
       return false;
@@ -176,9 +170,13 @@ function parseDeclaration(declaration, key, result, isSupportDataURLInNewURL) {
           } = nNode;
           const isStringValue = nodes.length !== 0 && nodes[0].type === "string";
           let url = isStringValue ? nodes[0].value : _postcssValueParser.default.stringify(nodes);
-          url = (0, _utils.normalizeUrl)(url, isStringValue); // Do not traverse inside `url`
+          url = (0, _utils.normalizeUrl)(url, isStringValue);
+          const {
+            requestable,
+            needResolve
+          } = shouldHandleURL(url, declaration, result, options); // Do not traverse inside `url`
 
-          if (!shouldHandleURL(url, declaration, result, isSupportDataURLInNewURL)) {
+          if (!requestable) {
             // eslint-disable-next-line consistent-return
             return false;
           }
@@ -197,7 +195,8 @@ function parseDeclaration(declaration, key, result, isSupportDataURLInNewURL) {
             node: getNodeFromUrlFunc(nNode),
             prefix,
             url,
-            needQuotes: false
+            needQuotes: false,
+            needResolve
           });
         } else if (type === "string") {
           needIgnore = getWebpackIgnoreCommentValue(innerIndex, valueNode.nodes);
@@ -212,9 +211,13 @@ function parseDeclaration(declaration, key, result, isSupportDataURLInNewURL) {
             continue;
           }
 
-          let url = (0, _utils.normalizeUrl)(value, true); // Do not traverse inside `url`
+          let url = (0, _utils.normalizeUrl)(value, true);
+          const {
+            requestable,
+            needResolve
+          } = shouldHandleURL(url, declaration, result, options); // Do not traverse inside `url`
 
-          if (!shouldHandleURL(url, declaration, result, isSupportDataURLInNewURL)) {
+          if (!requestable) {
             // eslint-disable-next-line consistent-return
             return false;
           }
@@ -233,7 +236,8 @@ function parseDeclaration(declaration, key, result, isSupportDataURLInNewURL) {
             node: nNode,
             prefix,
             url,
-            needQuotes: true
+            needQuotes: true,
+            needResolve
           });
         }
       } // Do not traverse inside `image-set`
@@ -256,9 +260,13 @@ const plugin = (options = {}) => {
       return {
         Declaration(declaration) {
           const {
-            isSupportDataURLInNewURL
+            isSupportDataURL,
+            isSupportAbsoluteURL
           } = options;
-          const parsedURL = parseDeclaration(declaration, "value", result, isSupportDataURLInNewURL);
+          const parsedURL = parseDeclaration(declaration, "value", result, {
+            isSupportDataURL,
+            isSupportAbsoluteURL
+          });
 
           if (!parsedURL) {
             return;
@@ -274,7 +282,8 @@ const plugin = (options = {}) => {
 
           const resolvedDeclarations = await Promise.all(parsedDeclarations.map(async parsedDeclaration => {
             const {
-              url
+              url,
+              needResolve
             } = parsedDeclaration;
 
             if (options.filter) {
@@ -286,7 +295,7 @@ const plugin = (options = {}) => {
               }
             }
 
-            if ((0, _utils.isDataUrl)(url)) {
+            if (!needResolve) {
               // eslint-disable-next-line consistent-return
               return parsedDeclaration;
             }
@@ -296,12 +305,12 @@ const plugin = (options = {}) => {
             let hash = query ? "?" : "";
             hash += hashOrQuery ? `#${hashOrQuery}` : "";
             const {
-              needToResolveURL,
+              resolver,
               rootContext
             } = options;
-            const request = (0, _utils.requestify)(pathname, rootContext, needToResolveURL);
+            const request = (0, _utils.requestify)(pathname, rootContext, Boolean(resolver));
 
-            if (!needToResolveURL) {
+            if (!resolver) {
               // eslint-disable-next-line consistent-return
               return { ...parsedDeclaration,
                 url: request,
@@ -309,20 +318,16 @@ const plugin = (options = {}) => {
               };
             }
 
-            const {
-              resolver,
-              context
-            } = options;
-            const resolvedUrl = await (0, _utils.resolveRequests)(resolver, context, [...new Set([request, url])]);
+            const resolvedURL = await (0, _utils.resolveRequests)(resolver, options.context, [...new Set([request, url])]);
 
-            if (!resolvedUrl) {
+            if (!resolvedURL) {
               // eslint-disable-next-line consistent-return
               return;
             } // eslint-disable-next-line consistent-return
 
 
             return { ...parsedDeclaration,
-              url: resolvedUrl,
+              url: resolvedURL,
               hash
             };
           }));
@@ -361,7 +366,7 @@ const plugin = (options = {}) => {
               options.imports.push({
                 type: "url",
                 importName,
-                url: options.needToResolveURL ? options.urlHandler(newUrl) : JSON.stringify(newUrl),
+                url: options.resolver ? options.urlHandler(newUrl) : JSON.stringify(newUrl),
                 index
               });
             }

package/dist/runtime/api.js

@@ -4,37 +4,55 @@
   MIT License http://www.opensource.org/licenses/mit-license.php
   Author Tobias Koppers @sokra
 */
-// css base code, injected by the css-loader
-// eslint-disable-next-line func-names
 module.exports = function (cssWithMappingToString) {
   var list = []; // return the list of modules as css string
 
   list.toString = function toString() {
     return this.map(function (item) {
-      var content = cssWithMappingToString(item);
+      var content = "";
+      var needLayer = typeof item[5] !== "undefined";
+
+      if (item[4]) {
+        content += "@supports (".concat(item[4], ") {");
+      }
+
+      if (item[2]) {
+        content += "@media ".concat(item[2], " {");
+      }
+
+      if (needLayer) {
+        content += "@layer".concat(item[5].length > 0 ? " ".concat(item[5]) : "", " {");
+      }
+
+      content += cssWithMappingToString(item);
+
+      if (needLayer) {
+        content += "}";
+      }
 
       if (item[2]) {
-        return "@media ".concat(item[2], " {").concat(content, "}");
+        content += "}";
+      }
+
+      if (item[4]) {
+        content += "}";
       }
 
       return content;
     }).join("");
   }; // import a list of modules into the list
-  // eslint-disable-next-line func-names
 
 
-  list.i = function (modules, mediaQuery, dedupe) {
+  list.i = function i(modules, media, dedupe, supports, layer) {
     if (typeof modules === "string") {
-      // eslint-disable-next-line no-param-reassign
-      modules = [[null, modules, ""]];
+      modules = [[null, modules, undefined]];
     }
 
     var alreadyImportedModules = {};
 
     if (dedupe) {
-      for (var i = 0; i < this.length; i++) {
-        // eslint-disable-next-line prefer-destructuring
-        var id = this[i][0];
+      for (var k = 0; k < this.length; k++) {
+        var id = this[k][0];
 
         if (id != null) {
           alreadyImportedModules[id] = true;
@@ -42,19 +60,37 @@ module.exports = function (cssWithMappingToString) {
       }
     }
 
-    for (var _i = 0; _i < modules.length; _i++) {
-      var item = [].concat(modules[_i]);
+    for (var _k = 0; _k < modules.length; _k++) {
+      var item = [].concat(modules[_k]);
 
       if (dedupe && alreadyImportedModules[item[0]]) {
-        // eslint-disable-next-line no-continue
         continue;
       }
 
-      if (mediaQuery) {
+      if (typeof layer !== "undefined") {
+        if (typeof item[5] === "undefined") {
+          item[5] = layer;
+        } else {
+          item[1] = "@layer".concat(item[5].length > 0 ? " ".concat(item[5]) : "", " {").concat(item[1], "}");
+          item[5] = layer;
+        }
+      }
+
+      if (media) {
         if (!item[2]) {
-          item[2] = mediaQuery;
+          item[2] = media;
+        } else {
+          item[1] = "@media ".concat(item[2], " {").concat(item[1], "}");
+          item[2] = media;
+        }
+      }
+
+      if (supports) {
+        if (!item[4]) {
+          item[4] = "".concat(supports);
         } else {
-          item[2] = "".concat(mediaQuery, " and ").concat(item[2]);
+          item[1] = "@supports (".concat(item[4], ") {").concat(item[1], "}");
+          item[4] = supports;
         }
       }
 

package/dist/runtime/getUrl.js

@@ -2,24 +2,20 @@
 
 module.exports = function (url, options) {
   if (!options) {
-    // eslint-disable-next-line no-param-reassign
     options = {};
   }
 
   if (!url) {
     return url;
-  } // eslint-disable-next-line no-underscore-dangle, no-param-reassign
-
+  }
 
   url = String(url.__esModule ? url.default : url); // If url is already wrapped in quotes, remove them
 
   if (/^['"].*['"]$/.test(url)) {
-    // eslint-disable-next-line no-param-reassign
     url = url.slice(1, -1);
   }
 
   if (options.hash) {
-    // eslint-disable-next-line no-param-reassign
     url += options.hash;
   } // Should url be wrapped?
   // See https://drafts.csswg.org/css-values-3/#urls

package/dist/runtime/noSourceMaps.js

@@ -0,0 +1,5 @@
+"use strict";
+
+module.exports = function (i) {
+  return i[1];
+};

package/dist/runtime/sourceMaps.js

@@ -0,0 +1,22 @@
+"use strict";
+
+module.exports = function (item) {
+  var content = item[1];
+  var cssMapping = item[3];
+
+  if (!cssMapping) {
+    return content;
+  }
+
+  if (typeof btoa === "function") {
+    var base64 = btoa(unescape(encodeURIComponent(JSON.stringify(cssMapping))));
+    var data = "sourceMappingURL=data:application/json;charset=utf-8;base64,".concat(base64);
+    var sourceMapping = "/*# ".concat(data, " */");
+    var sourceURLs = cssMapping.sources.map(function (source) {
+      return "/*# sourceURL=".concat(cssMapping.sourceRoot || "").concat(source, " */");
+    });
+    return [content].concat(sourceURLs).concat([sourceMapping]).join("\n");
+  }
+
+  return [content].join("\n");
+};