fix: prevent asset conflicts between React and Grid.js versions

Add coexistence checks to all enqueue methods to prevent loading
both React and Grid.js assets simultaneously.

Changes:
- ReactAdmin.php: Only enqueue React assets when ?react=1
- Init.php: Skip Grid.js when React active on admin pages
- Form.php, Coupon.php, Access.php: Restore classic assets when ?react=0
- Customer.php, Product.php, License.php: Add coexistence checks

Now the toggle between Classic and React versions works correctly.

Co-authored-by: Claude Opus 4.7 <noreply@anthropic.com>

node_modules/stylelint-scss/dist/index.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _stylelint = require("stylelint");
+var _utils = require("./utils");
+var _rules = _interopRequireDefault(require("./rules"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+var rulesPlugins = Object.keys(_rules["default"]).map(function (ruleName) {
+  return (0, _stylelint.createPlugin)((0, _utils.namespace)(ruleName), _rules["default"][ruleName]);
+});
+var _default = rulesPlugins;
+exports["default"] = _default;

node_modules/stylelint-scss/dist/rules/at-each-key-value-single-line/index.js

@@ -0,0 +1,114 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = rule;
+exports.ruleName = exports.meta = exports.messages = void 0;
+var _stylelint = require("stylelint");
+var _utils = require("../../utils");
+var ruleName = (0, _utils.namespace)("at-each-key-value-single-line");
+exports.ruleName = ruleName;
+var messages = _stylelint.utils.ruleMessages(ruleName, {
+  expected: "Use @each $key, $value in $map syntax instead of $value: map-get($map, $key)"
+});
+exports.messages = messages;
+var meta = {
+  url: (0, _utils.ruleUrl)(ruleName)
+};
+exports.meta = meta;
+function rule(primary) {
+  return function (root, result) {
+    var validOptions = _stylelint.utils.validateOptions(result, ruleName, {
+      actual: primary
+    });
+    if (!validOptions) {
+      return;
+    }
+    var mapNamespace = (0, _utils.moduleNamespace)(root, "sass:map");
+    root.walkAtRules("each", function (rule) {
+      var parts = separateEachParams(rule.params);
+
+      // If loop is fetching both key + value, return
+      if (parts[0].length === 2) {
+        return;
+      }
+
+      // If didn't call map-keys, return.
+      if (!didCallMapKeys(parts[1], mapNamespace)) {
+        return;
+      }
+
+      // Loop over decls inside of each statement and loop for variable assignments.
+      rule.walkDecls(function (innerDecl) {
+        // Check that this decl is a map-get call
+        if (innerDecl.prop[0] !== "$") {
+          return;
+        }
+        if (!didCallMapGet(innerDecl.value, mapNamespace)) {
+          return;
+        }
+
+        // Check map_name + key_name match.
+        var map_get_parts = mapGetParameters(innerDecl.value, mapNamespace);
+
+        // Check map names match.
+        if (map_get_parts[0] !== mapName(parts[1], mapNamespace)) {
+          return;
+        }
+
+        // Match key names match.
+        if (map_get_parts[1] !== parts[0][0]) {
+          return;
+        }
+        _stylelint.utils.report({
+          message: messages.expected,
+          node: rule,
+          result: result,
+          ruleName: ruleName,
+          word: rule.params
+        });
+      });
+    });
+  };
+}
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+
+// Takes in a param string from node.params
+// Returns: [[key variable, value variable], map_decl] (all Strings)
+function separateEachParams(paramString) {
+  var parts = paramString.split("in");
+  return [parts[0].split(",").map(function (s) {
+    return s.trim();
+  }), parts[1].trim()];
+}
+function didCallMapKeys(mapDecl, mapNamespace) {
+  var pattern = getNamespacedPattern("keys\\(.*\\)", mapNamespace);
+  return new RegExp(pattern).test(mapDecl);
+}
+function didCallMapGet(mapDecl, mapNamespace) {
+  var pattern = getNamespacedPattern("get\\((.*),(.*)\\)", mapNamespace);
+  return new RegExp(pattern).test(mapDecl);
+}
+
+// Fetch the name of the map from a map-keys() or map.keys() call.
+function mapName(mapDecl, mapNamespace) {
+  if (didCallMapKeys(mapDecl, mapNamespace)) {
+    var pattern = getNamespacedPattern("keys\\((.*)\\)", mapNamespace);
+    return mapDecl.match(new RegExp(pattern))[1];
+  }
+  return mapDecl;
+}
+
+// Returns the parameters of a map-get or map.get call
+// Returns [map variable, key_variable]
+function mapGetParameters(mapGetDecl, mapNamespace) {
+  var pattern = getNamespacedPattern("get\\((.*), ?(.*)\\)", mapNamespace);
+  var parts = mapGetDecl.match(new RegExp(pattern));
+  return [parts[1], parts[2]];
+}
+function getNamespacedPattern(pattern, namespace) {
+  return namespace !== null ? "(?:".concat(namespace, "\\.|map-)").concat(pattern) : pattern;
+}

node_modules/stylelint-scss/dist/rules/at-else-closing-brace-newline-after/index.js

@@ -0,0 +1,51 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = rule;
+exports.ruleName = exports.meta = exports.messages = void 0;
+var _stylelint = require("stylelint");
+var _utils = require("../../utils");
+var _atIfClosingBraceNewlineAfter = require("../at-if-closing-brace-newline-after");
+var ruleName = (0, _utils.namespace)("at-else-closing-brace-newline-after");
+exports.ruleName = ruleName;
+var messages = _stylelint.utils.ruleMessages(ruleName, {
+  expected: 'Expected newline after "}" of @else statement',
+  rejected: 'Unexpected newline after "}" of @else statement'
+});
+exports.messages = messages;
+var meta = {
+  url: (0, _utils.ruleUrl)(ruleName)
+};
+exports.meta = meta;
+function rule(expectation, options, context) {
+  return function (root, result) {
+    var validOptions = _stylelint.utils.validateOptions(result, ruleName, {
+      actual: expectation,
+      possible: ["always-last-in-chain"]
+    }, {
+      actual: options,
+      possible: {
+        disableFix: _utils.isBoolean
+      },
+      optional: true
+    });
+    if (!validOptions) {
+      return;
+    }
+    (0, _atIfClosingBraceNewlineAfter.sassConditionalBraceNLAfterChecker)({
+      root: root,
+      result: result,
+      ruleName: ruleName,
+      atRuleName: "else",
+      expectation: expectation,
+      messages: messages,
+      context: context,
+      options: options
+    });
+  };
+}
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;

node_modules/stylelint-scss/dist/rules/at-else-closing-brace-space-after/index.js

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = rule;
+exports.ruleName = exports.meta = exports.messages = void 0;
+var _utils = require("../../utils");
+var _stylelint = require("stylelint");
+var _atIfClosingBraceSpaceAfter = require("../at-if-closing-brace-space-after");
+var ruleName = (0, _utils.namespace)("at-else-closing-brace-space-after");
+exports.ruleName = ruleName;
+var messages = _stylelint.utils.ruleMessages(ruleName, {
+  expected: 'Expected single space after "}" of @else statement',
+  rejected: 'Unexpected space after "}" of @else statement'
+});
+exports.messages = messages;
+var meta = {
+  url: (0, _utils.ruleUrl)(ruleName)
+};
+exports.meta = meta;
+function rule(expectation, _, context) {
+  return function (root, result) {
+    var validOptions = _stylelint.utils.validateOptions(result, ruleName, {
+      actual: expectation,
+      possible: ["always-intermediate", "never-intermediate"]
+    });
+    if (!validOptions) {
+      return;
+    }
+    (0, _atIfClosingBraceSpaceAfter.sassConditionalBraceSpaceAfterChecker)({
+      root: root,
+      result: result,
+      ruleName: ruleName,
+      atRuleName: "else",
+      expectation: expectation,
+      messages: messages,
+      context: context
+    });
+  };
+}
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;

node_modules/stylelint-scss/dist/rules/at-else-empty-line-before/index.js

@@ -0,0 +1,55 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = rule;
+exports.ruleName = exports.meta = exports.messages = void 0;
+var _utils = require("../../utils");
+var _stylelint = require("stylelint");
+var ruleName = (0, _utils.namespace)("at-else-empty-line-before");
+exports.ruleName = ruleName;
+var messages = _stylelint.utils.ruleMessages(ruleName, {
+  rejected: "Unexpected empty line before @else"
+});
+exports.messages = messages;
+var meta = {
+  url: (0, _utils.ruleUrl)(ruleName)
+};
+exports.meta = meta;
+function rule(expectation, _, context) {
+  return function (root, result) {
+    var validOptions = _stylelint.utils.validateOptions(result, ruleName, {
+      actual: expectation,
+      possible: ["never"]
+    });
+    if (!validOptions) {
+      return;
+    }
+    root.walkAtRules(function (atrule) {
+      if (atrule.name !== "else") {
+        return;
+      }
+
+      // Don't need to ignore "the first rule in a stylesheet", etc, cases
+      // because @else should always go after @if
+
+      if (!(0, _utils.hasEmptyLine)(atrule.raws.before)) {
+        return;
+      }
+      if (context.fix) {
+        atrule.raws.before = " ";
+        return;
+      }
+      _stylelint.utils.report({
+        message: messages.rejected,
+        node: atrule,
+        result: result,
+        ruleName: ruleName
+      });
+    });
+  };
+}
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;

node_modules/stylelint-scss/dist/rules/at-else-if-parentheses-space-before/index.js

@@ -0,0 +1,62 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = rule;
+exports.ruleName = exports.meta = exports.messages = void 0;
+var _stylelint = require("stylelint");
+var _utils = require("../../utils");
+var ruleName = (0, _utils.namespace)("at-else-if-parentheses-space-before");
+exports.ruleName = ruleName;
+var messages = _stylelint.utils.ruleMessages(ruleName, {
+  rejectedBefore: function rejectedBefore() {
+    return "Unexpected whitespace before parentheses in else-if declaration";
+  },
+  expectedBefore: function expectedBefore() {
+    return "Expected a single space before parentheses in else-if declaration";
+  }
+});
+exports.messages = messages;
+var meta = {
+  url: (0, _utils.ruleUrl)(ruleName)
+};
+exports.meta = meta;
+function rule(value, _, context) {
+  return function (root, result) {
+    var validOptions = _stylelint.utils.validateOptions(result, ruleName, {
+      actual: value,
+      possible: ["always", "never"]
+    });
+    if (!validOptions) {
+      return;
+    }
+    var match = /^if\s*\(/;
+    var replacement = value === "always" ? "if (" : "if(";
+    var checker = (0, _utils.whitespaceChecker)("space", value, messages).before;
+    root.walkAtRules("else", function (decl) {
+      // return early if the else-if statement is not surrounded by parentheses
+      if (!match.test(decl.params)) {
+        return;
+      }
+      if (context.fix) {
+        decl.params = decl.params.replace(match, replacement);
+      }
+      checker({
+        source: decl.params,
+        index: decl.params.indexOf("("),
+        err: function err(message) {
+          return _stylelint.utils.report({
+            message: message,
+            node: decl,
+            result: result,
+            ruleName: ruleName
+          });
+        }
+      });
+    });
+  };
+}
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;

node_modules/stylelint-scss/dist/rules/at-extend-no-missing-placeholder/index.js

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = rule;
+exports.ruleName = exports.meta = exports.messages = void 0;
+var _stylelint = require("stylelint");
+var _utils = require("../../utils");
+var ruleName = (0, _utils.namespace)("at-extend-no-missing-placeholder");
+exports.ruleName = ruleName;
+var messages = _stylelint.utils.ruleMessages(ruleName, {
+  rejected: "Expected a placeholder selector (e.g. %placeholder) to be used in @extend"
+});
+exports.messages = messages;
+var meta = {
+  url: (0, _utils.ruleUrl)(ruleName)
+};
+exports.meta = meta;
+function rule(actual) {
+  return function (root, result) {
+    var validOptions = _stylelint.utils.validateOptions(result, ruleName, {
+      actual: actual
+    });
+    if (!validOptions) {
+      return;
+    }
+    root.walkAtRules("extend", function (atrule) {
+      var isPlaceholder = atrule.params.trim()[0] === "%";
+      var isInterpolation = /^#{.+}/.test(atrule.params.trim());
+      if (!isPlaceholder && !isInterpolation) {
+        _stylelint.utils.report({
+          ruleName: ruleName,
+          result: result,
+          node: atrule,
+          message: messages.rejected
+        });
+      }
+    });
+  };
+}
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;

node_modules/stylelint-scss/dist/rules/at-function-named-arguments/index.js

@@ -0,0 +1,98 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = rule;
+exports.ruleName = exports.meta = exports.messages = void 0;
+var _postcssValueParser = _interopRequireDefault(require("postcss-value-parser"));
+var _stylelint = require("stylelint");
+var _utils = require("../../utils");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+var ruleName = (0, _utils.namespace)("at-function-named-arguments");
+exports.ruleName = ruleName;
+var messages = _stylelint.utils.ruleMessages(ruleName, {
+  expected: "Expected a named parameter to be used in function call",
+  rejected: "Unexpected a named parameter in function call"
+});
+exports.messages = messages;
+var meta = {
+  url: (0, _utils.ruleUrl)(ruleName)
+};
+exports.meta = meta;
+var isScssVarRegExp = /^\$\S*/;
+function rule(expectation, options) {
+  return function (root, result) {
+    var validOptions = _stylelint.utils.validateOptions(result, ruleName, {
+      actual: expectation,
+      possible: ["always", "never"]
+    }, {
+      actual: options,
+      possible: {
+        ignore: ["single-argument"],
+        ignoreFunctions: [_utils.isString]
+      },
+      optional: true
+    });
+    if (!validOptions) {
+      return;
+    }
+    var shouldIgnoreSingleArgument = (0, _utils.optionsHaveIgnored)(options, "single-argument");
+    root.walkDecls(function (decl) {
+      (0, _postcssValueParser["default"])(decl.value).walk(function (node) {
+        if (node.type !== "function" || (0, _utils.isNativeCssFunction)(node.value) || node.value === "") {
+          return;
+        }
+        var hasFuncIgnored = options && options.ignoreFunctions && options.ignoreFunctions.some(function (f) {
+          var isRegex = /^\/.*\//.test(f);
+          if (!isRegex) {
+            return f === node.value;
+          }
+          var parts = f.split("/");
+          return new RegExp(parts[1], parts[2] || "").test(node.value);
+        });
+        if (hasFuncIgnored) {
+          return;
+        }
+        var args = (0, _utils.parseFunctionArguments)(_postcssValueParser["default"].stringify(node));
+        var isSingleArgument = args.length === 1;
+        if (isSingleArgument && shouldIgnoreSingleArgument) {
+          return;
+        }
+        args.forEach(function (arg) {
+          switch (expectation) {
+            case "never":
+              {
+                if (!arg.key) {
+                  return;
+                }
+                _stylelint.utils.report({
+                  message: messages.rejected,
+                  node: decl,
+                  result: result,
+                  ruleName: ruleName
+                });
+                break;
+              }
+            case "always":
+              {
+                if (arg.key && isScssVarRegExp.test(arg.key)) {
+                  return;
+                }
+                _stylelint.utils.report({
+                  message: messages.expected,
+                  node: decl,
+                  result: result,
+                  ruleName: ruleName
+                });
+                break;
+              }
+          }
+        });
+      });
+    });
+  };
+}
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;

node_modules/stylelint-scss/dist/rules/at-function-parentheses-space-before/index.js

@@ -0,0 +1,59 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = rule;
+exports.ruleName = exports.meta = exports.messages = void 0;
+var _stylelint = require("stylelint");
+var _utils = require("../../utils");
+var ruleName = (0, _utils.namespace)("at-function-parentheses-space-before");
+exports.ruleName = ruleName;
+var messages = _stylelint.utils.ruleMessages(ruleName, {
+  rejectedBefore: function rejectedBefore() {
+    return "Unexpected whitespace before parentheses in function declaration";
+  },
+  expectedBefore: function expectedBefore() {
+    return "Expected a single space before parentheses in function declaration";
+  }
+});
+exports.messages = messages;
+var meta = {
+  url: (0, _utils.ruleUrl)(ruleName)
+};
+exports.meta = meta;
+function rule(value, _, context) {
+  return function (root, result) {
+    var validOptions = _stylelint.utils.validateOptions(result, ruleName, {
+      actual: value,
+      possible: ["always", "never"]
+    });
+    if (!validOptions) {
+      return;
+    }
+    var match = /^([\w-]+)\s*\(/;
+    var replacement = value === "always" ? "$1 (" : "$1(";
+    var checker = (0, _utils.whitespaceChecker)("space", value, messages).before;
+    root.walkAtRules("function", function (decl) {
+      if (context.fix) {
+        decl.params = decl.params.replace(match, replacement);
+        return;
+      }
+      checker({
+        source: decl.params,
+        index: decl.params.indexOf("("),
+        err: function err(message) {
+          return _stylelint.utils.report({
+            message: message,
+            node: decl,
+            result: result,
+            ruleName: ruleName
+          });
+        }
+      });
+    });
+  };
+}
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;

node_modules/stylelint-scss/dist/rules/at-function-pattern/index.js

@@ -0,0 +1,55 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = rule;
+exports.ruleName = exports.meta = exports.messages = void 0;
+var _stylelint = require("stylelint");
+var _utils = require("../../utils");
+var ruleName = (0, _utils.namespace)("at-function-pattern");
+exports.ruleName = ruleName;
+var messages = _stylelint.utils.ruleMessages(ruleName, {
+  expected: "Expected @function name to match specified pattern"
+});
+exports.messages = messages;
+var meta = {
+  url: (0, _utils.ruleUrl)(ruleName)
+};
+exports.meta = meta;
+function rule(pattern) {
+  return function (root, result) {
+    var validOptions = _stylelint.utils.validateOptions(result, ruleName, {
+      actual: pattern,
+      possible: [_utils.isRegExp, _utils.isString]
+    });
+    if (!validOptions) {
+      return;
+    }
+    var regexpPattern = (0, _utils.isString)(pattern) ? new RegExp(pattern) : pattern;
+    root.walkAtRules(function (decl) {
+      if (decl.name !== "function") {
+        return;
+      }
+
+      // Stripping the function of its arguments
+      var funcName = decl.params.replace(/(\s*)\([\s\S]*\)/g, "");
+      if (regexpPattern.test(funcName)) {
+        return;
+      }
+      var funcTopLine = Object.assign({}, decl.source.start);
+      funcTopLine.line += 1;
+      funcTopLine.column = 0;
+      _stylelint.utils.report({
+        message: messages.expected,
+        node: decl,
+        result: result,
+        ruleName: ruleName,
+        end: funcTopLine
+      });
+    });
+  };
+}
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;

node_modules/stylelint-scss/dist/rules/at-if-closing-brace-newline-after/index.js

@@ -0,0 +1,113 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = rule;
+exports.ruleName = exports.meta = exports.messages = void 0;
+exports.sassConditionalBraceNLAfterChecker = sassConditionalBraceNLAfterChecker;
+var _stylelint = require("stylelint");
+var _utils = require("../../utils");
+var ruleName = (0, _utils.namespace)("at-if-closing-brace-newline-after");
+exports.ruleName = ruleName;
+var messages = _stylelint.utils.ruleMessages(ruleName, {
+  expected: 'Expected newline after "}" of @if statement',
+  rejected: 'Unexpected newline after "}" of @if statement'
+});
+exports.messages = messages;
+var meta = {
+  url: (0, _utils.ruleUrl)(ruleName)
+};
+exports.meta = meta;
+function rule(expectation, options, context) {
+  return function (root, result) {
+    var validOptions = _stylelint.utils.validateOptions(result, ruleName, {
+      actual: expectation,
+      possible: ["always-last-in-chain"]
+    }, {
+      actual: options,
+      possible: {
+        disableFix: _utils.isBoolean
+      },
+      optional: true
+    });
+    if (!validOptions) {
+      return;
+    }
+    sassConditionalBraceNLAfterChecker({
+      root: root,
+      result: result,
+      ruleName: ruleName,
+      atRuleName: "if",
+      expectation: expectation,
+      messages: messages,
+      context: context,
+      options: options
+    });
+  };
+}
+
+/**
+ * The core logic for this rule. Can be imported by other rules with similar
+ * logic, namely at-else-closing-brace-newline-after
+ *
+ * @param {Object} args -- Named arguments object
+ * @param {PostCSS root} args.root
+ * @param {PostCSS result} args.result
+ * @param {String ruleName} args.ruleName - needed for `report` function
+ * @param {String} args.atRuleName - the name of the at-rule to be checked, e.g. "if", "else"
+ * @param {Object} args.messages - returned by stylelint.utils.ruleMessages
+ * @return {undefined}
+ */
+function sassConditionalBraceNLAfterChecker(_ref) {
+  var root = _ref.root,
+    result = _ref.result,
+    ruleName = _ref.ruleName,
+    atRuleName = _ref.atRuleName,
+    expectation = _ref.expectation,
+    messages = _ref.messages,
+    context = _ref.context,
+    options = _ref.options;
+  var shouldFix = context.fix && (!options || options.disableFix !== true);
+  function complain(node, message, index, fixValue) {
+    if (shouldFix) {
+      node.next().raws.before = fixValue;
+      return;
+    }
+    _stylelint.utils.report({
+      result: result,
+      ruleName: ruleName,
+      node: node,
+      message: message,
+      index: index
+    });
+  }
+  root.walkAtRules(function (atrule) {
+    // Do nothing if it's not an @if
+    if (atrule.name !== atRuleName) {
+      return;
+    }
+    var nextNode = atrule.next();
+    if (!nextNode) {
+      return;
+    }
+    var nextBefore = nextNode.raws.before;
+    var hasNewLinesBeforeNext = nextBefore && !(0, _utils.isSingleLineString)(nextBefore);
+    var reportIndex = atrule.toString().length;
+    if (expectation === "always-last-in-chain") {
+      // If followed by @else, no newline is needed
+      if (nextNode.type === "atrule" && (nextNode.name === "else" || nextNode.name === "elseif")) {
+        if (hasNewLinesBeforeNext) {
+          complain(atrule, messages.rejected, reportIndex, " ");
+        }
+      } else {
+        if (!hasNewLinesBeforeNext) {
+          complain(atrule, messages.expected, reportIndex, context.newline);
+        }
+      }
+    }
+  });
+}
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;

node_modules/stylelint-scss/dist/rules/at-if-closing-brace-space-after/index.js

@@ -0,0 +1,100 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = rule;
+exports.ruleName = exports.meta = exports.messages = void 0;
+exports.sassConditionalBraceSpaceAfterChecker = sassConditionalBraceSpaceAfterChecker;
+var _utils = require("../../utils");
+var _stylelint = require("stylelint");
+var ruleName = (0, _utils.namespace)("at-if-closing-brace-space-after");
+exports.ruleName = ruleName;
+var messages = _stylelint.utils.ruleMessages(ruleName, {
+  expected: 'Expected single space after "}" of @if statement',
+  rejected: 'Unexpected space after "}" of @if statement'
+});
+exports.messages = messages;
+var meta = {
+  url: (0, _utils.ruleUrl)(ruleName)
+};
+exports.meta = meta;
+function rule(expectation, _, context) {
+  return function (root, result) {
+    var validOptions = _stylelint.utils.validateOptions(result, ruleName, {
+      actual: expectation,
+      possible: ["always-intermediate", "never-intermediate"]
+    });
+    if (!validOptions) {
+      return;
+    }
+    sassConditionalBraceSpaceAfterChecker({
+      root: root,
+      result: result,
+      ruleName: ruleName,
+      atRuleName: "if",
+      expectation: expectation,
+      messages: messages,
+      context: context
+    });
+  };
+}
+
+/**
+ * The core logic for this rule. Can be imported by other rules with similar
+ * logic, namely at-else-closing-brace-space-after
+ *
+ * @param {Object} args -- Named arguments object
+ * @param {PostCSS root} args.root
+ * @param {PostCSS result} args.result
+ * @param {String ruleName} args.ruleName - needed for `report` function
+ * @param {String} args.atRuleName - the name of the at-rule to be checked, e.g. "if", "else"
+ * @param {Object} args.messages - returned by stylelint.utils.ruleMessages
+ * @return {undefined}
+ */
+function sassConditionalBraceSpaceAfterChecker(_ref) {
+  var root = _ref.root,
+    result = _ref.result,
+    ruleName = _ref.ruleName,
+    atRuleName = _ref.atRuleName,
+    expectation = _ref.expectation,
+    messages = _ref.messages,
+    context = _ref.context;
+  function complain(node, message, index, fixValue) {
+    if (context.fix) {
+      node.next().raws.before = fixValue;
+      return;
+    }
+    _stylelint.utils.report({
+      result: result,
+      ruleName: ruleName,
+      node: node,
+      message: message,
+      index: index
+    });
+  }
+  root.walkAtRules(function (atrule) {
+    // Do nothing if it's not an @if
+    if (atrule.name !== atRuleName) {
+      return;
+    }
+    var nextNode = atrule.next();
+    var hasSpaceAfter = nextNode && nextNode.raws.before === " ";
+    var hasWhiteSpaceAfter = nextNode && nextNode.raws.before !== "";
+    var reportIndex = atrule.toString().length;
+
+    // When followed by an @else
+    if (nextNode && nextNode.type === "atrule" && nextNode.name === "else") {
+      // A single space is needed
+      if (expectation === "always-intermediate" && !hasSpaceAfter) {
+        complain(atrule, messages.expected, reportIndex, " ");
+      } else if (expectation === "never-intermediate" && hasWhiteSpaceAfter) {
+        // No whitespace is needed
+        complain(atrule, messages.rejected, reportIndex, "");
+      }
+    }
+  });
+}
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;

node_modules/stylelint-scss/dist/rules/at-if-no-null/index.js

@@ -0,0 +1,59 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = rule;
+exports.ruleName = exports.meta = exports.messages = void 0;
+var _utils = require("../../utils");
+var _stylelint = require("stylelint");
+var ruleName = (0, _utils.namespace)("at-if-no-null");
+exports.ruleName = ruleName;
+var messages = _stylelint.utils.ruleMessages(ruleName, {
+  equals_null: "Expected @if not statement rather than @if statement == null",
+  not_equals_null: "Expected @if statement rather than @if statement != null"
+});
+exports.messages = messages;
+var meta = {
+  url: (0, _utils.ruleUrl)(ruleName)
+};
+exports.meta = meta;
+function rule(expectation) {
+  return function (root, result) {
+    var validOptions = _stylelint.utils.validateOptions(result, ruleName, {
+      actual: expectation
+    });
+    if (!validOptions) {
+      return;
+    }
+    root.walkAtRules(function (atrule) {
+      // Do nothing if it's not an @if
+      if (atrule.name !== "if") {
+        return;
+      }
+
+      // If rule != null and (expr), skip
+      if (atrule.params.match(/.* != null and .*/)) {
+        return;
+      }
+      if (atrule.params.match(/.* == null[ \t]*\)?/)) {
+        _stylelint.utils.report({
+          message: messages.equals_null,
+          node: atrule,
+          result: result,
+          ruleName: ruleName
+        });
+      } else if (atrule.params.match(/.* != null[ \t]*\)?/)) {
+        _stylelint.utils.report({
+          message: messages.not_equals_null,
+          node: atrule,
+          result: result,
+          ruleName: ruleName
+        });
+      }
+    });
+  };
+}
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;

node_modules/stylelint-scss/dist/rules/at-import-no-partial-leading-underscore/index.js

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = rule;
+exports.ruleName = exports.meta = exports.messages = void 0;
+var _stylelint = require("stylelint");
+var _utils = require("../../utils");
+var ruleName = (0, _utils.namespace)("at-import-no-partial-leading-underscore");
+exports.ruleName = ruleName;
+var messages = _stylelint.utils.ruleMessages(ruleName, {
+  expected: "Unexpected leading underscore in imported partial name"
+});
+exports.messages = messages;
+var meta = {
+  url: (0, _utils.ruleUrl)(ruleName)
+};
+exports.meta = meta;
+function rule(actual) {
+  return function (root, result) {
+    var validOptions = _stylelint.utils.validateOptions(result, ruleName, {
+      actual: actual
+    });
+    if (!validOptions) {
+      return;
+    }
+    function checkPathForUnderscore(path, decl) {
+      // Stripping trailing quotes and whitespaces, if any
+      var pathStripped = path.replace(/^\s*(["'])\s*/, "").replace(/\s*(["'])\s*$/, "");
+
+      // Searching a _ at the start of filename
+      if (pathStripped.search(/(?:^|\/|\\)_[^/]+$/) === -1) {
+        return;
+      }
+
+      // Skipping importing CSS: url(), ".css", URI with a protocol, media
+      if (pathStripped.slice(0, 4) === "url(" || pathStripped.slice(-4) === ".css" || pathStripped.search("//") !== -1 || pathStripped.search(/[\s,)"']\w+$/) !== -1) {
+        return;
+      }
+      _stylelint.utils.report({
+        message: messages.expected,
+        node: decl,
+        result: result,
+        ruleName: ruleName
+      });
+    }
+    root.walkAtRules("import", function (decl) {
+      // Processing comma-separated lists of import paths
+      decl.params.split(",").forEach(function (path) {
+        checkPathForUnderscore(path, decl);
+      });
+    });
+  };
+}
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;

node_modules/stylelint-scss/dist/rules/at-import-partial-extension-blacklist/index.js

@@ -0,0 +1,72 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = rule;
+exports.ruleName = exports.meta = exports.messages = void 0;
+var _path = _interopRequireDefault(require("path"));
+var _stylelint = require("stylelint");
+var _utils = require("../../utils");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+var ruleName = (0, _utils.namespace)("at-import-partial-extension-blacklist");
+exports.ruleName = ruleName;
+var messages = _stylelint.utils.ruleMessages(ruleName, {
+  rejected: function rejected(ext) {
+    return "Unexpected extension \".".concat(ext, "\" in imported partial name");
+  }
+});
+exports.messages = messages;
+var meta = {
+  url: (0, _utils.ruleUrl)(ruleName)
+};
+exports.meta = meta;
+function rule(blacklistOption) {
+  var blacklist = [].concat(blacklistOption);
+  return function (root, result) {
+    var validOptions = _stylelint.utils.validateOptions(result, ruleName, {
+      actual: blacklistOption,
+      possible: [_utils.isString, _utils.isRegExp]
+    });
+    if (!validOptions) {
+      return;
+    }
+    function checkPathForUnderscore(path, decl) {
+      // Stripping trailing quotes and whitespaces, if any
+      var pathStripped = path.replace(/^\s*(["'])\s*/, "").replace(/\s*(["'])\s*$/, "");
+      var extension = _path["default"].extname(pathStripped).slice(1);
+      // Save this separately to be able to pass the original string to report()
+      var extensionNormalized = extension.toLowerCase();
+
+      // If the extension is empty
+      if (!extension) {
+        return;
+      }
+
+      // Skipping importing CSS: url(), ".css", URI with a protocol, media
+      if (pathStripped.slice(0, 4) === "url(" || pathStripped.slice(-4) === ".css" || pathStripped.search("//") !== -1 || pathStripped.search(/[\s,)"']\w+$/) !== -1) {
+        return;
+      }
+      blacklist.forEach(function (ext) {
+        if ((0, _utils.isString)(ext) && extensionNormalized === ext || (0, _utils.isRegExp)(ext) && extensionNormalized.search(ext) !== -1) {
+          _stylelint.utils.report({
+            message: messages.rejected(extension),
+            node: decl,
+            word: extension,
+            result: result,
+            ruleName: ruleName
+          });
+        }
+      });
+    }
+    root.walkAtRules("import", function (atRule) {
+      // Processing comma-separated lists of import paths
+      atRule.params.split(",").forEach(function (path) {
+        checkPathForUnderscore(path, atRule);
+      });
+    });
+  };
+}
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;

node_modules/stylelint-scss/dist/rules/at-import-partial-extension-whitelist/index.js

@@ -0,0 +1,73 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = rule;
+exports.ruleName = exports.meta = exports.messages = void 0;
+var _path = _interopRequireDefault(require("path"));
+var _stylelint = require("stylelint");
+var _utils = require("../../utils");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+var ruleName = (0, _utils.namespace)("at-import-partial-extension-whitelist");
+exports.ruleName = ruleName;
+var messages = _stylelint.utils.ruleMessages(ruleName, {
+  rejected: function rejected(ext) {
+    return "Unexpected extension \".".concat(ext, "\" in imported partial name");
+  }
+});
+exports.messages = messages;
+var meta = {
+  url: (0, _utils.ruleUrl)(ruleName)
+};
+exports.meta = meta;
+function rule(whitelistOption) {
+  var whitelist = [].concat(whitelistOption);
+  return function (root, result) {
+    var validOptions = _stylelint.utils.validateOptions(result, ruleName, {
+      actual: whitelistOption,
+      possible: [_utils.isString, _utils.isRegExp]
+    });
+    if (!validOptions) {
+      return;
+    }
+    function checkPathForUnderscore(path, decl) {
+      // Stripping trailing quotes and whitespaces, if any
+      var pathStripped = path.replace(/^\s*(["'])\s*/, "").replace(/\s*(["'])\s*$/, "");
+      var extension = _path["default"].extname(pathStripped).slice(1);
+      // Save this separately to be able to pass the original string to report()
+      var extensionNormalized = extension.toLowerCase();
+
+      // If the extension is empty
+      if (!extension) {
+        return;
+      }
+
+      // Skipping importing CSS: url(), ".css", URI with a protocol, media
+      if (pathStripped.slice(0, 4) === "url(" || pathStripped.slice(-4) === ".css" || pathStripped.search("//") !== -1 || pathStripped.search(/[\s,)"']\w+$/) !== -1) {
+        return;
+      }
+      if (whitelist.some(function (ext) {
+        return (0, _utils.isString)(ext) && extensionNormalized === ext || (0, _utils.isRegExp)(ext) && extensionNormalized.search(ext) !== -1;
+      })) {
+        return;
+      }
+      _stylelint.utils.report({
+        message: messages.rejected(extension),
+        node: decl,
+        word: extension,
+        result: result,
+        ruleName: ruleName
+      });
+    }
+    root.walkAtRules("import", function (atRule) {
+      // Processing comma-separated lists of import paths
+      atRule.params.split(",").forEach(function (path) {
+        checkPathForUnderscore(path, atRule);
+      });
+    });
+  };
+}
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;

node_modules/stylelint-scss/dist/rules/at-import-partial-extension/index.js

@@ -0,0 +1,86 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = rule;
+exports.ruleName = exports.meta = exports.messages = void 0;
+var _path = _interopRequireDefault(require("path"));
+var _stylelint = require("stylelint");
+var _utils = require("../../utils");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+var ruleName = (0, _utils.namespace)("at-import-partial-extension");
+exports.ruleName = ruleName;
+var messages = _stylelint.utils.ruleMessages(ruleName, {
+  expected: "Expected @import to have an extension",
+  rejected: function rejected(ext) {
+    return "Unexpected extension \".".concat(ext, "\" in @import");
+  }
+});
+exports.messages = messages;
+var meta = {
+  url: (0, _utils.ruleUrl)(ruleName)
+};
+
+// https://drafts.csswg.org/mediaqueries/#media-types
+exports.meta = meta;
+var mediaQueryTypes = ["all", "print", "screen", "speech", "tv", "tty", "projection", "handheld", "braille", "embossed", "aural"];
+var mediaQueryTypesRE = new RegExp("(".concat(mediaQueryTypes.join("|"), ")$"), "i");
+var stripPath = function stripPath(path) {
+  return path.replace(/^\s*(["'])\s*/, "").replace(/\s*(["'])\s*$/, "");
+};
+function rule(expectation, _, context) {
+  return function (root, result) {
+    var validOptions = _stylelint.utils.validateOptions(result, ruleName, {
+      actual: expectation,
+      possible: ["always", "never"]
+    });
+    if (!validOptions) {
+      return;
+    }
+    root.walkAtRules("import", function (decl) {
+      var paths = decl.params.split(/["']\s*,/).filter(function (path) {
+        return !mediaQueryTypesRE.test(path.trim());
+      });
+
+      // Processing comma-separated lists of import paths
+      paths.forEach(function (path) {
+        // Stripping trailing quotes and whitespaces, if any
+        var pathStripped = stripPath(path);
+
+        // Skipping importing CSS: url(), ".css", URI with a protocol
+        if (pathStripped.slice(0, 4) === "url(" || pathStripped.slice(-4) === ".css" || pathStripped.search("//") !== -1) {
+          return;
+        }
+        var extension = _path["default"].extname(pathStripped).slice(1);
+        if (!extension && expectation === "always") {
+          _stylelint.utils.report({
+            message: messages.expected,
+            node: decl,
+            result: result,
+            ruleName: ruleName
+          });
+          return;
+        }
+        var isScssPartial = extension === "scss";
+        if (extension && isScssPartial && expectation === "never") {
+          if (context.fix) {
+            var extPattern = new RegExp("\\.".concat(extension, "(['\" ]*)$"), "g");
+            decl.params = decl.params.replace(extPattern, "$1");
+            return;
+          }
+          _stylelint.utils.report({
+            message: messages.rejected(extension),
+            node: decl,
+            word: extension,
+            result: result,
+            ruleName: ruleName
+          });
+        }
+      });
+    });
+  };
+}
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;

node_modules/stylelint-scss/dist/rules/at-mixin-argumentless-call-parentheses/index.js

@@ -0,0 +1,64 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = rule;
+exports.ruleName = exports.meta = exports.messages = void 0;
+var _stylelint = require("stylelint");
+var _utils = require("../../utils");
+var ruleName = (0, _utils.namespace)("at-mixin-argumentless-call-parentheses");
+exports.ruleName = ruleName;
+var messages = _stylelint.utils.ruleMessages(ruleName, {
+  expected: function expected(mixin) {
+    return "Expected parentheses in mixin \"".concat(mixin, "\" call");
+  },
+  rejected: function rejected(mixin) {
+    return "Unexpected parentheses in argumentless mixin \"".concat(mixin, "\" call");
+  }
+});
+exports.messages = messages;
+var meta = {
+  url: (0, _utils.ruleUrl)(ruleName)
+};
+exports.meta = meta;
+function rule(value, _, context) {
+  return function (root, result) {
+    var validOptions = _stylelint.utils.validateOptions(result, ruleName, {
+      actual: value,
+      possible: ["always", "never"]
+    });
+    if (!validOptions) {
+      return;
+    }
+    root.walkAtRules("include", function (mixinCall) {
+      // If it is "No parens in argumentless calls"
+      if (value === "never" && mixinCall.params.search(/\(\s*\)\s*$/) === -1) {
+        return;
+      }
+
+      // If it is "Always use parens"
+      if (value === "always" && mixinCall.params.search(/\(/) !== -1) {
+        return;
+      }
+      if (context.fix) {
+        if (value === "always") {
+          mixinCall.params = "".concat(mixinCall.params, " ()");
+        } else {
+          mixinCall.params = mixinCall.params.replace(/\s*\([\s\S]*?\)$/, "");
+        }
+        return;
+      }
+      var mixinName = /\s*(\S*?)\s*(?:\(|$)/.exec(mixinCall.params)[1];
+      _stylelint.utils.report({
+        message: messages[value === "never" ? "rejected" : "expected"](mixinName),
+        node: mixinCall,
+        result: result,
+        ruleName: ruleName
+      });
+    });
+  };
+}
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;

node_modules/stylelint-scss/dist/rules/at-mixin-named-arguments/index.js

@@ -0,0 +1,108 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = rule;
+exports.ruleName = exports.meta = exports.messages = void 0;
+var _stylelint = require("stylelint");
+var _utils = require("../../utils");
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+var ruleName = (0, _utils.namespace)("at-mixin-named-arguments");
+exports.ruleName = ruleName;
+var messages = _stylelint.utils.ruleMessages(ruleName, {
+  expected: "Expected a named parameter to be used in at-include call",
+  rejected: "Unexpected a named parameter in at-include call"
+});
+exports.messages = messages;
+var meta = {
+  url: (0, _utils.ruleUrl)(ruleName)
+};
+exports.meta = meta;
+var hasArgumentsRegExp = /\((.*)\)$/;
+var isScssVarRegExp = /^\$\S*/;
+function rule(expectation, options) {
+  return function (root, result) {
+    var validOptions = _stylelint.utils.validateOptions(result, ruleName, {
+      actual: expectation,
+      possible: ["always", "never"]
+    }, {
+      actual: options,
+      possible: {
+        ignore: ["single-argument"]
+      },
+      optional: true
+    });
+    if (!validOptions) {
+      return;
+    }
+    var shouldIgnoreSingleArgument = (0, _utils.optionsHaveIgnored)(options, "single-argument");
+    root.walkAtRules("include", function (atRule) {
+      var argsString = atRule.params.replace(/\n/g, " ").match(hasArgumentsRegExp);
+
+      // Ignore @include that does not contain arguments.
+      if (!argsString || argsString.index === -1 || argsString[0].length === 2) {
+        return;
+      }
+      var args = argsString[1]
+      // Create array of arguments.
+      .split(",")
+      // Create a key-value array for every argument.
+      .map(function (argsString) {
+        return argsString.split(":").map(function (argsKeyValuePair) {
+          return argsKeyValuePair.trim();
+        });
+      }).reduce(function (resultArray, keyValuePair) {
+        var pair = {
+          value: keyValuePair[1] || keyValuePair[0]
+        };
+        if (keyValuePair[1]) {
+          pair.key = keyValuePair[0];
+        }
+        return [].concat(_toConsumableArray(resultArray), [pair]);
+      }, []);
+      var isSingleArgument = args.length === 1;
+      if (isSingleArgument && shouldIgnoreSingleArgument) {
+        return;
+      }
+      args.forEach(function (arg) {
+        switch (expectation) {
+          case "never":
+            {
+              if (!arg.key) {
+                return;
+              }
+              _stylelint.utils.report({
+                message: messages.rejected,
+                node: atRule,
+                result: result,
+                ruleName: ruleName
+              });
+              break;
+            }
+          case "always":
+            {
+              if (arg.key && isScssVarRegExp.test(arg.key)) {
+                return;
+              }
+              _stylelint.utils.report({
+                message: messages.expected,
+                node: atRule,
+                result: result,
+                ruleName: ruleName
+              });
+              break;
+            }
+        }
+      });
+    });
+  };
+}
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;

node_modules/stylelint-scss/dist/rules/at-mixin-parentheses-space-before/index.js

@@ -0,0 +1,59 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = rule;
+exports.ruleName = exports.meta = exports.messages = void 0;
+var _stylelint = require("stylelint");
+var _utils = require("../../utils");
+var ruleName = (0, _utils.namespace)("at-mixin-parentheses-space-before");
+exports.ruleName = ruleName;
+var messages = _stylelint.utils.ruleMessages(ruleName, {
+  rejectedBefore: function rejectedBefore() {
+    return "Unexpected whitespace before parentheses in mixin declaration";
+  },
+  expectedBefore: function expectedBefore() {
+    return "Expected a single space before parentheses in mixin declaration";
+  }
+});
+exports.messages = messages;
+var meta = {
+  url: (0, _utils.ruleUrl)(ruleName)
+};
+exports.meta = meta;
+function rule(value, _, context) {
+  return function (root, result) {
+    var validOptions = _stylelint.utils.validateOptions(result, ruleName, {
+      actual: value,
+      possible: ["always", "never"]
+    });
+    if (!validOptions) {
+      return;
+    }
+    var match = /^([\w-]+)\s*\(/;
+    var replacement = value === "always" ? "$1 (" : "$1(";
+    var checker = (0, _utils.whitespaceChecker)("space", value, messages).before;
+    root.walkAtRules("mixin", function (decl) {
+      if (context.fix) {
+        decl.params = decl.params.replace(match, replacement);
+        return;
+      }
+      checker({
+        source: decl.params,
+        index: decl.params.indexOf("("),
+        err: function err(message) {
+          return _stylelint.utils.report({
+            message: message,
+            node: decl,
+            result: result,
+            ruleName: ruleName
+          });
+        }
+      });
+    });
+  };
+}
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;

node_modules/stylelint-scss/dist/rules/at-mixin-pattern/index.js

@@ -0,0 +1,55 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = rule;
+exports.ruleName = exports.meta = exports.messages = void 0;
+var _stylelint = require("stylelint");
+var _utils = require("../../utils");
+var ruleName = (0, _utils.namespace)("at-mixin-pattern");
+exports.ruleName = ruleName;
+var messages = _stylelint.utils.ruleMessages(ruleName, {
+  expected: "Expected @mixin name to match specified pattern"
+});
+exports.messages = messages;
+var meta = {
+  url: (0, _utils.ruleUrl)(ruleName)
+};
+exports.meta = meta;
+function rule(pattern) {
+  return function (root, result) {
+    var validOptions = _stylelint.utils.validateOptions(result, ruleName, {
+      actual: pattern,
+      possible: [_utils.isRegExp, _utils.isString]
+    });
+    if (!validOptions) {
+      return;
+    }
+    var regexpPattern = (0, _utils.isString)(pattern) ? new RegExp(pattern) : pattern;
+    root.walkAtRules(function (decl) {
+      if (decl.name !== "mixin") {
+        return;
+      }
+
+      // Stripping the mixin of its arguments
+      var mixinName = decl.params.replace(/(\s*)\([\s\S]*\)/g, "");
+      if (regexpPattern.test(mixinName)) {
+        return;
+      }
+      var mixinTopLine = Object.assign({}, decl.source.start);
+      mixinTopLine.line += 1;
+      mixinTopLine.column = 0;
+      _stylelint.utils.report({
+        message: messages.expected,
+        node: decl,
+        result: result,
+        ruleName: ruleName,
+        end: mixinTopLine
+      });
+    });
+  };
+}
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;

node_modules/stylelint-scss/dist/rules/at-rule-conditional-no-parentheses/index.js

@@ -0,0 +1,83 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = rule;
+exports.ruleName = exports.meta = exports.messages = void 0;
+var _stylelint = require("stylelint");
+var _utils = require("../../utils");
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+var ruleName = (0, _utils.namespace)("at-rule-conditional-no-parentheses");
+exports.ruleName = ruleName;
+var messages = _stylelint.utils.ruleMessages(ruleName, {
+  rejected: "Unexpected () used to surround statements for @-rules"
+});
+exports.messages = messages;
+var meta = {
+  url: (0, _utils.ruleUrl)(ruleName)
+};
+
+// postcss picks up else-if as else.
+exports.meta = meta;
+var conditional_rules = ["if", "while", "else"];
+function report(atrule, result) {
+  _stylelint.utils.report({
+    message: messages.rejected,
+    node: atrule,
+    result: result,
+    ruleName: ruleName
+  });
+}
+function fix(atrule) {
+  var regex = /(if)? ?\((.*)\)/;
+
+  // 2 regex groups: 'if ' and cond.
+  var groups = atrule.params.match(regex).slice(1);
+  atrule.params = _toConsumableArray(new Set(groups)).join(" ");
+}
+function rule(primary, _unused, context) {
+  return function (root, result) {
+    var validOptions = _stylelint.utils.validateOptions(result, ruleName, {
+      actual: primary
+    });
+    if (!validOptions) {
+      return;
+    }
+    root.walkAtRules(function (atrule) {
+      // Check if this is a conditional rule.
+      if (!conditional_rules.includes(atrule.name)) {
+        return;
+      }
+
+      // Else uses a different regex
+      // params are of format "`if (cond)` or `if cond`
+      // instead of `(cond)` or `cond`"
+      if (atrule.name === "else") {
+        if (atrule.params.match(/ ?if ?\(.*\) ?$/)) {
+          if (context.fix) {
+            fix(atrule);
+          } else {
+            report(atrule, result);
+          }
+        }
+      } else {
+        if (atrule.params.trim().match(/^\(.*\)$/)) {
+          if (context.fix) {
+            fix(atrule);
+          } else {
+            report(atrule, result);
+          }
+        }
+      }
+    });
+  };
+}
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;

node_modules/stylelint-scss/dist/rules/at-rule-no-unknown/index.js

@@ -0,0 +1,71 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = rule;
+exports.ruleName = exports.meta = exports.messages = void 0;
+var _stylelint = require("stylelint");
+var _utils = require("../../utils");
+var sassAtRules = ["at-root", "content", "debug", "each", "else", "else if", "error", "extend", "for", "forward", "function", "if", "import", "include", "media", "mixin", "return", "use", "warn", "while"];
+var ruleToCheckAgainst = "at-rule-no-unknown";
+var ruleName = (0, _utils.namespace)(ruleToCheckAgainst);
+exports.ruleName = ruleName;
+var messages = _stylelint.utils.ruleMessages(ruleName, {
+  rejected: function rejected() {
+    var _rules$ruleToCheckAga;
+    return (_rules$ruleToCheckAga = _stylelint.rules[ruleToCheckAgainst].messages).rejected.apply(_rules$ruleToCheckAga, arguments).replace(" (".concat(ruleToCheckAgainst, ")"), "");
+  }
+});
+exports.messages = messages;
+var meta = {
+  url: (0, _utils.ruleUrl)(ruleName)
+};
+exports.meta = meta;
+function rule(primaryOption, secondaryOptions) {
+  return function (root, result) {
+    var validOptions = _stylelint.utils.validateOptions(result, ruleName, {
+      actual: primaryOption
+    }, {
+      actual: secondaryOptions,
+      possible: {
+        ignoreAtRules: [_utils.isRegExp, _utils.isString]
+      },
+      optional: true
+    });
+    if (!validOptions) {
+      return;
+    }
+    var optionsAtRules = secondaryOptions && secondaryOptions.ignoreAtRules;
+    var ignoreAtRules = sassAtRules.concat(optionsAtRules || []);
+    var defaultedOptions = Object.assign({}, secondaryOptions, {
+      ignoreAtRules: ignoreAtRules
+    });
+    _stylelint.utils.checkAgainstRule({
+      ruleName: ruleToCheckAgainst,
+      ruleSettings: [primaryOption, defaultedOptions],
+      root: root
+    }, function (warning) {
+      var name = warning.node.name;
+      if (!ignoreAtRules.includes(name)) {
+        _stylelint.utils.report({
+          message: messages.rejected("@".concat(name)),
+          ruleName: ruleName,
+          result: result,
+          node: warning.node,
+          start: {
+            line: warning.line,
+            column: warning.column
+          },
+          end: {
+            line: warning.endLine,
+            column: warning.endColumn
+          }
+        });
+      }
+    });
+  };
+}
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;

node_modules/stylelint-scss/dist/rules/at-use-no-unnamespaced/index.js

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = rule;
+exports.ruleName = exports.meta = exports.messages = void 0;
+var _stylelint = require("stylelint");
+var _utils = require("../../utils");
+var ruleName = (0, _utils.namespace)("at-use-no-unnamespaced");
+exports.ruleName = ruleName;
+var messages = _stylelint.utils.ruleMessages(ruleName, {
+  rejected: "Unexpected @use without namespace"
+});
+exports.messages = messages;
+var meta = {
+  url: (0, _utils.ruleUrl)(ruleName)
+};
+exports.meta = meta;
+function rule(actual) {
+  return function (root, result) {
+    var validOptions = _stylelint.utils.validateOptions(result, ruleName, {
+      actual: actual
+    });
+    if (!validOptions) {
+      return;
+    }
+    root.walkAtRules("use", function (decl) {
+      if (/as\s*\*\s*(?:$|with\s*\()/.test(decl.params)) {
+        _stylelint.utils.report({
+          message: messages.rejected,
+          node: decl,
+          result: result,
+          ruleName: ruleName
+        });
+      }
+    });
+  };
+}
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;

node_modules/stylelint-scss/dist/rules/comment-no-empty/index.js

@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = rule;
+exports.ruleName = exports.meta = exports.messages = void 0;
+var _stylelint = require("stylelint");
+var _utils = require("../../utils");
+var coreRuleName = "comment-no-empty";
+var ruleName = (0, _utils.namespace)(coreRuleName);
+exports.ruleName = ruleName;
+var messages = _stylelint.utils.ruleMessages(ruleName, {
+  rejected: _stylelint.rules[coreRuleName].messages.rejected.replace(" (".concat(coreRuleName, ")"), "")
+});
+exports.messages = messages;
+var meta = {
+  url: (0, _utils.ruleUrl)(ruleName)
+};
+exports.meta = meta;
+function rule(primary) {
+  return function (root, result) {
+    var validOptions = _stylelint.utils.validateOptions(result, ruleName, {
+      actual: primary
+    });
+    if (!validOptions) {
+      return;
+    }
+    root.walkComments(function (comment) {
+      if (isEmptyComment(comment)) {
+        _stylelint.utils.report({
+          message: messages.rejected,
+          node: comment,
+          result: result,
+          ruleName: ruleName
+        });
+      }
+    });
+  };
+}
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+function isEmptyComment(comment) {
+  return comment.text === "";
+}

node_modules/stylelint-scss/dist/rules/comment-no-loud/index.js

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = rule;
+exports.ruleName = exports.meta = exports.messages = void 0;
+var _stylelint = require("stylelint");
+var _utils = require("../../utils");
+var ruleName = (0, _utils.namespace)("comment-no-loud");
+exports.ruleName = ruleName;
+var messages = _stylelint.utils.ruleMessages(ruleName, {
+  expected: "Expected // for comments instead of /*"
+});
+exports.messages = messages;
+var meta = {
+  url: (0, _utils.ruleUrl)(ruleName)
+};
+exports.meta = meta;
+function rule(primary) {
+  return function (root, result) {
+    var validOptions = _stylelint.utils.validateOptions(result, ruleName, {
+      actual: primary
+    });
+    if (!validOptions) {
+      return;
+    }
+    root.walkComments(function (comment) {
+      if (isLoudComment(comment)) {
+        _stylelint.utils.report({
+          message: messages.expected,
+          node: comment,
+          result: result,
+          ruleName: ruleName
+        });
+      }
+    });
+  };
+}
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+function isLoudComment(comment) {
+  var regex = new RegExp(/^[ \t\n]*\/\*/);
+  var splitComment = comment.source.input.css.split("\n");
+  var commentFirstLine = splitComment[comment.source.start.line - 1];
+  return regex.test(commentFirstLine);
+}

node_modules/stylelint-scss/dist/rules/declaration-nested-properties-no-divided-groups/index.js

@@ -0,0 +1,70 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = rule;
+exports.ruleName = exports.meta = exports.messages = void 0;
+var _stylelint = require("stylelint");
+var _utils = require("../../utils");
+var hasOwnProp = Object.prototype.hasOwnProperty;
+var ruleName = (0, _utils.namespace)("declaration-nested-properties-no-divided-groups");
+exports.ruleName = ruleName;
+var messages = _stylelint.utils.ruleMessages(ruleName, {
+  expected: function expected(prop) {
+    return "Expected all nested properties of \"".concat(prop, "\" namespace to be in one nested group");
+  }
+});
+exports.messages = messages;
+var meta = {
+  url: (0, _utils.ruleUrl)(ruleName)
+};
+exports.meta = meta;
+function rule(expectation) {
+  return function (root, result) {
+    var validOptions = _stylelint.utils.validateOptions(result, ruleName, {
+      actual: expectation
+    });
+    if (!validOptions) {
+      return;
+    }
+    root.walk(function (item) {
+      if (item.type !== "rule" && item.type !== "atrule") {
+        return;
+      }
+      var nestedGroups = {};
+
+      // Find all nested property groups
+      item.each(function (decl) {
+        if (decl.type !== "rule") {
+          return;
+        }
+        var testForProp = (0, _utils.parseNestedPropRoot)(decl.selector);
+        if (testForProp && testForProp.propName !== undefined) {
+          var ns = testForProp.propName.value;
+          if (!hasOwnProp.call(nestedGroups, ns)) {
+            nestedGroups[ns] = [];
+          }
+          nestedGroups[ns].push(decl);
+        }
+      });
+      Object.keys(nestedGroups).forEach(function (namespace) {
+        // Only warn if there are more than one nested groups with equal namespaces
+        if (nestedGroups[namespace].length === 1) {
+          return;
+        }
+        nestedGroups[namespace].forEach(function (group) {
+          _stylelint.utils.report({
+            message: messages.expected(namespace),
+            node: group,
+            result: result,
+            ruleName: ruleName
+          });
+        });
+      });
+    });
+  };
+}
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;

node_modules/stylelint-scss/dist/rules/declaration-nested-properties/index.js

@@ -0,0 +1,146 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = rule;
+exports.ruleName = exports.meta = exports.messages = void 0;
+var _stylelint = require("stylelint");
+var _utils = require("../../utils");
+var hasOwnProp = Object.prototype.hasOwnProperty;
+var ruleName = (0, _utils.namespace)("declaration-nested-properties");
+exports.ruleName = ruleName;
+var messages = _stylelint.utils.ruleMessages(ruleName, {
+  expected: function expected(prop) {
+    return "Expected property \"".concat(prop, "\" to be in a nested form");
+  },
+  rejected: function rejected(prop) {
+    return "Unexpected nested property \"".concat(prop, "\"");
+  }
+});
+exports.messages = messages;
+var meta = {
+  url: (0, _utils.ruleUrl)(ruleName)
+};
+exports.meta = meta;
+function rule(expectation, options) {
+  return function (root, result) {
+    var validOptions = _stylelint.utils.validateOptions(result, ruleName, {
+      actual: expectation,
+      possible: ["always", "never"]
+    }, {
+      actual: options,
+      possible: {
+        except: ["only-of-namespace"]
+      },
+      optional: true
+    });
+    if (!validOptions) {
+      return;
+    }
+    if (expectation === "always") {
+      root.walk(function (item) {
+        if (item.type !== "rule" && item.type !== "atrule") {
+          return;
+        }
+        var warningCandidates = {};
+        item.each(function (decl) {
+          var prop = decl.prop,
+            type = decl.type,
+            selector = decl.selector;
+
+          // Looking for namespaced non-nested properties
+          // Namespaced prop is basically a prop with a `-` in a name, e.g. `margin-top`
+          if (type === "decl") {
+            if (!(0, _utils.isStandardSyntaxProperty)(prop)) {
+              return;
+            }
+
+            // Add simple namespaced prop decls to warningCandidates.ns
+            // (prop names with browser prefixes are ignored)
+            var seekNamespace = /^([a-zA-Z\d]+)-/.exec(prop);
+            if (seekNamespace && seekNamespace[1]) {
+              var ns = seekNamespace[1];
+              if (!hasOwnProp.call(warningCandidates, ns)) {
+                warningCandidates[ns] = [];
+              }
+              warningCandidates[ns].push({
+                node: decl
+              });
+            }
+          }
+
+          // Nested props, `prop: [value] { <nested decls> }`
+          if (type === "rule" || type === "decl" && decl.isNested) {
+            // `background:red {` - selector;
+            // `background: red {` - nested prop; space is decisive here
+            var testForProp = (0, _utils.parseNestedPropRoot)(selector || decl.toString());
+            if (testForProp && testForProp.propName !== undefined) {
+              var _ns = testForProp.propName.value;
+              if (!hasOwnProp.call(warningCandidates, _ns)) {
+                warningCandidates[_ns] = [];
+              }
+              warningCandidates[_ns].push({
+                node: decl,
+                nested: true
+              });
+            }
+          }
+        });
+
+        // Now check if the found properties deserve warnings
+        Object.keys(warningCandidates).forEach(function (namespace) {
+          var exceptIfOnlyOfNs = (0, _utils.optionsHaveException)(options, "only-of-namespace");
+          var moreThanOneProp = warningCandidates[namespace].length > 1;
+          warningCandidates[namespace].forEach(function (candidate) {
+            if (candidate.nested === true) {
+              if (exceptIfOnlyOfNs) {
+                // If there is only one prop inside a nested prop - warn (reverse "always")
+                if (candidate.nested === true && candidate.node.nodes.length === 1) {
+                  _stylelint.utils.report({
+                    message: messages.rejected(namespace),
+                    node: candidate.node,
+                    result: result,
+                    ruleName: ruleName
+                  });
+                }
+              }
+            } else {
+              // Don't warn on non-nested namespaced props if there are
+              // less than 2 of them, and except: "only-of-namespace" is set
+              if (exceptIfOnlyOfNs && !moreThanOneProp) {
+                return;
+              }
+              _stylelint.utils.report({
+                message: messages.expected(candidate.node.prop),
+                node: candidate.node,
+                result: result,
+                ruleName: ruleName
+              });
+            }
+          });
+        });
+      });
+    } else if (expectation === "never") {
+      root.walk(function (item) {
+        // Just check if there are ANY nested props
+        if (item.type === "rule") {
+          // `background:red {` - selector;
+          // `background: red {` - nested prop; space is decisive here
+          var testForProp = (0, _utils.parseNestedPropRoot)(item.selector);
+          if (testForProp && testForProp.propName !== undefined) {
+            _stylelint.utils.report({
+              message: messages.rejected(testForProp.propName.value),
+              result: result,
+              ruleName: ruleName,
+              node: item
+            });
+          }
+        }
+      });
+    }
+  };
+}
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;

node_modules/stylelint-scss/dist/rules/dimension-no-non-numeric-values/index.js

@@ -0,0 +1,105 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = rule;
+exports.units = exports.ruleName = exports.meta = exports.messages = void 0;
+var _postcssValueParser = _interopRequireDefault(require("postcss-value-parser"));
+var _stylelint = require("stylelint");
+var _utils = require("../../utils");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+var ruleName = (0, _utils.namespace)("dimension-no-non-numeric-values");
+exports.ruleName = ruleName;
+var messages = _stylelint.utils.ruleMessages(ruleName, {
+  rejected: function rejected(unit) {
+    return "Expected \"$value * 1".concat(unit, "\" instead of \"#{$value}").concat(unit, "\". Consider writing \"value\" in terms of ").concat(unit, " originally.");
+  }
+});
+exports.messages = messages;
+var meta = {
+  url: (0, _utils.ruleUrl)(ruleName)
+};
+exports.meta = meta;
+var units = [
+// Font-relative lengths:
+// https://www.w3.org/TR/css-values-4/#font-relative-lengths
+"em", "ex", "cap", "ch", "ic", "rem", "lh", "rlh",
+// Viewport-relative lengths:
+// https://www.w3.org/TR/css-values-4/#viewport-relative-lengths
+"vw", "vh", "vi", "vb", "vmin", "vmax",
+// Absolute lengths:
+// https://www.w3.org/TR/css-values-4/#absolute-lengths
+"cm", "mm", "Q", "in", "pc", "pt", "px",
+// Angle units:
+// https://www.w3.org/TR/css-values-4/#angles
+"deg", "grad", "rad", "turn",
+// Duration units:
+// https://www.w3.org/TR/css-values-4/#time
+"s", "ms",
+// Frequency units:
+// https://www.w3.org/TR/css-values-4/#frequency
+"Hz", "kHz",
+// Resolution units:
+// https://www.w3.org/TR/css-values-4/#resolution
+"dpi", "dpcm", "dppx", "x",
+// Flexible lengths:
+// https://www.w3.org/TR/css-grid-1/#fr-unit
+"fr"];
+exports.units = units;
+function rule(primary) {
+  return function (root, result) {
+    var validOptions = _stylelint.utils.validateOptions(result, ruleName, {
+      actual: primary
+    });
+    if (!validOptions) {
+      return;
+    }
+    root.walkDecls(function (decl) {
+      (0, _postcssValueParser["default"])(decl.value).walk(function (node) {
+        // All words are non-quoted, while strings are quoted.
+        // If quoted, it's probably a deliberate non-numeric dimension.
+        if (node.type !== "word") {
+          return;
+        }
+        if (!isInterpolated(node.value)) {
+          return;
+        }
+        var regex = new RegExp("#{[$a-z_0-9 +-]*}(".concat(units.join("|"), ");?"));
+        var matchUnit = decl.value.match(regex);
+        if (!matchUnit) {
+          return;
+        }
+        var unit = matchUnit[1];
+        var offset = decl.value.indexOf(unit);
+        _stylelint.utils.report({
+          ruleName: ruleName,
+          result: result,
+          message: messages.rejected(unit),
+          index: (0, _utils.declarationValueIndex)(decl) + offset,
+          node: decl
+        });
+      });
+    });
+  };
+}
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+function isInterpolated(value) {
+  var _boolean = false;
+
+  // ValueParser breaks up interpolation with math into multiple, fragmented
+  // segments (#{$value, +, 2}px). The easiest way to detect this is to look for a fragmented
+  // interpolated section.
+  if (value.match(/^#{\$[a-z]*$/)) {
+    return true;
+  }
+  units.forEach(function (unit) {
+    var regex = new RegExp("^#{[$a-z_0-9 +-]*}".concat(unit, ";?$"));
+    if (value.match(regex)) {
+      _boolean = true;
+    }
+  });
+  return _boolean;
+}

node_modules/stylelint-scss/dist/rules/dollar-variable-colon-newline-after/index.js

@@ -0,0 +1,97 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = rule;
+exports.ruleName = exports.meta = exports.messages = void 0;
+var _stylelint = require("stylelint");
+var _utils = require("../../utils");
+var ruleName = (0, _utils.namespace)("dollar-variable-colon-newline-after");
+exports.ruleName = ruleName;
+var messages = _stylelint.utils.ruleMessages(ruleName, {
+  expectedAfter: function expectedAfter() {
+    return 'Expected newline after ":"';
+  },
+  expectedAfterMultiLine: function expectedAfterMultiLine() {
+    return 'Expected newline after ":" with a multi-line value';
+  }
+});
+exports.messages = messages;
+var meta = {
+  url: (0, _utils.ruleUrl)(ruleName)
+};
+exports.meta = meta;
+function rule(expectation, options, context) {
+  var checker = (0, _utils.whitespaceChecker)("newline", expectation, messages);
+  return function (root, result) {
+    var validOptions = _stylelint.utils.validateOptions(result, ruleName, {
+      actual: expectation,
+      possible: ["always", "always-multi-line"]
+    }, {
+      actual: options,
+      possible: {
+        disableFix: _utils.isBoolean
+      },
+      optional: true
+    });
+    if (!validOptions) {
+      return;
+    }
+    var shouldFix = context.fix && (!options || options.disableFix !== true);
+    root.walkDecls(function (decl) {
+      if (!decl.prop || decl.prop[0] !== "$") {
+        return;
+      }
+      var value = decl.value.trim();
+      var startsWithParen = value[0] === "(";
+      var endsWithParen = value[value.length - 1] === ")";
+      var endsWithDefault = /\)\s*!default$/.test(value);
+      var isMultilineVarWithParens = startsWithParen && (endsWithParen || endsWithDefault) && !(0, _utils.isSingleLineString)(value);
+      if (isMultilineVarWithParens) {
+        return;
+      }
+
+      // Get the raw $var, and only that
+      var endOfPropIndex = (0, _utils.declarationValueIndex)(decl) + decl.raw("between").length - 1;
+      // `$var:`, `$var :`
+      var propPlusColon = decl.toString().slice(0, endOfPropIndex);
+      var _loop = function _loop() {
+        if (propPlusColon[i] !== ":") {
+          return "continue";
+        }
+        var indexToCheck = propPlusColon.substr(propPlusColon[i], 3) === "/*" ? propPlusColon.indexOf("*/", i) + 1 : i;
+        checker.afterOneOnly({
+          source: propPlusColon,
+          index: indexToCheck,
+          lineCheckStr: decl.value,
+          err: function err(m) {
+            if (shouldFix) {
+              var nextLinePrefix = expectation === "always" ? decl.raws.before.replace(context.newline, "") : decl.value.split(context.newline)[1].replace(/^(\s+).*$/, function (_, whitespace) {
+                return whitespace;
+              });
+              decl.raws.between = decl.raws.between.replace(/:(.*)$/, ":".concat(context.newline).concat(nextLinePrefix));
+              return;
+            }
+            _stylelint.utils.report({
+              message: m,
+              node: decl,
+              index: indexToCheck,
+              result: result,
+              ruleName: ruleName
+            });
+          }
+        });
+        return "break";
+      };
+      for (var i = 0, l = propPlusColon.length; i < l; i++) {
+        var _ret = _loop();
+        if (_ret === "continue") continue;
+        if (_ret === "break") break;
+      }
+    });
+  };
+}
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;

node_modules/stylelint-scss/dist/rules/dollar-variable-colon-space-after/index.js

@@ -0,0 +1,113 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = rule;
+exports.ruleName = exports.meta = exports.messages = void 0;
+exports.variableColonSpaceChecker = variableColonSpaceChecker;
+var _utils = require("../../utils");
+var _stylelint = require("stylelint");
+var ruleName = (0, _utils.namespace)("dollar-variable-colon-space-after");
+exports.ruleName = ruleName;
+var messages = _stylelint.utils.ruleMessages(ruleName, {
+  expectedAfter: function expectedAfter() {
+    return 'Expected single space after ":"';
+  },
+  rejectedAfter: function rejectedAfter() {
+    return 'Unexpected whitespace after ":"';
+  },
+  expectedAfterSingleLine: function expectedAfterSingleLine() {
+    return 'Expected single space after ":" with a single-line value';
+  },
+  expectedAfterAtLeast: function expectedAfterAtLeast() {
+    return 'Expected at least one space after ":"';
+  }
+});
+exports.messages = messages;
+var meta = {
+  url: (0, _utils.ruleUrl)(ruleName)
+};
+exports.meta = meta;
+function rule(expectation, _, context) {
+  var checker = (0, _utils.whitespaceChecker)("space", expectation, messages);
+  return function (root, result) {
+    var validOptions = _stylelint.utils.validateOptions(result, ruleName, {
+      actual: expectation,
+      possible: ["always", "never", "always-single-line", "at-least-one-space"]
+    });
+    if (!validOptions) {
+      return;
+    }
+    variableColonSpaceChecker({
+      root: root,
+      result: result,
+      locationChecker: checker.after,
+      checkedRuleName: ruleName,
+      position: "after",
+      expectation: expectation,
+      context: context
+    });
+  };
+}
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+function variableColonSpaceChecker(_ref) {
+  var locationChecker = _ref.locationChecker,
+    root = _ref.root,
+    result = _ref.result,
+    checkedRuleName = _ref.checkedRuleName,
+    position = _ref.position,
+    expectation = _ref.expectation,
+    context = _ref.context;
+  root.walkDecls(function (decl) {
+    if (decl.prop === undefined || decl.prop[0] !== "$") {
+      return;
+    }
+    if (context && context.fix) {
+      if (expectation === "always-single-line" && !(0, _utils.isSingleLineString)(decl.value)) {
+        return;
+      }
+      if (position === "before") {
+        var replacement = expectation === "never" ? ":" : " :";
+        decl.raws.between = decl.raws.between.replace(/\s*:/, replacement);
+      } else if (position === "after") {
+        var match = expectation === "at-least-one-space" ? /:(?! )/ : /:\s*/;
+        var _replacement = expectation === "never" ? ":" : ": ";
+        decl.raws.between = decl.raws.between.replace(match, _replacement);
+      }
+      return;
+    }
+
+    // Get the raw $var, and only that
+    var endOfPropIndex = (0, _utils.declarationValueIndex)(decl) + decl.raw("between").length - 1;
+    // `$var:`, `$var :`
+    var propPlusColon = decl.toString().slice(0, endOfPropIndex);
+    var _loop = function _loop(i) {
+      if (propPlusColon[i] !== ":") {
+        return "continue";
+      }
+      locationChecker({
+        source: propPlusColon,
+        index: i,
+        lineCheckStr: decl.value,
+        err: function err(m) {
+          _stylelint.utils.report({
+            message: m,
+            node: decl,
+            index: i,
+            result: result,
+            ruleName: checkedRuleName
+          });
+        }
+      });
+      return "break";
+    };
+    for (var i = 0; i < propPlusColon.length; i++) {
+      var _ret = _loop(i);
+      if (_ret === "continue") continue;
+      if (_ret === "break") break;
+    }
+  });
+}

node_modules/stylelint-scss/dist/rules/dollar-variable-colon-space-before/index.js

@@ -0,0 +1,49 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = rule;
+exports.ruleName = exports.meta = exports.messages = void 0;
+var _utils = require("../../utils");
+var _stylelint = require("stylelint");
+var _dollarVariableColonSpaceAfter = require("../dollar-variable-colon-space-after");
+var ruleName = (0, _utils.namespace)("dollar-variable-colon-space-before");
+exports.ruleName = ruleName;
+var messages = _stylelint.utils.ruleMessages(ruleName, {
+  expectedBefore: function expectedBefore() {
+    return 'Expected single space before ":"';
+  },
+  rejectedBefore: function rejectedBefore() {
+    return 'Unexpected whitespace before ":"';
+  }
+});
+exports.messages = messages;
+var meta = {
+  url: (0, _utils.ruleUrl)(ruleName)
+};
+exports.meta = meta;
+function rule(expectation, _, context) {
+  var checker = (0, _utils.whitespaceChecker)("space", expectation, messages);
+  return function (root, result) {
+    var validOptions = _stylelint.utils.validateOptions(result, ruleName, {
+      actual: expectation,
+      possible: ["always", "never"]
+    });
+    if (!validOptions) {
+      return;
+    }
+    (0, _dollarVariableColonSpaceAfter.variableColonSpaceChecker)({
+      root: root,
+      result: result,
+      locationChecker: checker.before,
+      checkedRuleName: ruleName,
+      position: "before",
+      expectation: expectation,
+      context: context
+    });
+  };
+}
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;

node_modules/stylelint-scss/dist/rules/dollar-variable-default/index.js

@@ -0,0 +1,60 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = rule;
+exports.ruleName = exports.meta = exports.messages = void 0;
+var _stylelint = require("stylelint");
+var _utils = require("../../utils");
+var ruleName = (0, _utils.namespace)("dollar-variable-default");
+exports.ruleName = ruleName;
+var messages = _stylelint.utils.ruleMessages(ruleName, {
+  expected: function expected(variable) {
+    return "Expected !default flag for \"".concat(variable, "\"");
+  }
+});
+exports.messages = messages;
+var meta = {
+  url: (0, _utils.ruleUrl)(ruleName)
+};
+exports.meta = meta;
+function rule(primaryOption, secondaryOptions) {
+  return function (root, result) {
+    var validOptions = _stylelint.utils.validateOptions(result, ruleName, {
+      actual: primaryOption
+    }, {
+      actual: secondaryOptions,
+      possible: {
+        ignore: ["local"]
+      },
+      optional: true
+    });
+    if (!validOptions) {
+      return;
+    }
+    root.walkDecls(function (decl) {
+      // not variable
+      if (decl.prop[0] !== "$") {
+        return;
+      }
+
+      // "ignore" options
+      if ((0, _utils.optionsHaveIgnored)(secondaryOptions, "local") && decl.parent.type !== "root") {
+        return;
+      }
+      if (decl.value.toLowerCase().includes("!default")) {
+        return;
+      }
+      _stylelint.utils.report({
+        message: messages.expected(decl.prop),
+        node: decl,
+        result: result,
+        ruleName: ruleName
+      });
+    });
+  };
+}
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;

node_modules/stylelint-scss/dist/rules/dollar-variable-empty-line-after/index.js

@@ -0,0 +1,150 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = rule;
+exports.ruleName = exports.meta = exports.messages = void 0;
+var _stylelint = require("stylelint");
+var _utils = require("../../utils");
+var ruleName = (0, _utils.namespace)("dollar-variable-empty-line-after");
+exports.ruleName = ruleName;
+var messages = _stylelint.utils.ruleMessages(ruleName, {
+  expected: "Expected an empty line after $-variable",
+  rejected: "Unexpected empty line after $-variable"
+});
+exports.messages = messages;
+var meta = {
+  url: (0, _utils.ruleUrl)(ruleName)
+};
+exports.meta = meta;
+function rule(expectation, options, context) {
+  return function (root, result) {
+    var validOptions = _stylelint.utils.validateOptions(result, ruleName, {
+      actual: expectation,
+      possible: ["always", "never"]
+    }, {
+      actual: options,
+      possible: {
+        except: ["last-nested", "before-comment", "before-dollar-variable"],
+        ignore: ["before-comment", "inside-single-line-block"],
+        disableFix: _utils.isBoolean
+      },
+      optional: true
+    });
+    if (!validOptions) {
+      return;
+    }
+    var fixNext = function fixNext(decl, match, replace) {
+      decl.raws.before = decl.raws.before.replace(new RegExp("^".concat(match)), replace);
+    };
+    var fixParent = function fixParent(decl, match, replace) {
+      decl.parent.raws.after = decl.parent.raws.after.replace(new RegExp("^".concat(match)), replace);
+    };
+    var hasNewline = function hasNewline(str) {
+      return str.indexOf(context.newline) > -1;
+    };
+    var isDollarVar = function isDollarVar(node) {
+      return node.prop && node.prop[0] === "$";
+    };
+    root.walkDecls(function (decl) {
+      var expectEmptyLineAfter = expectation === "always";
+      var exceptLastNested = (0, _utils.optionsHaveException)(options, "last-nested");
+      var exceptBeforeComment = (0, _utils.optionsHaveException)(options, "before-comment");
+      var exceptBeforeVariable = (0, _utils.optionsHaveException)(options, "before-dollar-variable");
+      var ignoreInsideSingleLineBlock = (0, _utils.optionsHaveIgnored)(options, "inside-single-line-block");
+      var ignoreBeforeComment = (0, _utils.optionsHaveIgnored)(options, "before-comment");
+      var isSingleLineDeclaration = (0, _utils.isSingleLineString)((0, _utils.blockString)(decl.parent));
+
+      // Ignore declarations that aren't variables.
+      // ------------------------------------------
+      if (!isDollarVar(decl)) {
+        return;
+      }
+
+      // Ignore declaration if it's the last line in a file.
+      // ---------------------------------------------------
+      if (decl === root.last) {
+        return;
+      }
+
+      // Ignore single line blocks (if chosen as an option).
+      // ---------------------------------------------------
+      if (ignoreInsideSingleLineBlock && decl.parent.type !== "root" && isSingleLineDeclaration) {
+        return;
+      }
+      var next = decl.next();
+
+      // The declaration is the last in a block.
+      // ---------------------------------------
+      if (!next) {
+        var hasEmptyLineAfter = (0, _utils.hasEmptyLine)(decl.parent.raws.after);
+        if (expectEmptyLineAfter && hasEmptyLineAfter && !exceptLastNested || !expectEmptyLineAfter && !hasEmptyLineAfter && !exceptLastNested || expectEmptyLineAfter && !hasEmptyLineAfter && exceptLastNested || !expectEmptyLineAfter && hasEmptyLineAfter && exceptLastNested) {
+          return;
+        }
+      }
+
+      // The declaration is NOT the last in a block.
+      // -------------------------------------------
+      else {
+        var _hasEmptyLineAfter = (0, _utils.hasEmptyLine)(next.raws.before);
+        var nextIsComment = next.type === "comment";
+        var nextIsVariable = isDollarVar(next);
+        if (nextIsComment) {
+          if (ignoreBeforeComment || expectEmptyLineAfter && _hasEmptyLineAfter && !exceptBeforeComment || !expectEmptyLineAfter && !_hasEmptyLineAfter && !exceptBeforeComment || expectEmptyLineAfter && !_hasEmptyLineAfter && exceptBeforeComment || !expectEmptyLineAfter && _hasEmptyLineAfter && exceptBeforeComment) {
+            return;
+          }
+        } else if (nextIsVariable) {
+          if (expectEmptyLineAfter && _hasEmptyLineAfter && !exceptBeforeVariable || !expectEmptyLineAfter && !_hasEmptyLineAfter && !exceptBeforeVariable || expectEmptyLineAfter && !_hasEmptyLineAfter && exceptBeforeVariable || !expectEmptyLineAfter && _hasEmptyLineAfter && exceptBeforeVariable || expectEmptyLineAfter && _hasEmptyLineAfter && exceptBeforeVariable) {
+            return;
+          }
+        } else if (expectEmptyLineAfter === _hasEmptyLineAfter) {
+          return;
+        }
+      }
+      var isFixDisabled = options && options.disableFix === true;
+      if (context.fix && !isFixDisabled) {
+        if (next) {
+          var nextBefore = next.raws.before;
+          var _hasEmptyLineAfter2 = (0, _utils.hasEmptyLine)(nextBefore);
+          var _nextIsComment = next.type === "comment";
+          var _nextIsVariable = isDollarVar(next);
+          if (expectEmptyLineAfter && !_hasEmptyLineAfter2) {
+            fixNext(next, context.newline, context.newline + context.newline);
+            if (exceptLastNested && !hasNewline(nextBefore)) {
+              fixNext(next, "\\s+", context.newline + context.newline);
+            }
+            return;
+          } else if (expectEmptyLineAfter && exceptBeforeComment && _nextIsComment && _hasEmptyLineAfter2 || expectEmptyLineAfter && exceptBeforeVariable && _nextIsVariable && _hasEmptyLineAfter2 || !expectEmptyLineAfter && _hasEmptyLineAfter2) {
+            fixNext(decl, "\\n\\r\\n", "\r\n");
+            fixNext(next, context.newline + context.newline, context.newline);
+            return;
+          } else if (!expectEmptyLineAfter && exceptBeforeComment && _nextIsComment && !_hasEmptyLineAfter2 || !expectEmptyLineAfter && exceptBeforeVariable && _nextIsVariable && !_hasEmptyLineAfter2) {
+            fixNext(next, context.newline, context.newline + context.newline);
+            return;
+          }
+        } else {
+          var _hasEmptyLineAfter3 = (0, _utils.hasEmptyLine)(decl.parent.raws.after);
+          expectEmptyLineAfter = exceptLastNested ? !expectEmptyLineAfter : expectEmptyLineAfter;
+          if (expectEmptyLineAfter && !_hasEmptyLineAfter3) {
+            fixParent(decl, context.newline, context.newline + context.newline);
+            return;
+          } else if (!expectEmptyLineAfter && _hasEmptyLineAfter3) {
+            fixParent(decl, "\\n\\r\\n", "\r\n");
+            fixParent(decl, context.newline + context.newline, context.newline);
+            return;
+          }
+        }
+      }
+      _stylelint.utils.report({
+        message: expectEmptyLineAfter ? messages.expected : messages.rejected,
+        node: decl,
+        result: result,
+        ruleName: ruleName
+      });
+    });
+  };
+}
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;

node_modules/stylelint-scss/dist/rules/dollar-variable-empty-line-before/index.js

@@ -0,0 +1,117 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = rule;
+exports.ruleName = exports.meta = exports.messages = void 0;
+var _stylelint = require("stylelint");
+var _utils = require("../../utils");
+var ruleName = (0, _utils.namespace)("dollar-variable-empty-line-before");
+exports.ruleName = ruleName;
+var messages = _stylelint.utils.ruleMessages(ruleName, {
+  expected: "Expected an empty line before $-variable",
+  rejected: "Unexpected empty line before $-variable"
+});
+exports.messages = messages;
+var meta = {
+  url: (0, _utils.ruleUrl)(ruleName)
+};
+exports.meta = meta;
+function rule(expectation, options, context) {
+  return function (root, result) {
+    var validOptions = _stylelint.utils.validateOptions(result, ruleName, {
+      actual: expectation,
+      possible: ["always", "never"]
+    }, {
+      actual: options,
+      possible: {
+        except: ["first-nested", "after-comment", "after-dollar-variable"],
+        ignore: ["after-comment", "inside-single-line-block", "after-dollar-variable"],
+        disableFix: _utils.isBoolean
+      },
+      optional: true
+    });
+    if (!validOptions) {
+      return;
+    }
+    var fix = function fix(decl, match, replace) {
+      decl.raws.before = decl.raws.before.replace(new RegExp("^".concat(match)), replace);
+    };
+    var hasNewline = function hasNewline(str) {
+      return str.includes(context.newline);
+    };
+    root.walkDecls(function (decl) {
+      if (!isDollarVar(decl)) {
+        return;
+      }
+
+      // Always ignore the first $var in a stylesheet
+      if (decl === root.first) {
+        return;
+      }
+
+      // If ignoring vars after comments is set
+      if ((0, _utils.optionsHaveIgnored)(options, "after-comment") && decl.prev() && decl.prev().type === "comment") {
+        return;
+      }
+
+      // If ignoring single-line blocks
+      if ((0, _utils.optionsHaveIgnored)(options, "inside-single-line-block") && decl.parent.type !== "root" && (0, _utils.isSingleLineString)((0, _utils.blockString)(decl.parent))) {
+        return;
+      }
+
+      // if ignoring after another $-variable
+      if ((0, _utils.optionsHaveIgnored)(options, "after-dollar-variable") && decl.prev() && isDollarVar(decl.prev())) {
+        return;
+      }
+      var expectHasEmptyLineBefore = expectation === "always";
+
+      // Reverse for a variable that is a first child of its parent
+      if ((0, _utils.optionsHaveException)(options, "first-nested") && decl === decl.parent.first) {
+        expectHasEmptyLineBefore = !expectHasEmptyLineBefore;
+      }
+
+      // Reverse if after a comment
+      if ((0, _utils.optionsHaveException)(options, "after-comment") && decl.prev() && decl.prev().type === "comment") {
+        expectHasEmptyLineBefore = !expectHasEmptyLineBefore;
+      }
+
+      // Reverse if after another $-variable
+      if ((0, _utils.optionsHaveException)(options, "after-dollar-variable") && decl.prev() && isDollarVar(decl.prev())) {
+        expectHasEmptyLineBefore = !expectHasEmptyLineBefore;
+      }
+      var before = decl.raws.before;
+      if (expectHasEmptyLineBefore === (0, _utils.hasEmptyLine)(before)) {
+        return;
+      }
+      var isFixDisabled = options && options.disableFix === true;
+      if (context.fix && !isFixDisabled) {
+        if (expectHasEmptyLineBefore && !(0, _utils.hasEmptyLine)(before)) {
+          fix(decl, context.newline, context.newline + context.newline);
+          if ((0, _utils.optionsHaveException)(options, "first-nested") && !hasNewline(before)) {
+            fix(decl, "\\s+", context.newline + context.newline);
+          }
+          return;
+        }
+        if (!expectHasEmptyLineBefore && (0, _utils.hasEmptyLine)(before)) {
+          fix(decl, "\\n\\r\\n", "\r\n");
+          fix(decl, context.newline + context.newline, context.newline);
+          return;
+        }
+      }
+      _stylelint.utils.report({
+        message: expectHasEmptyLineBefore ? messages.expected : messages.rejected,
+        node: decl,
+        result: result,
+        ruleName: ruleName
+      });
+    });
+  };
+}
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+function isDollarVar(node) {
+  return node.prop && node.prop[0] === "$";
+}

node_modules/stylelint-scss/dist/rules/dollar-variable-first-in-block/index.js

@@ -0,0 +1,105 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = rule;
+exports.ruleName = exports.meta = exports.messages = void 0;
+var _utils = require("../../utils");
+var _stylelint = require("stylelint");
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+var ruleName = (0, _utils.namespace)("dollar-variable-first-in-block");
+exports.ruleName = ruleName;
+var messages = _stylelint.utils.ruleMessages(ruleName, {
+  expected: "Expected $-variable to be first in block"
+});
+exports.messages = messages;
+var meta = {
+  url: (0, _utils.ruleUrl)(ruleName)
+};
+exports.meta = meta;
+function rule(primary, options) {
+  return function (root, result) {
+    var validOptions = _stylelint.utils.validateOptions(result, ruleName, {
+      actual: primary
+    }, {
+      actual: options,
+      possible: {
+        ignore: ["comments", "imports"],
+        except: ["root", "at-rule", "function", "mixin", "if-else", "loops"]
+      },
+      optional: true
+    });
+    if (!validOptions) {
+      return;
+    }
+    var isDollarVar = function isDollarVar(node) {
+      return node.prop && node.prop[0] === "$";
+    };
+    root.walkDecls(function (decl) {
+      // Ignore declarations that aren't variables.
+      // ------------------------------------------
+      if (!isDollarVar(decl)) {
+        return;
+      }
+
+      // If selected, ignore declarations in root.
+      // -----------------------------------------
+      if ((0, _utils.optionsHaveException)(options, "root") && decl.parent === root) {
+        return;
+      }
+
+      // If selected, ignore declarations in different types of at-rules.
+      // ----------------------------------------------------------------
+      if (decl.parent.type === "atrule") {
+        if ((0, _utils.optionsHaveException)(options, "at-rule") || (0, _utils.optionsHaveException)(options, "function") && decl.parent.name === "function" || (0, _utils.optionsHaveException)(options, "mixin") && decl.parent.name === "mixin" || (0, _utils.optionsHaveException)(options, "if-else") && (decl.parent.name === "if" || decl.parent.name === "else") || (0, _utils.optionsHaveException)(options, "loops") && (decl.parent.name === "each" || decl.parent.name === "for" || decl.parent.name === "while")) {
+          return;
+        }
+      }
+      var previous = decl.prev();
+
+      // If first or preceded by another variable.
+      // -----------------------------------------
+      if (!previous || isDollarVar(previous)) {
+        return;
+      }
+
+      // Check if preceded only by allowed types.
+      // ----------------------------------------
+      var precededOnlyByAllowed = true;
+      var allowComments = (0, _utils.optionsHaveIgnored)(options, "comments");
+      var allowImports = (0, _utils.optionsHaveIgnored)(options, "imports");
+      var importAtRules = ["import", "use", "forward"];
+      var _iterator = _createForOfIteratorHelper(decl.parent.nodes),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var sibling = _step.value;
+          if (sibling === decl) {
+            break;
+          } else if (!isDollarVar(sibling) && !(allowComments && sibling.type === "comment" || allowImports && sibling.type === "atrule" && importAtRules.includes(sibling.name))) {
+            precededOnlyByAllowed = false;
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      if (precededOnlyByAllowed) {
+        return;
+      }
+      _stylelint.utils.report({
+        message: messages.expected,
+        node: decl,
+        result: result,
+        ruleName: ruleName
+      });
+    });
+  };
+}
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;

node_modules/stylelint-scss/dist/rules/dollar-variable-no-missing-interpolation/index.js

@@ -0,0 +1,122 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = rule;
+exports.ruleName = exports.meta = exports.messages = void 0;
+var _stylelint = require("stylelint");
+var _utils = require("../../utils");
+var _postcssValueParser = _interopRequireDefault(require("postcss-value-parser"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+var ruleName = (0, _utils.namespace)("dollar-variable-no-missing-interpolation");
+exports.ruleName = ruleName;
+var messages = _stylelint.utils.ruleMessages(ruleName, {
+  rejected: function rejected(n, v) {
+    return "Expected variable ".concat(v, " to be interpolated when using it with ").concat(n);
+  }
+});
+exports.messages = messages;
+var meta = {
+  url: (0, _utils.ruleUrl)(ruleName)
+};
+
+// https://developer.mozilla.org/en/docs/Web/CSS/custom-ident#Lists_of_excluded_values
+exports.meta = meta;
+var customIdentProps = ["animation", "animation-name", "counter-reset", "counter-increment", "list-style-type", "will-change"];
+
+// https://developer.mozilla.org/en/docs/Web/CSS/At-rule
+var customIdentAtRules = ["counter-style", "keyframes", "supports"];
+function isAtRule(type) {
+  return type === "atrule";
+}
+function isCustomIdentAtRule(node) {
+  return isAtRule(node.type) && customIdentAtRules.includes(node.name);
+}
+function isCustomIdentProp(node) {
+  return customIdentProps.includes(node.prop);
+}
+function isAtSupports(node) {
+  return isAtRule(node.type) && node.name === "supports";
+}
+function isSassVar(value) {
+  return value[0] === "$";
+}
+function isStringVal(value) {
+  return /^(["']).*(["'])$/.test(value);
+}
+function toRegex(arr) {
+  return new RegExp("(".concat(arr.join("|"), ")"));
+}
+function rule(actual) {
+  return function (root, result) {
+    var validOptions = _stylelint.utils.validateOptions(result, ruleName, {
+      actual: actual
+    });
+    if (!validOptions) {
+      return;
+    }
+    var stringVars = [];
+    var vars = [];
+    function findVars(node) {
+      node.walkDecls(function (decl) {
+        var prop = decl.prop,
+          value = decl.value;
+        if (!isSassVar(prop) || vars.includes(prop)) {
+          return;
+        }
+        if (isStringVal(value)) {
+          stringVars.push(prop);
+        }
+        vars.push(prop);
+      });
+    }
+    findVars(root);
+    root.walkRules(findVars);
+    if (!vars.length) {
+      return;
+    }
+    function shouldReport(node, value) {
+      if (isAtSupports(node) || isCustomIdentProp(node)) {
+        return stringVars.includes(value);
+      }
+      if (isCustomIdentAtRule(node)) {
+        return vars.includes(value);
+      }
+      return false;
+    }
+    function report(node, value) {
+      var name = node.name,
+        prop = node.prop,
+        type = node.type;
+      var nodeName = isAtRule(type) ? "@".concat(name) : prop;
+      _stylelint.utils.report({
+        ruleName: ruleName,
+        result: result,
+        node: node,
+        message: messages.rejected(nodeName, value)
+      });
+    }
+    function exitEarly(node) {
+      return node.type !== "word" || !node.value;
+    }
+    function walkValues(node, value) {
+      (0, _postcssValueParser["default"])(value).walk(function (valNode) {
+        var value = valNode.value;
+        if (exitEarly(valNode) || !shouldReport(node, value)) {
+          return;
+        }
+        report(node, value);
+      });
+    }
+    root.walkDecls(toRegex(customIdentProps), function (decl) {
+      walkValues(decl, decl.value);
+    });
+    root.walkAtRules(toRegex(customIdentAtRules), function (atRule) {
+      walkValues(atRule, atRule.params);
+    });
+  };
+}
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;

node_modules/stylelint-scss/dist/rules/dollar-variable-no-namespaced-assignment/index.js

@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = rule;
+exports.ruleName = exports.meta = exports.messages = void 0;
+var _stylelint = require("stylelint");
+var _utils = require("../../utils");
+var ruleName = (0, _utils.namespace)("dollar-variable-no-namespaced-assignment");
+exports.ruleName = ruleName;
+var messages = _stylelint.utils.ruleMessages(ruleName, {
+  rejected: "Unexpected assignment to a namespaced $ variable"
+});
+exports.messages = messages;
+var meta = {
+  url: (0, _utils.ruleUrl)(ruleName)
+};
+exports.meta = meta;
+function rule(actual) {
+  return function (root, result) {
+    var validOptions = _stylelint.utils.validateOptions(result, ruleName, {
+      actual: actual
+    });
+    if (!validOptions) {
+      return;
+    }
+    root.walkDecls(function (decl) {
+      if (!/^[^$.]+\.\$./.test(decl.prop)) {
+        return;
+      }
+      _stylelint.utils.report({
+        message: messages.rejected,
+        node: decl,
+        result: result,
+        ruleName: ruleName
+      });
+    });
+  };
+}
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;

node_modules/stylelint-scss/dist/rules/dollar-variable-pattern/index.js

@@ -0,0 +1,60 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = rule;
+exports.ruleName = exports.meta = exports.messages = void 0;
+var _stylelint = require("stylelint");
+var _utils = require("../../utils");
+var ruleName = (0, _utils.namespace)("dollar-variable-pattern");
+exports.ruleName = ruleName;
+var messages = _stylelint.utils.ruleMessages(ruleName, {
+  expected: "Expected $ variable name to match specified pattern"
+});
+exports.messages = messages;
+var meta = {
+  url: (0, _utils.ruleUrl)(ruleName)
+};
+exports.meta = meta;
+function rule(pattern, options) {
+  return function (root, result) {
+    var validOptions = _stylelint.utils.validateOptions(result, ruleName, {
+      actual: pattern,
+      possible: [_utils.isRegExp, _utils.isString]
+    }, {
+      actual: options,
+      possible: {
+        ignore: ["local", "global"]
+      },
+      optional: true
+    });
+    if (!validOptions) {
+      return;
+    }
+    var regexpPattern = (0, _utils.isString)(pattern) ? new RegExp(pattern) : pattern;
+    root.walkDecls(function (decl) {
+      var prop = decl.prop;
+      if (prop[0] !== "$") {
+        return;
+      }
+
+      // If local or global variables need to be ignored
+      if ((0, _utils.optionsHaveIgnored)(options, "global") && decl.parent.type === "root" || (0, _utils.optionsHaveIgnored)(options, "local") && decl.parent.type !== "root") {
+        return;
+      }
+      if (regexpPattern.test(prop.slice(1))) {
+        return;
+      }
+      _stylelint.utils.report({
+        message: messages.expected,
+        node: decl,
+        result: result,
+        ruleName: ruleName
+      });
+    });
+  };
+}
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;

node_modules/stylelint-scss/dist/rules/double-slash-comment-empty-line-before/index.js

@@ -0,0 +1,107 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = rule;
+exports.ruleName = exports.meta = exports.messages = void 0;
+var _stylelint = require("stylelint");
+var _utils = require("../../utils");
+var ruleName = (0, _utils.namespace)("double-slash-comment-empty-line-before");
+exports.ruleName = ruleName;
+var messages = _stylelint.utils.ruleMessages(ruleName, {
+  expected: "Expected empty line before comment",
+  rejected: "Unexpected empty line before comment"
+});
+exports.messages = messages;
+var meta = {
+  url: (0, _utils.ruleUrl)(ruleName)
+};
+exports.meta = meta;
+var stylelintCommandPrefix = "stylelint-";
+function rule(expectation, options, context) {
+  return function (root, result) {
+    var validOptions = _stylelint.utils.validateOptions(result, ruleName, {
+      actual: expectation,
+      possible: ["always", "never"]
+    }, {
+      actual: options,
+      possible: {
+        except: ["first-nested", "inside-block"],
+        ignore: ["stylelint-commands", "between-comments", "inside-block"]
+      },
+      optional: true
+    });
+    if (!validOptions) {
+      return;
+    }
+    root.walkComments(function (comment) {
+      // Only process // comments
+      if (!comment.raws.inline && !comment.inline) {
+        return;
+      }
+      if ((0, _utils.isInlineComment)(comment)) {
+        return;
+      }
+
+      // Ignore the first node
+      if (comment === root.first) {
+        return;
+      }
+
+      // Optionally ignore stylelint commands
+      if (comment.text.indexOf(stylelintCommandPrefix) === 0 && (0, _utils.optionsHaveIgnored)(options, "stylelint-commands")) {
+        return;
+      }
+
+      // Optionally ignore comments inside blocks
+      if (comment.parent !== root && (0, _utils.optionsHaveIgnored)(options, "inside-block")) {
+        return;
+      }
+
+      // Optionally ignore newlines between comments
+      var prev = comment.prev();
+      if (prev && prev.type === "comment" && (0, _utils.optionsHaveIgnored)(options, "between-comments")) {
+        return;
+      }
+      var before = comment.raw("before");
+      var expectEmptyLineBefore = function () {
+        if ((0, _utils.optionsHaveException)(options, "first-nested") && comment.parent !== root && comment === comment.parent.first) {
+          return false;
+        }
+
+        // Reverse expectation for comments inside blocks
+        if (comment.parent !== root && (0, _utils.optionsHaveException)(options, "inside-block")) {
+          return expectation === "never";
+        }
+        return expectation === "always";
+      }();
+      var hasEmptyLineBefore = before.search(/\n\s*?\n/) !== -1;
+
+      // Return if the expectation is met
+      if (expectEmptyLineBefore === hasEmptyLineBefore) {
+        return;
+      }
+      if (context.fix) {
+        if (expectEmptyLineBefore && !hasEmptyLineBefore) {
+          (0, _utils.addEmptyLineBefore)(comment, context.newline);
+          return;
+        }
+        if (!expectEmptyLineBefore && hasEmptyLineBefore) {
+          (0, _utils.removeEmptyLinesBefore)(comment, context.newline);
+          return;
+        }
+      }
+      var message = expectEmptyLineBefore ? messages.expected : messages.rejected;
+      _stylelint.utils.report({
+        message: message,
+        node: comment,
+        result: result,
+        ruleName: ruleName
+      });
+    });
+  };
+}
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;

node_modules/stylelint-scss/dist/rules/double-slash-comment-inline/index.js

@@ -0,0 +1,76 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = rule;
+exports.ruleName = exports.meta = exports.messages = void 0;
+var _utils = require("../../utils");
+var _stylelint = require("stylelint");
+var ruleName = (0, _utils.namespace)("double-slash-comment-inline");
+exports.ruleName = ruleName;
+var messages = _stylelint.utils.ruleMessages(ruleName, {
+  expected: "Expected //-comment to be inline comment",
+  rejected: "Unexpected inline //-comment"
+});
+exports.messages = messages;
+var meta = {
+  url: (0, _utils.ruleUrl)(ruleName)
+};
+exports.meta = meta;
+var stylelintCommandPrefix = "stylelint-";
+function rule(expectation, options) {
+  return function (root, result) {
+    var validOptions = _stylelint.utils.validateOptions(result, ruleName, {
+      actual: expectation,
+      possible: ["always", "never"]
+    }, {
+      actual: options,
+      possible: {
+        ignore: ["stylelint-commands"]
+      },
+      optional: true
+    });
+    if (!validOptions) {
+      return;
+    }
+    (0, _utils.eachRoot)(root, checkRoot);
+    function checkRoot(root) {
+      var rootString = root.source.input.css;
+      if (rootString.trim() === "") {
+        return;
+      }
+      var comments = (0, _utils.findCommentsInRaws)(rootString);
+      comments.forEach(function (comment) {
+        // Only process // comments
+        if (comment.type !== "double-slash") {
+          return;
+        }
+
+        // Optionally ignore stylelint commands
+        if (comment.text.indexOf(stylelintCommandPrefix) === 0 && (0, _utils.optionsHaveIgnored)(options, "stylelint-commands")) {
+          return;
+        }
+        var isInline = comment.inlineAfter || comment.inlineBefore;
+        var message;
+        if (isInline && expectation === "never") {
+          message = messages.rejected;
+        } else if (!isInline && expectation === "always") {
+          message = messages.expected;
+        } else {
+          return;
+        }
+        _stylelint.utils.report({
+          message: message,
+          node: root,
+          index: comment.source.start,
+          result: result,
+          ruleName: ruleName
+        });
+      });
+    }
+  };
+}
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;

node_modules/stylelint-scss/dist/rules/double-slash-comment-whitespace-inside/index.js

@@ -0,0 +1,69 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = rule;
+exports.ruleName = exports.meta = exports.messages = void 0;
+var _utils = require("../../utils");
+var _stylelint = require("stylelint");
+var ruleName = (0, _utils.namespace)("double-slash-comment-whitespace-inside");
+exports.ruleName = ruleName;
+var messages = _stylelint.utils.ruleMessages(ruleName, {
+  expected: "Expected a space after //",
+  rejected: "Unexpected space after //"
+});
+exports.messages = messages;
+var meta = {
+  url: (0, _utils.ruleUrl)(ruleName)
+};
+exports.meta = meta;
+function rule(expectation) {
+  return function (root, result) {
+    var validOptions = _stylelint.utils.validateOptions(result, ruleName, {
+      actual: expectation,
+      possible: ["always", "never"]
+    });
+    if (!validOptions) {
+      return;
+    }
+    (0, _utils.eachRoot)(root, checkRoot);
+    function checkRoot(root) {
+      var rootString = root.source.input.css;
+      if (rootString.trim() === "") {
+        return;
+      }
+      var comments = (0, _utils.findCommentsInRaws)(rootString);
+      comments.forEach(function (comment) {
+        // Only process // comments
+        if (comment.type !== "double-slash") {
+          return;
+        }
+
+        // if it's `//` - no warning whatsoever; if `// ` - then trailing
+        // whitespace rule will govern this
+        if (comment.text === "") {
+          return;
+        }
+        var message;
+        if (expectation === "never" && comment.raws.left !== "") {
+          message = messages.rejected;
+        } else if (comment.raws.left === "" && expectation === "always") {
+          message = messages.expected;
+        } else {
+          return;
+        }
+        _stylelint.utils.report({
+          message: message,
+          node: root,
+          index: comment.source.start + comment.raws.startToken.length,
+          result: result,
+          ruleName: ruleName
+        });
+      });
+    }
+  };
+}
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;

node_modules/stylelint-scss/dist/rules/function-color-relative/index.js

@@ -0,0 +1,61 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = rule;
+exports.ruleName = exports.meta = exports.messages = void 0;
+var _postcssValueParser = _interopRequireDefault(require("postcss-value-parser"));
+var _stylelint = require("stylelint");
+var _utils = require("../../utils");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+var ruleName = (0, _utils.namespace)("function-color-relative");
+exports.ruleName = ruleName;
+var messages = _stylelint.utils.ruleMessages(ruleName, {
+  rejected: "Expected the scale-color function to be used"
+});
+exports.messages = messages;
+var meta = {
+  url: (0, _utils.ruleUrl)(ruleName)
+};
+exports.meta = meta;
+var function_names = ["saturate", "desaturate", "darken", "lighten", "opacify", "fade-in", "transparentize", "fade-out"];
+function isColorFunction(node) {
+  return node.type === "function" && function_names.includes(node.value);
+}
+function rule(primary) {
+  return function (root, result) {
+    var validOptions = _stylelint.utils.validateOptions(result, ruleName, {
+      actual: primary
+    });
+    if (!validOptions) {
+      return;
+    }
+    root.walkDecls(function (decl) {
+      (0, _postcssValueParser["default"])(decl.value).walk(function (node) {
+        // Verify that we're only looking at functions.
+        if (node.type !== "function" || node.value === "") {
+          return;
+        }
+        var isFilter = decl.prop === "filter";
+        var isSassColorFunction = !isFilter && isColorFunction(node);
+        var isDSFilterColorFunction = isFilter && node.value === "drop-shadow" && node.nodes.some(isColorFunction);
+        if (isSassColorFunction || isDSFilterColorFunction) {
+          var nodes = isDSFilterColorFunction ? node.nodes.filter(isColorFunction) : [node];
+          nodes.forEach(function (node) {
+            _stylelint.utils.report({
+              message: messages.rejected,
+              node: decl,
+              index: (0, _utils.declarationValueIndex)(decl) + node.sourceIndex,
+              result: result,
+              ruleName: ruleName
+            });
+          });
+        }
+      });
+    });
+  };
+}
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;

node_modules/stylelint-scss/dist/rules/function-no-unknown/index.js

@@ -0,0 +1,125 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = rule;
+exports.ruleName = exports.meta = exports.messages = void 0;
+var _postcssValueParser = _interopRequireDefault(require("postcss-value-parser"));
+var _stylelint = require("stylelint");
+var _utils = require("../../utils");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _iterableToArrayLimit(arr, i) { var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"]; if (null != _i) { var _s, _e, _x, _r, _arr = [], _n = !0, _d = !1; try { if (_x = (_i = _i.call(arr)).next, 0 === i) { if (Object(_i) !== _i) return; _n = !1; } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0); } catch (err) { _d = !0, _e = err; } finally { try { if (!_n && null != _i["return"] && (_r = _i["return"](), Object(_r) !== _r)) return; } finally { if (_d) throw _e; } } return _arr; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+var ruleToCheckAgainst = "function-no-unknown";
+var ruleName = (0, _utils.namespace)(ruleToCheckAgainst);
+exports.ruleName = ruleName;
+var messages = _stylelint.utils.ruleMessages(ruleName, {
+  rejected: function rejected() {
+    var _rules$ruleToCheckAga;
+    return (_rules$ruleToCheckAga = _stylelint.rules[ruleToCheckAgainst].messages).rejected.apply(_rules$ruleToCheckAga, arguments).replace(" (".concat(ruleToCheckAgainst, ")"), "");
+  }
+});
+exports.messages = messages;
+var meta = {
+  url: (0, _utils.ruleUrl)(ruleName)
+};
+exports.meta = meta;
+function isNamespacedFunction(fn) {
+  var namespacedFunc = /^\w+\.\w+$/;
+  return namespacedFunc.test(fn);
+}
+function isAtUseAsSyntax(nodes) {
+  var _nodes$slice = nodes.slice(-3),
+    _nodes$slice2 = _slicedToArray(_nodes$slice, 3),
+    first = _nodes$slice2[0],
+    second = _nodes$slice2[1],
+    third = _nodes$slice2[2];
+  return first.type === "word" && first.value === "as" && second.type === "space" && third.type === "word";
+}
+function getAtUseNamespace(nodes) {
+  if (isAtUseAsSyntax(nodes)) {
+    var _nodes$slice3 = nodes.slice(-1),
+      _nodes$slice4 = _slicedToArray(_nodes$slice3, 1),
+      _last = _nodes$slice4[0];
+    return _last.value;
+  }
+  var _nodes = _slicedToArray(nodes, 1),
+    first = _nodes[0];
+  var parts = first.value.split("/");
+  var _parts$slice = parts.slice(-1),
+    _parts$slice2 = _slicedToArray(_parts$slice, 1),
+    last = _parts$slice2[0];
+  return last;
+}
+function rule(primaryOption, secondaryOptions) {
+  return function (root, result) {
+    var validOptions = _stylelint.utils.validateOptions(result, ruleName, {
+      actual: primaryOption
+    }, {
+      actual: secondaryOptions,
+      possible: {
+        ignoreFunctions: [_utils.isString, _utils.isRegExp]
+      },
+      optional: true
+    });
+    if (!validOptions) {
+      return;
+    }
+    var optionsFunctions = secondaryOptions && secondaryOptions.ignoreFunctions || [];
+    var ignoreFunctions = _utils.ALL_FUNCTIONS.concat(optionsFunctions);
+    var ignoreFunctionsAsSet = new Set(ignoreFunctions);
+    var newSecondaryOptions = Object.assign({}, secondaryOptions, {
+      ignoreFunctions: ignoreFunctions
+    });
+    _stylelint.utils.checkAgainstRule({
+      ruleName: ruleToCheckAgainst,
+      ruleSettings: [primaryOption, newSecondaryOptions],
+      root: root
+    }, function (warning) {
+      var node = warning.node,
+        index = warning.index;
+
+      // NOTE: Using `valueParser` is necessary for extracting a function name. This may be a performance waste.
+      (0, _postcssValueParser["default"])(node.value).walk(function (valueNode) {
+        var type = valueNode.type,
+          funcName = valueNode.value;
+        if (type !== "function") {
+          return;
+        }
+        if (isNamespacedFunction(funcName)) {
+          var atUseNamespaces = [];
+          root.walkAtRules(/^use$/i, function (atRule) {
+            var _valueParser = (0, _postcssValueParser["default"])(atRule.params),
+              nodes = _valueParser.nodes;
+            atUseNamespaces.push(getAtUseNamespace(nodes));
+          });
+          if (atUseNamespaces.length) {
+            var _funcName$split = funcName.split("."),
+              _funcName$split2 = _slicedToArray(_funcName$split, 1),
+              _namespace = _funcName$split2[0];
+            if (atUseNamespaces.includes(_namespace)) {
+              return;
+            }
+          }
+        }
+        if (!ignoreFunctionsAsSet.has(funcName)) {
+          _stylelint.utils.report({
+            message: messages.rejected(funcName),
+            ruleName: ruleName,
+            result: result,
+            node: node,
+            index: index
+          });
+        }
+      });
+    });
+  };
+}
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;

node_modules/stylelint-scss/dist/rules/function-quote-no-quoted-strings-inside/index.js

@@ -0,0 +1,75 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = rule;
+exports.ruleName = exports.meta = exports.messages = void 0;
+var _postcssValueParser = _interopRequireDefault(require("postcss-value-parser"));
+var _stylelint = require("stylelint");
+var _utils = require("../../utils");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+var ruleName = (0, _utils.namespace)("function-quote-no-quoted-strings-inside");
+exports.ruleName = ruleName;
+var messages = _stylelint.utils.ruleMessages(ruleName, {
+  rejected: "Quote function used with an already-quoted string"
+});
+exports.messages = messages;
+var meta = {
+  url: (0, _utils.ruleUrl)(ruleName)
+};
+exports.meta = meta;
+function rule(primary, _, context) {
+  return function (root, result) {
+    var validOptions = _stylelint.utils.validateOptions(result, ruleName, {
+      actual: primary
+    });
+    if (!validOptions) {
+      return;
+    }
+
+    // Setup variable naming.
+    var vars = {};
+    root.walkDecls(function (decl) {
+      if (decl.prop[0] !== "$") {
+        return;
+      }
+      (0, _postcssValueParser["default"])(decl.value).walk(function (node) {
+        vars[decl.prop] = node.type;
+      });
+    });
+    root.walkDecls(function (decl) {
+      (0, _postcssValueParser["default"])(decl.value).walk(function (node) {
+        // Verify that we're only looking at functions.
+        if (node.type !== "function" || (0, _utils.isNativeCssFunction)(node.value) || node.value === "") {
+          return;
+        }
+
+        // Verify we're only looking at quote() calls.
+        if (node.value !== "quote") {
+          return;
+        }
+
+        // Report error if first character is a quote.
+        // postcss-value-parser represents quoted strings as type 'string' (as opposed to word)
+        if (node.nodes[0].quote || vars[node.nodes[0].value] === "string") {
+          if (context.fix) {
+            var contents = decl.value.match(/quote\((.*)\)/);
+            decl.value = decl.value.replace(/quote\(.*\)/, contents[1]);
+          } else {
+            _stylelint.utils.report({
+              message: messages.rejected,
+              node: decl,
+              index: (0, _utils.declarationValueIndex)(decl) + node.sourceIndex,
+              result: result,
+              ruleName: ruleName
+            });
+          }
+        }
+      });
+    });
+  };
+}
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;

node_modules/stylelint-scss/dist/rules/function-unquote-no-unquoted-strings-inside/index.js

@@ -0,0 +1,75 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = rule;
+exports.ruleName = exports.meta = exports.messages = void 0;
+var _postcssValueParser = _interopRequireDefault(require("postcss-value-parser"));
+var _stylelint = require("stylelint");
+var _utils = require("../../utils");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+var ruleName = (0, _utils.namespace)("function-unquote-no-unquoted-strings-inside");
+exports.ruleName = ruleName;
+var messages = _stylelint.utils.ruleMessages(ruleName, {
+  rejected: "Unquote function used with an already-unquoted string"
+});
+exports.messages = messages;
+var meta = {
+  url: (0, _utils.ruleUrl)(ruleName)
+};
+exports.meta = meta;
+function rule(primary, _, context) {
+  return function (root, result) {
+    var validOptions = _stylelint.utils.validateOptions(result, ruleName, {
+      actual: primary
+    });
+    if (!validOptions) {
+      return;
+    }
+
+    // Setup variable naming.
+    var vars = {};
+    root.walkDecls(function (decl) {
+      if (decl.prop[0] !== "$") {
+        return;
+      }
+      (0, _postcssValueParser["default"])(decl.value).walk(function (node) {
+        vars[decl.prop] = node.type;
+      });
+    });
+    root.walkDecls(function (decl) {
+      (0, _postcssValueParser["default"])(decl.value).walk(function (node) {
+        // Verify that we're only looking at functions.
+        if (node.type !== "function" || (0, _utils.isNativeCssFunction)(node.value) || node.value === "") {
+          return;
+        }
+
+        // Verify we're only looking at quote() calls.
+        if (node.value !== "unquote") {
+          return;
+        }
+
+        // Report error if first character is a quote.
+        // postcss-value-parser represents quoted strings as type 'string' (as opposed to word)
+        if (!node.nodes[0].quote && node.nodes[0].value[0] !== "$" || vars[node.nodes[0].value] === "word") {
+          if (context.fix) {
+            var contents = /unquote\((.*)\)/.exec(decl.value);
+            decl.value = contents[1];
+          } else {
+            _stylelint.utils.report({
+              message: messages.rejected,
+              node: decl,
+              index: (0, _utils.declarationValueIndex)(decl) + node.sourceIndex,
+              result: result,
+              ruleName: ruleName
+            });
+          }
+        }
+      });
+    });
+  };
+}
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;

node_modules/stylelint-scss/dist/rules/index.js

@@ -0,0 +1,128 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _atEachKeyValueSingleLine = _interopRequireDefault(require("./at-each-key-value-single-line"));
+var _atElseClosingBraceNewlineAfter = _interopRequireDefault(require("./at-else-closing-brace-newline-after"));
+var _atElseClosingBraceSpaceAfter = _interopRequireDefault(require("./at-else-closing-brace-space-after"));
+var _atElseEmptyLineBefore = _interopRequireDefault(require("./at-else-empty-line-before"));
+var _atElseIfParenthesesSpaceBefore = _interopRequireDefault(require("./at-else-if-parentheses-space-before"));
+var _atExtendNoMissingPlaceholder = _interopRequireDefault(require("./at-extend-no-missing-placeholder"));
+var _atFunctionNamedArguments = _interopRequireDefault(require("./at-function-named-arguments"));
+var _atFunctionParenthesesSpaceBefore = _interopRequireDefault(require("./at-function-parentheses-space-before"));
+var _atFunctionPattern = _interopRequireDefault(require("./at-function-pattern"));
+var _atIfClosingBraceNewlineAfter = _interopRequireDefault(require("./at-if-closing-brace-newline-after"));
+var _atIfClosingBraceSpaceAfter = _interopRequireDefault(require("./at-if-closing-brace-space-after"));
+var _atIfNoNull = _interopRequireDefault(require("./at-if-no-null"));
+var _atImportNoPartialLeadingUnderscore = _interopRequireDefault(require("./at-import-no-partial-leading-underscore"));
+var _atImportPartialExtension = _interopRequireDefault(require("./at-import-partial-extension"));
+var _atImportPartialExtensionBlacklist = _interopRequireDefault(require("./at-import-partial-extension-blacklist"));
+var _atImportPartialExtensionWhitelist = _interopRequireDefault(require("./at-import-partial-extension-whitelist"));
+var _atMixinArgumentlessCallParentheses = _interopRequireDefault(require("./at-mixin-argumentless-call-parentheses"));
+var _atMixinNamedArguments = _interopRequireDefault(require("./at-mixin-named-arguments"));
+var _atMixinParenthesesSpaceBefore = _interopRequireDefault(require("./at-mixin-parentheses-space-before"));
+var _atMixinPattern = _interopRequireDefault(require("./at-mixin-pattern"));
+var _atRuleConditionalNoParentheses = _interopRequireDefault(require("./at-rule-conditional-no-parentheses"));
+var _atRuleNoUnknown = _interopRequireDefault(require("./at-rule-no-unknown"));
+var _atUseNoUnnamespaced = _interopRequireDefault(require("./at-use-no-unnamespaced"));
+var _commentNoEmpty = _interopRequireDefault(require("./comment-no-empty"));
+var _commentNoLoud = _interopRequireDefault(require("./comment-no-loud"));
+var _declarationNestedProperties = _interopRequireDefault(require("./declaration-nested-properties"));
+var _declarationNestedPropertiesNoDividedGroups = _interopRequireDefault(require("./declaration-nested-properties-no-divided-groups"));
+var _dimensionNoNonNumericValues = _interopRequireDefault(require("./dimension-no-non-numeric-values"));
+var _dollarVariableColonNewlineAfter = _interopRequireDefault(require("./dollar-variable-colon-newline-after"));
+var _dollarVariableColonSpaceAfter = _interopRequireDefault(require("./dollar-variable-colon-space-after"));
+var _dollarVariableColonSpaceBefore = _interopRequireDefault(require("./dollar-variable-colon-space-before"));
+var _dollarVariableDefault = _interopRequireDefault(require("./dollar-variable-default"));
+var _dollarVariableEmptyLineAfter = _interopRequireDefault(require("./dollar-variable-empty-line-after"));
+var _dollarVariableEmptyLineBefore = _interopRequireDefault(require("./dollar-variable-empty-line-before"));
+var _dollarVariableFirstInBlock = _interopRequireDefault(require("./dollar-variable-first-in-block"));
+var _dollarVariableNoMissingInterpolation = _interopRequireDefault(require("./dollar-variable-no-missing-interpolation"));
+var _dollarVariableNoNamespacedAssignment = _interopRequireDefault(require("./dollar-variable-no-namespaced-assignment"));
+var _dollarVariablePattern = _interopRequireDefault(require("./dollar-variable-pattern"));
+var _doubleSlashCommentEmptyLineBefore = _interopRequireDefault(require("./double-slash-comment-empty-line-before"));
+var _doubleSlashCommentInline = _interopRequireDefault(require("./double-slash-comment-inline"));
+var _doubleSlashCommentWhitespaceInside = _interopRequireDefault(require("./double-slash-comment-whitespace-inside"));
+var _functionColorRelative = _interopRequireDefault(require("./function-color-relative"));
+var _functionNoUnknown = _interopRequireDefault(require("./function-no-unknown"));
+var _functionQuoteNoQuotedStringsInside = _interopRequireDefault(require("./function-quote-no-quoted-strings-inside"));
+var _functionUnquoteNoUnquotedStringsInside = _interopRequireDefault(require("./function-unquote-no-unquoted-strings-inside"));
+var _mapKeysQuotes = _interopRequireDefault(require("./map-keys-quotes"));
+var _mediaFeatureValueDollarVariable = _interopRequireDefault(require("./media-feature-value-dollar-variable"));
+var _noDollarVariables = _interopRequireDefault(require("./no-dollar-variables"));
+var _noGlobalFunctionNames = _interopRequireDefault(require("./no-global-function-names"));
+var _noDuplicateDollarVariables = _interopRequireDefault(require("./no-duplicate-dollar-variables"));
+var _noDuplicateMixins = _interopRequireDefault(require("./no-duplicate-mixins"));
+var _operatorNoNewlineAfter = _interopRequireDefault(require("./operator-no-newline-after"));
+var _operatorNoNewlineBefore = _interopRequireDefault(require("./operator-no-newline-before"));
+var _operatorNoUnspaced = _interopRequireDefault(require("./operator-no-unspaced"));
+var _partialNoImport = _interopRequireDefault(require("./partial-no-import"));
+var _percentPlaceholderPattern = _interopRequireDefault(require("./percent-placeholder-pattern"));
+var _selectorNestCombinators = _interopRequireDefault(require("./selector-nest-combinators"));
+var _selectorNoRedundantNestingSelector = _interopRequireDefault(require("./selector-no-redundant-nesting-selector"));
+var _selectorNoUnionClassName = _interopRequireDefault(require("./selector-no-union-class-name"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+var _default = {
+  "at-extend-no-missing-placeholder": _atExtendNoMissingPlaceholder["default"],
+  "at-else-closing-brace-newline-after": _atElseClosingBraceNewlineAfter["default"],
+  "at-else-closing-brace-space-after": _atElseClosingBraceSpaceAfter["default"],
+  "at-else-empty-line-before": _atElseEmptyLineBefore["default"],
+  "at-else-if-parentheses-space-before": _atElseIfParenthesesSpaceBefore["default"],
+  "at-function-named-arguments": _atFunctionNamedArguments["default"],
+  "at-function-parentheses-space-before": _atFunctionParenthesesSpaceBefore["default"],
+  "at-function-pattern": _atFunctionPattern["default"],
+  "at-if-closing-brace-newline-after": _atIfClosingBraceNewlineAfter["default"],
+  "at-if-closing-brace-space-after": _atIfClosingBraceSpaceAfter["default"],
+  "at-if-no-null": _atIfNoNull["default"],
+  "at-import-no-partial-leading-underscore": _atImportNoPartialLeadingUnderscore["default"],
+  "at-import-partial-extension": _atImportPartialExtension["default"],
+  "at-import-partial-extension-blacklist": _atImportPartialExtensionBlacklist["default"],
+  "at-import-partial-extension-whitelist": _atImportPartialExtensionWhitelist["default"],
+  "at-mixin-argumentless-call-parentheses": _atMixinArgumentlessCallParentheses["default"],
+  "at-mixin-named-arguments": _atMixinNamedArguments["default"],
+  "at-mixin-parentheses-space-before": _atMixinParenthesesSpaceBefore["default"],
+  "at-mixin-pattern": _atMixinPattern["default"],
+  "at-each-key-value-single-line": _atEachKeyValueSingleLine["default"],
+  "at-rule-conditional-no-parentheses": _atRuleConditionalNoParentheses["default"],
+  "at-rule-no-unknown": _atRuleNoUnknown["default"],
+  "at-use-no-unnamespaced": _atUseNoUnnamespaced["default"],
+  "comment-no-empty": _commentNoEmpty["default"],
+  "comment-no-loud": _commentNoLoud["default"],
+  "declaration-nested-properties": _declarationNestedProperties["default"],
+  "declaration-nested-properties-no-divided-groups": _declarationNestedPropertiesNoDividedGroups["default"],
+  "dimension-no-non-numeric-values": _dimensionNoNonNumericValues["default"],
+  "dollar-variable-colon-newline-after": _dollarVariableColonNewlineAfter["default"],
+  "dollar-variable-colon-space-after": _dollarVariableColonSpaceAfter["default"],
+  "dollar-variable-colon-space-before": _dollarVariableColonSpaceBefore["default"],
+  "dollar-variable-default": _dollarVariableDefault["default"],
+  "dollar-variable-empty-line-after": _dollarVariableEmptyLineAfter["default"],
+  "dollar-variable-empty-line-before": _dollarVariableEmptyLineBefore["default"],
+  "dollar-variable-first-in-block": _dollarVariableFirstInBlock["default"],
+  "dollar-variable-no-missing-interpolation": _dollarVariableNoMissingInterpolation["default"],
+  "dollar-variable-no-namespaced-assignment": _dollarVariableNoNamespacedAssignment["default"],
+  "dollar-variable-pattern": _dollarVariablePattern["default"],
+  "double-slash-comment-empty-line-before": _doubleSlashCommentEmptyLineBefore["default"],
+  "double-slash-comment-inline": _doubleSlashCommentInline["default"],
+  "double-slash-comment-whitespace-inside": _doubleSlashCommentWhitespaceInside["default"],
+  "function-quote-no-quoted-strings-inside": _functionQuoteNoQuotedStringsInside["default"],
+  "function-unquote-no-unquoted-strings-inside": _functionUnquoteNoUnquotedStringsInside["default"],
+  "function-color-relative": _functionColorRelative["default"],
+  "function-no-unknown": _functionNoUnknown["default"],
+  "map-keys-quotes": _mapKeysQuotes["default"],
+  "media-feature-value-dollar-variable": _mediaFeatureValueDollarVariable["default"],
+  "no-dollar-variables": _noDollarVariables["default"],
+  "no-duplicate-dollar-variables": _noDuplicateDollarVariables["default"],
+  "no-duplicate-mixins": _noDuplicateMixins["default"],
+  "no-global-function-names": _noGlobalFunctionNames["default"],
+  "operator-no-newline-after": _operatorNoNewlineAfter["default"],
+  "operator-no-newline-before": _operatorNoNewlineBefore["default"],
+  "operator-no-unspaced": _operatorNoUnspaced["default"],
+  "percent-placeholder-pattern": _percentPlaceholderPattern["default"],
+  "partial-no-import": _partialNoImport["default"],
+  "selector-nest-combinators": _selectorNestCombinators["default"],
+  "selector-no-redundant-nesting-selector": _selectorNoRedundantNestingSelector["default"],
+  "selector-no-union-class-name": _selectorNoUnionClassName["default"]
+};
+exports["default"] = _default;

node_modules/stylelint-scss/dist/rules/map-keys-quotes/index.js

@@ -0,0 +1,85 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = rule;
+exports.ruleName = exports.meta = exports.messages = void 0;
+var _postcssValueParser = _interopRequireDefault(require("postcss-value-parser"));
+var _stylelint = require("stylelint");
+var _utils = require("../../utils");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+var ruleName = (0, _utils.namespace)("map-keys-quotes");
+exports.ruleName = ruleName;
+var messages = _stylelint.utils.ruleMessages(ruleName, {
+  expected: "Expected keys in map to be quoted."
+});
+exports.messages = messages;
+var meta = {
+  url: (0, _utils.ruleUrl)(ruleName)
+};
+exports.meta = meta;
+var mathOperators = ["+", "/", "-", "*", "%"];
+function rule(primary) {
+  return function (root, result) {
+    var validOptions = _stylelint.utils.validateOptions(result, ruleName, {
+      actual: primary,
+      possible: ["always"]
+    });
+    if (!validOptions) {
+      return;
+    }
+    root.walkDecls(function (decl) {
+      if (decl.prop[0] !== "$") {
+        return;
+      }
+      (0, _postcssValueParser["default"])(decl.value).walk(function (node) {
+        if (node.type === "function" && node.value === "" && isMap(node.nodes)) {
+          // Identify all of the map-keys and see if they're strings (not words).
+          var mapKeys = returnMapKeys(node.nodes);
+          mapKeys.forEach(function (map_key) {
+            if (mathOperators.includes(map_key.value)) {
+              return;
+            }
+            if (map_key.type === "word" && isNaN(map_key.value)) {
+              _stylelint.utils.report({
+                message: messages.expected,
+                node: decl,
+                result: result,
+                ruleName: ruleName
+              });
+            }
+          });
+        }
+      });
+    });
+  };
+}
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+
+// Takes in a list of map nodes and identifies if they are a map.
+// A map is identified by the pattern: [string/word colon(div) anything comma(div) ...]
+function isMap(nodes) {
+  if (nodes.length < 4) {
+    return false;
+  }
+  if (nodes[0].type !== "word" && nodes[0].type !== "string") {
+    return false;
+  }
+  if (nodes[1].value !== ":") {
+    return false;
+  }
+  if (nodes[3].value !== ",") {
+    return false;
+  }
+  return true;
+}
+function returnMapKeys(array) {
+  var new_array = [];
+  for (var i = 0; i < array.length; i += 4) {
+    new_array.push(array[i]);
+  }
+  return new_array;
+}

node_modules/stylelint-scss/dist/rules/media-feature-value-dollar-variable/index.js

@@ -0,0 +1,89 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = rule;
+exports.ruleName = exports.meta = exports.messages = void 0;
+var _stylelint = require("stylelint");
+var _utils = require("../../utils");
+var ruleName = (0, _utils.namespace)("media-feature-value-dollar-variable");
+exports.ruleName = ruleName;
+var messages = _stylelint.utils.ruleMessages(ruleName, {
+  rejected: "Unexpected dollar-variable as a media feature value",
+  expected: "Expected a dollar-variable (e.g. $var) to be used as a media feature value"
+});
+exports.messages = messages;
+var meta = {
+  url: (0, _utils.ruleUrl)(ruleName)
+};
+exports.meta = meta;
+function rule(expectation, options) {
+  return function (root, result) {
+    var validOptions = _stylelint.utils.validateOptions(result, ruleName, {
+      actual: expectation,
+      possible: ["always", "never"]
+    }, {
+      actual: options,
+      possible: {
+        ignore: ["keywords"]
+      },
+      optional: true
+    });
+    if (!validOptions) {
+      return;
+    }
+    var valueRegex = /:\s*(\S.+?)(:?\s*)\)/;
+    // In `(max-width: 10px )` find `: 10px )`.
+    // Got to go with that (the global search doesn't remember parens' insides)
+    // and parse it again afterwards to remove trailing junk
+    var valueRegexGlobal = new RegExp(valueRegex.source, "g");
+    // `$var-name_sth`
+    var variableRegex = /^(\w+\.)?\$[\w-]+$/;
+    // `#{$var-name_sth}`
+    var interpolationVarRegex = /^#{\s*(\w+\.)?\$\w+\s*}$/;
+    // `none`, `dark`
+    var keywordValueRegex = /^[a-z][a-z\d-]*$/;
+    root.walkAtRules("media", function (atRule) {
+      var found = atRule.params.match(valueRegexGlobal);
+
+      // If there are no values
+      if (!found || !found.length) {
+        return;
+      }
+      found.forEach(function (found) {
+        // ... parse `: 10px )` to `10px`
+        var valueParsed = found.match(valueRegex)[1];
+
+        // Just a shorthand to stylelint.utils.report()
+        function complain(message) {
+          _stylelint.utils.report({
+            ruleName: ruleName,
+            result: result,
+            node: atRule,
+            word: valueParsed,
+            message: message
+          });
+        }
+
+        // Keyword values, like `none`, should always be fine if keywords are
+        // ignored.
+        if (keywordValueRegex.test(valueParsed) && (0, _utils.optionsHaveIgnored)(options, "keywords")) {
+          return;
+        }
+
+        // A value should be a single variable
+        // or it should be a single variable inside Sass interpolation
+        if (expectation === "always" && !(variableRegex.test(valueParsed) || interpolationVarRegex.test(valueParsed))) {
+          complain(messages.expected);
+        } else if (expectation === "never" && valueParsed.includes("$")) {
+          // "Never" means no variables at all (functions allowed)
+          complain(messages.rejected);
+        }
+      });
+    });
+  };
+}
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;

node_modules/stylelint-scss/dist/rules/no-dollar-variables/index.js

@@ -0,0 +1,45 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = rule;
+exports.ruleName = exports.meta = exports.messages = void 0;
+var _stylelint = require("stylelint");
+var _utils = require("../../utils");
+var ruleName = (0, _utils.namespace)("no-dollar-variables");
+exports.ruleName = ruleName;
+var messages = _stylelint.utils.ruleMessages(ruleName, {
+  rejected: function rejected(variable) {
+    return "Unexpected dollar variable ".concat(variable);
+  }
+});
+exports.messages = messages;
+var meta = {
+  url: (0, _utils.ruleUrl)(ruleName)
+};
+exports.meta = meta;
+function rule(value) {
+  return function (root, result) {
+    var validOptions = _stylelint.utils.validateOptions(result, ruleName, {
+      actual: value
+    });
+    if (!validOptions) {
+      return;
+    }
+    root.walkDecls(function (decl) {
+      if (decl.prop[0] !== "$") {
+        return;
+      }
+      _stylelint.utils.report({
+        message: messages.rejected(decl.prop),
+        node: decl,
+        result: result,
+        ruleName: ruleName
+      });
+    });
+  };
+}
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;

node_modules/stylelint-scss/dist/rules/no-duplicate-dollar-variables/index.js

@@ -0,0 +1,164 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = rule;
+exports.ruleName = exports.meta = exports.messages = void 0;
+var _stylelint = require("stylelint");
+var _utils = require("../../utils");
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+var ruleName = (0, _utils.namespace)("no-duplicate-dollar-variables");
+exports.ruleName = ruleName;
+var messages = _stylelint.utils.ruleMessages(ruleName, {
+  rejected: function rejected(variable) {
+    return "Unexpected duplicate dollar variable ".concat(variable);
+  }
+});
+exports.messages = messages;
+var meta = {
+  url: (0, _utils.ruleUrl)(ruleName)
+};
+exports.meta = meta;
+function rule(value, secondaryOptions) {
+  return function (root, result) {
+    var validOptions = _stylelint.utils.validateOptions(result, ruleName, {
+      actual: value
+    }, {
+      actual: secondaryOptions,
+      possible: {
+        ignoreInside: ["at-rule", "nested-at-rule"],
+        ignoreInsideAtRules: [_utils.isString],
+        ignoreDefaults: [_utils.isBoolean]
+      },
+      optional: true
+    });
+    if (!validOptions) {
+      return;
+    }
+    var vars = {};
+
+    /**
+     * Traverse the [vars] tree through the path defined by [ancestors], creating nodes as needed.
+     * @param {*} ancestors
+     * @returns the tree of the node defined by the last of [ancestors].
+     */
+    function getScope(ancestors) {
+      var scope = vars;
+      var _iterator = _createForOfIteratorHelper(ancestors),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var node = _step.value;
+          if (!(node in scope)) {
+            scope[node] = {};
+          }
+          scope = scope[node];
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      return scope;
+    }
+
+    /**
+     * Iterates through the ancestors while checking each scope until the [variable] is found.
+     * If not found, an object with empty values is returned.
+     * @param {*} ancestors
+     * @param {string} variable the variable name.
+     * @returns The previously declared variable data or an object with empty values.
+     */
+    function getVariableData(ancestors, variable) {
+      var scope = vars;
+      var _iterator2 = _createForOfIteratorHelper(ancestors),
+        _step2;
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var node = _step2.value;
+          scope = scope[node];
+          if (scope[variable]) {
+            return scope[variable];
+          }
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+      return {
+        defaultCount: 0,
+        isDeclared: false
+      };
+    }
+
+    /**
+     * Checks whether the given [variableData] is declared.
+     * @param {{ defaultCount: number; isDeclared: boolean; }} variableData the variable data
+     * containing default count and if the variable is declared.
+     * @param {boolean} isDefault if the variable contains the `!default` keyword.
+     * @param {boolean | number} ignoreDefaults the ignore defaults options.
+     * @returns true if declared.
+     */
+    function isDeclared(variableData, isDefault, ignoreDefaults) {
+      if (isDefault) {
+        if (Number.isFinite(ignoreDefaults)) {
+          return variableData.defaultCount >= ignoreDefaults;
+        } else if (ignoreDefaults) {
+          return false;
+        }
+      }
+      return variableData.isDeclared;
+    }
+
+    /**
+     * Processes the variable data based on the given arguments.
+     * @param {{ defaultCount: number; isDeclared: boolean; }} variableData the variable data
+     * containing default count and if the variable is declared.
+     * @param {boolean} isDefault if the variable contains the `!default` keyword.
+     * @param {boolean | number} ignoreDefaults the ignore defaults options.
+     * @returns the updated `variableData`.
+     */
+    function processVariableData(variableData, isDefault, ignoreDefaults) {
+      return {
+        defaultCount: isDefault ? ++variableData.defaultCount : variableData.defaultCount,
+        isDeclared: isDefault && ignoreDefaults !== false ? variableData.isDeclared : true
+      };
+    }
+    var ignoreDefaults = secondaryOptions && secondaryOptions.ignoreDefaults !== undefined ? secondaryOptions.ignoreDefaults : 1;
+    root.walkDecls(function (decl) {
+      var isVar = decl.prop[0] === "$";
+      var isInsideIgnoredAtRule = decl.parent.type === "atrule" && secondaryOptions && secondaryOptions.ignoreInside && secondaryOptions.ignoreInside === "at-rule";
+      var isInsideIgnoredNestedAtRule = decl.parent.type === "atrule" && decl.parent.parent.type !== "root" && secondaryOptions && secondaryOptions.ignoreInside && secondaryOptions.ignoreInside === "nested-at-rule";
+      var isInsideIgnoredSpecifiedAtRule = decl.parent.type === "atrule" && secondaryOptions && secondaryOptions.ignoreInsideAtRules && secondaryOptions.ignoreInsideAtRules.includes(decl.parent.name);
+      if (!isVar || isInsideIgnoredAtRule || isInsideIgnoredNestedAtRule || isInsideIgnoredSpecifiedAtRule) {
+        return;
+      }
+      var ancestors = [];
+      var parent = decl.parent;
+      while (parent !== null && parent !== undefined) {
+        var parentKey = parent.toString();
+        ancestors.unshift(parentKey);
+        parent = parent.parent;
+      }
+      var scope = getScope(ancestors);
+      var isDefault = /!default/.test(decl.value);
+      var variableData = getVariableData(ancestors, decl.prop);
+      if (isDeclared(variableData, isDefault, ignoreDefaults)) {
+        _stylelint.utils.report({
+          message: messages.rejected(decl.prop),
+          node: decl,
+          result: result,
+          ruleName: ruleName
+        });
+      }
+      scope[decl.prop] = processVariableData(variableData, isDefault, ignoreDefaults);
+    });
+  };
+}
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;

node_modules/stylelint-scss/dist/rules/no-duplicate-mixins/index.js

@@ -0,0 +1,51 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = rule;
+exports.ruleName = exports.meta = exports.messages = void 0;
+var _stylelint = require("stylelint");
+var _utils = require("../../utils");
+var ruleName = (0, _utils.namespace)("no-duplicate-mixins");
+exports.ruleName = ruleName;
+var messages = _stylelint.utils.ruleMessages(ruleName, {
+  rejected: function rejected(mixin) {
+    return "Unexpected duplicate mixin ".concat(mixin);
+  }
+});
+exports.messages = messages;
+var meta = {
+  url: (0, _utils.ruleUrl)(ruleName)
+};
+exports.meta = meta;
+function rule(value) {
+  return function (root, result) {
+    var validOptions = _stylelint.utils.validateOptions(result, ruleName, {
+      actual: value
+    });
+    if (!validOptions) {
+      return;
+    }
+    var mixins = {};
+    root.walkAtRules(function (decl) {
+      var isMixin = decl.name === "mixin";
+      if (!isMixin) {
+        return;
+      }
+      var mixinName = (0, _utils.atRuleBaseName)(decl);
+      if (mixins[mixinName]) {
+        _stylelint.utils.report({
+          message: messages.rejected(mixinName),
+          node: decl,
+          result: result,
+          ruleName: ruleName
+        });
+      }
+      mixins[mixinName] = true;
+    });
+  };
+}
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;

node_modules/stylelint-scss/dist/rules/no-global-function-names/index.js

@@ -0,0 +1,192 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = rule;
+exports.ruleName = exports.meta = exports.messages = void 0;
+var _postcssValueParser = _interopRequireDefault(require("postcss-value-parser"));
+var _stylelint = require("stylelint");
+var _utils = require("../../utils");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _iterableToArrayLimit(arr, i) { var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"]; if (null != _i) { var _s, _e, _x, _r, _arr = [], _n = !0, _d = !1; try { if (_x = (_i = _i.call(arr)).next, 0 === i) { if (Object(_i) !== _i) return; _n = !1; } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0); } catch (err) { _d = !0, _e = err; } finally { try { if (!_n && null != _i["return"] && (_r = _i["return"](), Object(_r) !== _r)) return; } finally { if (_d) throw _e; } } return _arr; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+var interpolationPrefix = /^#{\s*/m;
+var rules = {
+  red: "color",
+  blue: "color",
+  green: "color",
+  mix: "color",
+  hue: "color",
+  saturation: "color",
+  lightness: "color",
+  complement: "color",
+  "adjust-color": "color",
+  "scale-color": "color",
+  "change-color": "color",
+  "ie-hex-str": "color",
+  "map-get": "map",
+  "map-merge": "map",
+  "map-remove": "map",
+  "map-keys": "map",
+  "map-values": "map",
+  "map-has-key": "map",
+  unquote: "string",
+  quote: "string",
+  "str-length": "string",
+  "str-insert": "string",
+  "str-index": "string",
+  "str-slice": "string",
+  "to-upper-case": "string",
+  "to-lower-case": "string",
+  "unique-id": "string",
+  percentage: "math",
+  round: "math",
+  ceil: "math",
+  floor: "math",
+  abs: "math",
+  random: "math",
+  unit: "math",
+  unitless: "math",
+  comparable: "math",
+  length: "list",
+  nth: "list",
+  "set-nth": "list",
+  join: "list",
+  append: "list",
+  zip: "list",
+  index: "list",
+  "list-separator": "list",
+  "feature-exists": "meta",
+  "variable-exists": "meta",
+  "global-variable-exists": "meta",
+  "function-exists": "meta",
+  "mixin-exists": "meta",
+  inspect: "meta",
+  "get-function": "meta",
+  "type-of": "meta",
+  call: "meta",
+  "content-exists": "meta",
+  keywords: "meta",
+  "selector-nest": "selector",
+  "selector-append": "selector",
+  "selector-replace": "selector",
+  "selector-unify": "selector",
+  "is-superselector": "selector",
+  "simple-selectors": "selector",
+  "selector-parse": "selector",
+  "selector-extend": "selector",
+  lighten: "color",
+  "adjust-hue": "color",
+  darken: "color",
+  desaturate: "color",
+  opacify: "color",
+  transparentize: "color"
+};
+var new_rule_names = {
+  "adjust-color": "adjust",
+  "scale-color": "scale",
+  "change-color": "change",
+  "map-get": "get",
+  "map-merge": "merge",
+  "map-remove": "remove",
+  "map-keys": "keys",
+  "map-values": "values",
+  "map-has-key": "has-key",
+  "str-length": "length",
+  "str-insert": "insert",
+  "str-index": "index",
+  "str-slice": "slice",
+  unitless: "is-unitless",
+  comparable: "compatible",
+  "list-separator": "separator",
+  "selector-nest": "nest",
+  "selector-append": "append",
+  "selector-replace": "replace",
+  "selector-unify": "unify",
+  "selector-parse": "parse",
+  "selector-extend": "extend",
+  lighten: "adjust",
+  "adjust-hue": "adjust",
+  darken: "adjust",
+  desaturate: "adjust",
+  opacify: "adjust",
+  saturate: "adjust",
+  transparentize: "adjust"
+};
+var rule_mapping = {
+  lighten: ["lighten($color, $amount)", "adjust($color, $lightness: $amount)"],
+  "adjust-hue": ["adjust-hue($color, $amount)", "adjust($color, $hue: $amount)"],
+  darken: ["darken($color, $amount)", "adjust($color, $lightness: -$amount)"],
+  desaturate: ["desaturate($color, $amount)", "adjust($color, $saturation: -$amount)"],
+  opacify: ["opacify($color, $amount)", "adjust($color, $alpha: -$amount)"],
+  saturate: ["saturate($color, $amount)", "adjust($color, $saturation: $amount)"],
+  transparentize: ["transparentize($color, $amount)", "adjust($color, $alpha: -$amount)"]
+};
+var ruleName = (0, _utils.namespace)("no-global-function-names");
+exports.ruleName = ruleName;
+var messages = _stylelint.utils.ruleMessages(ruleName, {
+  rejectedFullMessage: function rejectedFullMessage(string) {
+    return string;
+  },
+  rejected: function rejected(name) {
+    return errorMessage(name);
+  }
+});
+exports.messages = messages;
+var meta = {
+  url: (0, _utils.ruleUrl)(ruleName)
+};
+exports.meta = meta;
+function errorMessage(name) {
+  var sass_package = rules[name];
+  var rename = new_rule_names[name];
+  var map_rule = rule_mapping[name];
+  if (rename) {
+    if (map_rule) {
+      var _map_rule = _slicedToArray(map_rule, 2),
+        old_rule = _map_rule[0],
+        new_rule = _map_rule[1];
+      return "Expected ".concat(sass_package, ".").concat(new_rule, " instead of ").concat(old_rule);
+    }
+    return "Expected ".concat(sass_package, ".").concat(rename, " instead of ").concat(name);
+  } else {
+    return "Expected ".concat(sass_package, ".").concat(name, " instead of ").concat(name);
+  }
+}
+function rule(value) {
+  return function (root, result) {
+    var validOptions = _stylelint.utils.validateOptions(result, ruleName, {
+      actual: value
+    });
+    if (!validOptions) {
+      return;
+    }
+    root.walkDecls(function (decl) {
+      (0, _postcssValueParser["default"])(decl.value).walk(function (node) {
+        var cleanValue = node.value.replace(interpolationPrefix, "");
+
+        // Verify that we're only looking at functions.
+        if (node.type !== "function" || cleanValue === "") {
+          return;
+        }
+        if (Object.keys(rules).includes(cleanValue)) {
+          _stylelint.utils.report({
+            message: messages.rejected(cleanValue),
+            node: decl,
+            index: (0, _utils.declarationValueIndex)(decl) + node.sourceIndex,
+            result: result,
+            ruleName: ruleName
+          });
+        }
+      });
+    });
+  };
+}
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;

node_modules/stylelint-scss/dist/rules/operator-no-newline-after/index.js

@@ -0,0 +1,74 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = rule;
+exports.ruleName = exports.meta = exports.messages = void 0;
+var _stylelint = require("stylelint");
+var _utils = require("../../utils");
+var _operatorNoUnspaced = require("../operator-no-unspaced");
+var ruleName = (0, _utils.namespace)("operator-no-newline-after");
+exports.ruleName = ruleName;
+var messages = _stylelint.utils.ruleMessages(ruleName, {
+  rejected: function rejected(operator) {
+    return "Unexpected newline after \"".concat(operator, "\"");
+  }
+});
+exports.messages = messages;
+var meta = {
+  url: (0, _utils.ruleUrl)(ruleName)
+};
+
+/**
+ * The checker function: whether there is a newline before THAT operator.
+ */
+exports.meta = meta;
+function checkNewlineBefore(_ref) {
+  var string = _ref.string,
+    globalIndex = _ref.globalIndex,
+    startIndex = _ref.startIndex,
+    endIndex = _ref.endIndex,
+    node = _ref.node,
+    result = _ref.result;
+  var symbol = string.substring(startIndex, endIndex + 1);
+  var newLineBefore = false;
+  var index = endIndex + 1;
+  while (index && (0, _utils.isWhitespace)(string[index])) {
+    if (string[index] === "\n") {
+      newLineBefore = true;
+      break;
+    }
+    index++;
+  }
+  if (newLineBefore) {
+    _stylelint.utils.report({
+      ruleName: ruleName,
+      result: result,
+      node: node,
+      message: messages.rejected(symbol),
+      index: endIndex + globalIndex
+    });
+  }
+}
+function rule(expectation) {
+  return function (root, result) {
+    var validOptions = _stylelint.utils.validateOptions(result, ruleName, {
+      actual: expectation
+    });
+    if (!validOptions) {
+      return;
+    }
+    (0, _utils.eachRoot)(root, checkRoot);
+    function checkRoot(root) {
+      (0, _operatorNoUnspaced.calculationOperatorSpaceChecker)({
+        root: root,
+        result: result,
+        checker: checkNewlineBefore
+      });
+    }
+  };
+}
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;

node_modules/stylelint-scss/dist/rules/operator-no-newline-before/index.js

@@ -0,0 +1,74 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = rule;
+exports.ruleName = exports.meta = exports.messages = void 0;
+var _stylelint = require("stylelint");
+var _utils = require("../../utils");
+var _operatorNoUnspaced = require("../operator-no-unspaced");
+var ruleName = (0, _utils.namespace)("operator-no-newline-before");
+exports.ruleName = ruleName;
+var messages = _stylelint.utils.ruleMessages(ruleName, {
+  rejected: function rejected(operator) {
+    return "Unexpected newline before \"".concat(operator, "\"");
+  }
+});
+exports.messages = messages;
+var meta = {
+  url: (0, _utils.ruleUrl)(ruleName)
+};
+
+/**
+ * The checker function: whether there is a newline before THAT operator.
+ */
+exports.meta = meta;
+function checkNewlineBefore(_ref) {
+  var string = _ref.string,
+    globalIndex = _ref.globalIndex,
+    startIndex = _ref.startIndex,
+    endIndex = _ref.endIndex,
+    node = _ref.node,
+    result = _ref.result;
+  var symbol = string.substring(startIndex, endIndex + 1);
+  var newLineBefore = false;
+  var index = startIndex - 1;
+  while (index && (0, _utils.isWhitespace)(string[index])) {
+    if (string[index] === "\n") {
+      newLineBefore = true;
+      break;
+    }
+    index--;
+  }
+  if (newLineBefore) {
+    _stylelint.utils.report({
+      ruleName: ruleName,
+      result: result,
+      node: node,
+      message: messages.rejected(symbol),
+      index: endIndex + globalIndex
+    });
+  }
+}
+function rule(expectation) {
+  return function (root, result) {
+    var validOptions = _stylelint.utils.validateOptions(result, ruleName, {
+      actual: expectation
+    });
+    if (!validOptions) {
+      return;
+    }
+    (0, _utils.eachRoot)(root, checkRoot);
+    function checkRoot(root) {
+      (0, _operatorNoUnspaced.calculationOperatorSpaceChecker)({
+        root: root,
+        result: result,
+        checker: checkNewlineBefore
+      });
+    }
+  };
+}
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;

node_modules/stylelint-scss/dist/rules/operator-no-unspaced/index.js

@@ -0,0 +1,268 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.calculationOperatorSpaceChecker = calculationOperatorSpaceChecker;
+exports["default"] = rule;
+exports.ruleName = exports.meta = exports.messages = void 0;
+var _postcssMediaQueryParser = _interopRequireDefault(require("postcss-media-query-parser"));
+var _stylelint = require("stylelint");
+var _utils = require("../../utils");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+var ruleName = (0, _utils.namespace)("operator-no-unspaced");
+exports.ruleName = ruleName;
+var messages = _stylelint.utils.ruleMessages(ruleName, {
+  expectedAfter: function expectedAfter(operator) {
+    return "Expected single space after \"".concat(operator, "\"");
+  },
+  expectedBefore: function expectedBefore(operator) {
+    return "Expected single space before \"".concat(operator, "\"");
+  }
+});
+exports.messages = messages;
+var meta = {
+  url: (0, _utils.ruleUrl)(ruleName)
+};
+
+/**
+ * The actual check for are there (un)necessary whitespaces
+ */
+exports.meta = meta;
+function checkSpaces(_ref) {
+  var string = _ref.string,
+    globalIndex = _ref.globalIndex,
+    startIndex = _ref.startIndex,
+    endIndex = _ref.endIndex,
+    node = _ref.node,
+    result = _ref.result;
+  var symbol = string.substring(startIndex, endIndex + 1);
+  var beforeOk = string[startIndex - 1] === " " && !(0, _utils.isWhitespace)(string[startIndex - 2]) || newlineBefore(string, startIndex - 1);
+  if (!beforeOk) {
+    _stylelint.utils.report({
+      ruleName: ruleName,
+      result: result,
+      node: node,
+      message: messages.expectedBefore(symbol),
+      index: startIndex + globalIndex
+    });
+  }
+  var afterOk = string[endIndex + 1] === " " && !(0, _utils.isWhitespace)(string[endIndex + 2]) || string[endIndex + 1] === "\n" || string.substr(endIndex + 1, 2) === "\r\n";
+  if (!afterOk) {
+    _stylelint.utils.report({
+      ruleName: ruleName,
+      result: result,
+      node: node,
+      message: messages.expectedAfter(symbol),
+      index: endIndex + globalIndex
+    });
+  }
+}
+function newlineBefore(str, startIndex) {
+  var index = startIndex;
+  while (index && (0, _utils.isWhitespace)(str[index])) {
+    if (str[index] === "\n") return true;
+    index--;
+  }
+  return false;
+}
+function rule(expectation) {
+  return function (root, result) {
+    var validOptions = _stylelint.utils.validateOptions(result, ruleName, {
+      actual: expectation
+    });
+    if (!validOptions) {
+      return;
+    }
+    (0, _utils.eachRoot)(root, checkRoot);
+    function checkRoot(root) {
+      var rootString = root.source.input.css;
+      if (rootString.trim() === "") {
+        return;
+      }
+      calculationOperatorSpaceChecker({
+        root: root,
+        result: result,
+        checker: checkSpaces
+      });
+    }
+  };
+}
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+
+/**
+ * The core rule logic function. This one can be imported by some other rules
+ * that work with Sass operators
+ *
+ * @param {Object} args -- Named arguments object
+ * @param {PostCSS Root} args.root
+ * @param {PostCSS Result} args.result
+ * @param {function} args.checker -- the function that is run against all the
+ *    operators found in the input. Takes these arguments:
+ *    {Object} cbArgs -- Named arguments object
+ *    {string} cbArgs.string -- the input string (suspected operation)
+ *    {number} cbArgs.globalIndex -- the string's index in a global input
+ *    {number} cbArgs.startIndex -- the start index of a symbol to inspect
+ *    {number} cbArgs.endIndex -- the end index of a symbol to inspect
+ *      (two indexes needed to allow for `==`, `!=`, etc.)
+ *    {PostCSS Node} cbArgs.node -- for stylelint.utils.report
+ *    {PostCSS Result} cbArgs.result -- for stylelint.utils.report
+ */
+function calculationOperatorSpaceChecker(_ref2) {
+  var root = _ref2.root,
+    result = _ref2.result,
+    checker = _ref2.checker;
+  /**
+   * Takes a string, finds all occurrences of Sass interpolation in it, then
+   * finds all operators inside that interpolation
+   *
+   * @return {array} An array of objects { string, operators } - effectively,
+   *    a list of operators for each Sass interpolation occurrence
+   */
+  function findInterpolation(string, startIndex) {
+    var interpolationRegex = /#{(.*?)}/g;
+    var results = [];
+    // Searching for interpolation
+    var match = interpolationRegex.exec(string);
+    startIndex = !isNaN(startIndex) ? Number(startIndex) : 0;
+    while (match !== null) {
+      results.push({
+        source: match[0],
+        operators: (0, _utils.findOperators)({
+          string: match[0],
+          globalIndex: match.index + startIndex
+        })
+      });
+      match = interpolationRegex.exec(string);
+    }
+    return results;
+  }
+  var dataURIRegex = /^url\(\s*['"]?data:.+['"]?\s*\)/;
+  root.walk(function (item) {
+    if (item.prop === "unicode-range") {
+      return;
+    }
+    var results = [];
+
+    // Check a value (`10px` in `width: 10px;`)
+    if (item.value !== undefined) {
+      if (dataURIRegex.test(item.value)) {
+        return results;
+      }
+      results.push({
+        source: item.value,
+        operators: (0, _utils.findOperators)({
+          string: item.value,
+          globalIndex: (0, _utils.declarationValueIndex)(item),
+          // For Sass variable values some special rules apply
+          isAfterColon: item.prop[0] === "$"
+        })
+      });
+    }
+
+    // Property name
+    if (item.prop !== undefined) {
+      results = results.concat(findInterpolation(item.prop));
+    }
+
+    // Selector
+    if (item.selector !== undefined) {
+      results = results.concat(findInterpolation(item.selector));
+    }
+    if (item.type === "atrule") {
+      // @forward, @use and @at-root
+      if (item.name === "forward" || item.name === "use" || item.name === "at-root") {
+        return;
+      }
+
+      // Media queries
+      if (item.name === "media" || item.name === "import") {
+        (0, _postcssMediaQueryParser["default"])(item.params).walk(function (node) {
+          var type = node.type;
+          if (["keyword", "media-type", "media-feature"].includes(type)) {
+            results = results.concat(findInterpolation(node.value, (0, _utils.atRuleParamIndex)(item) + node.sourceIndex));
+          } else if (type === "value") {
+            results.push({
+              source: node.value,
+              operators: (0, _utils.findOperators)({
+                string: node.value,
+                globalIndex: (0, _utils.atRuleParamIndex)(item) + node.sourceIndex,
+                isAfterColon: true
+              })
+            });
+          } else if (type === "url") {
+            var isQuoted = node.value[0] === '"' || node.value[0] === "'";
+            var containsWhitespace = node.value.search(/\s/) > -1;
+            if (isQuoted || containsWhitespace) {
+              // The argument to the url function is only parsed as SassScript if it is a quoted
+              // string, or a _valid_ unquoted URL [1].
+              //
+              // [1] https://sass-lang.com/documentation/syntax/special-functions#url
+              results.push({
+                source: node.value,
+                operators: (0, _utils.findOperators)({
+                  string: node.value,
+                  globalIndex: (0, _utils.atRuleParamIndex)(item) + node.sourceIndex,
+                  isAfterColon: true
+                })
+              });
+            }
+          }
+        });
+      } else {
+        // Function and mixin definitions and other rules
+        results.push({
+          source: item.params,
+          operators: (0, _utils.findOperators)({
+            string: item.params,
+            globalIndex: (0, _utils.atRuleParamIndex)(item),
+            isAfterColon: true
+          })
+        });
+      }
+    }
+
+    // All the strings have been parsed, now run whitespace checking
+    results.forEach(function (el) {
+      // Only if there are operators within a string
+      if (el.operators && el.operators.length > 0) {
+        el.operators.forEach(function (operator) {
+          checker({
+            string: el.source,
+            globalIndex: operator.globalIndex,
+            startIndex: operator.startIndex,
+            endIndex: operator.endIndex,
+            node: item,
+            result: result
+          });
+        });
+      }
+    });
+  });
+
+  // Checking interpolation inside comments
+  // We have to give up on PostCSS here because it skips some inline comments
+  (0, _utils.findCommentsInRaws)(root.source.input.css).forEach(function (comment) {
+    var startIndex = comment.source.start + comment.raws.startToken.length + comment.raws.left.length;
+    if (comment.type !== "css") {
+      return;
+    }
+    findInterpolation(comment.text).forEach(function (el) {
+      // Only if there are operators within a string
+      if (el.operators && el.operators.length > 0) {
+        el.operators.forEach(function (operator) {
+          checker({
+            string: el.source,
+            globalIndex: operator.globalIndex + startIndex,
+            startIndex: operator.startIndex,
+            endIndex: operator.endIndex,
+            node: root,
+            result: result
+          });
+        });
+      }
+    });
+  });
+}

node_modules/stylelint-scss/dist/rules/partial-no-import/index.js

@@ -0,0 +1,73 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = rule;
+exports.ruleName = exports.meta = exports.messages = void 0;
+var _path = _interopRequireDefault(require("path"));
+var _stylelint = require("stylelint");
+var _utils = require("../../utils");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+var ruleName = (0, _utils.namespace)("partial-no-import");
+exports.ruleName = ruleName;
+var messages = _stylelint.utils.ruleMessages(ruleName, {
+  expected: "Unexpected @import in a partial"
+});
+exports.messages = messages;
+var meta = {
+  url: (0, _utils.ruleUrl)(ruleName)
+};
+exports.meta = meta;
+function rule(on) {
+  return function (root, result) {
+    var validOptions = _stylelint.utils.validateOptions(result, ruleName, {
+      actual: on
+    });
+    if (!validOptions) {
+      return;
+    }
+    if (root.source.input.file === undefined || !root.source.input.file) {
+      result.warn("The 'partial-no-import' rule won't work if linting in a code string without an actual file.");
+      return;
+    }
+    var fileName = _path["default"].basename(root.source.input.file);
+    var extName = _path["default"].extname(root.source.input.file);
+    function checkImportForCSS(path, decl) {
+      // Stripping trailing quotes and whitespaces, if any
+      var pathStripped = path.replace(/^\s*(["'])\s*/, "").replace(/\s*(["'])\s*$/, "");
+
+      // Skipping importing empty import, CSS: url(), ".css", URI with a protocol, media
+      if (pathStripped.trim() === "" || pathStripped.slice(0, 4) === "url(" || pathStripped.slice(-4) === ".css" || pathStripped.search("//") !== -1 || pathStripped.search(/[\s,)"']\w+$/) !== -1) {
+        return;
+      }
+      _stylelint.utils.report({
+        message: messages.expected,
+        node: decl,
+        index: decl.params.indexOf(path),
+        result: result,
+        ruleName: ruleName
+      });
+    }
+
+    // Usual CSS file
+    if (extName === ".css") {
+      return;
+    }
+
+    // Not a partial
+    if (fileName[0] !== "_") {
+      return;
+    }
+    root.walkAtRules("import", function (mixinCall) {
+      // Check if @import is treated as CSS import; report only if not
+      // Processing comma-separated lists of import paths
+      mixinCall.params.split(/["']\s*,/).forEach(function (path) {
+        checkImportForCSS(path, mixinCall);
+      });
+    });
+  };
+}
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;

node_modules/stylelint-scss/dist/rules/percent-placeholder-pattern/index.js

@@ -0,0 +1,92 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = rule;
+exports.ruleName = exports.meta = exports.messages = void 0;
+var _postcssResolveNestedSelector = _interopRequireDefault(require("postcss-resolve-nested-selector"));
+var _stylelint = require("stylelint");
+var _utils = require("../../utils");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+var ruleName = (0, _utils.namespace)("percent-placeholder-pattern");
+exports.ruleName = ruleName;
+var messages = _stylelint.utils.ruleMessages(ruleName, {
+  expected: function expected(placeholder) {
+    return "Expected %-placeholder \"%".concat(placeholder, "\" to match specified pattern");
+  }
+});
+exports.messages = messages;
+var meta = {
+  url: (0, _utils.ruleUrl)(ruleName)
+};
+exports.meta = meta;
+function rule(pattern) {
+  return function (root, result) {
+    var validOptions = _stylelint.utils.validateOptions(result, ruleName, {
+      actual: pattern,
+      possible: [_utils.isRegExp, _utils.isString]
+    });
+    if (!validOptions) {
+      return;
+    }
+    var placeholderPattern = (0, _utils.isString)(pattern) ? new RegExp(pattern) : pattern;
+
+    // Checking placeholder definitions (looking among regular rules)
+    root.walkRules(function (rule) {
+      var selector = rule.selector;
+
+      // Just a shorthand for calling `parseSelector`
+      function parse(selector) {
+        (0, _utils.parseSelector)(selector, result, rule, function (s) {
+          return checkSelector(s, rule);
+        });
+      }
+
+      // If it's a custom prop or a less mixin
+      if (!(0, _utils.isStandardRule)(rule)) {
+        return;
+      }
+
+      // If the selector has interpolation
+      if (!(0, _utils.isStandardSelector)(selector)) {
+        return;
+      }
+
+      // Nested selectors are processed in steps, as nesting levels are resolved.
+      // Here we skip processing intermediate parts of selectors (to process only fully resolved selectors)
+      // if (rule.nodes.some(node => node.type === "rule" || node.type === "atrule")) { return }
+
+      // Only resolve selectors that have an interpolating "&"
+      if ((0, _utils.hasInterpolatingAmpersand)(selector)) {
+        (0, _postcssResolveNestedSelector["default"])(selector, rule).forEach(parse);
+      } else {
+        parse(selector);
+      }
+    });
+    function checkSelector(fullSelector, rule) {
+      // postcss-selector-parser gives %placeholders' nodes a "tag" type
+      fullSelector.walkTags(function (compoundSelector) {
+        var value = compoundSelector.value,
+          sourceIndex = compoundSelector.sourceIndex;
+        if (value[0] !== "%") {
+          return;
+        }
+        var placeholder = value.slice(1);
+        if (placeholderPattern.test(placeholder)) {
+          return;
+        }
+        _stylelint.utils.report({
+          result: result,
+          ruleName: ruleName,
+          message: messages.expected(placeholder),
+          node: rule,
+          index: sourceIndex
+        });
+      });
+    }
+  };
+}
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;

node_modules/stylelint-scss/dist/rules/selector-nest-combinators/index.js

@@ -0,0 +1,119 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = rule;
+exports.ruleName = exports.meta = exports.messages = void 0;
+var _stylelint = require("stylelint");
+var _utils = require("../../utils");
+var ruleName = (0, _utils.namespace)("selector-nest-combinators");
+exports.ruleName = ruleName;
+var messages = _stylelint.utils.ruleMessages(ruleName, {
+  expectedInterpolation: "Expected interpolation to be in a nested form",
+  expected: function expected(combinator, type) {
+    return "Expected combinator \"".concat(combinator, "\" of type \"").concat(type, "\" to be in a nested form");
+  },
+  rejected: "Unexpected nesting found in selector"
+});
+exports.messages = messages;
+var meta = {
+  url: (0, _utils.ruleUrl)(ruleName)
+};
+exports.meta = meta;
+function rule(expectation) {
+  return function (root, result) {
+    var validOptions = _stylelint.utils.validateOptions(result, ruleName, {
+      actual: expectation,
+      possible: ["always", "never"]
+    });
+    if (!validOptions) {
+      return;
+    }
+    function precedesParentSelector(current) {
+      do {
+        current = current.next();
+        if (current.type === "nesting") {
+          return true;
+        }
+      } while (current.next());
+      return false;
+    }
+
+    // attribute, class, combinator, comment, id, nesting, pseudo, root, selector, string, tag, or universal
+    var chainingTypes = ["attribute", "class", "id", "pseudo", "tag", "universal"];
+    var interpolationRe = /#{.+?}$/;
+    root.walkRules(function (rule) {
+      if (rule.parent && rule.parent.type === "atrule" && rule.parent.name === "keyframes") {
+        return;
+      }
+      if (typeof rule.selector === "string") {
+        var isNestedProperty = rule.selector.slice(-1) === ":";
+        if (isNestedProperty) {
+          return;
+        }
+      }
+      (0, _utils.parseSelector)(rule.selector, result, rule, function (fullSelector) {
+        var message;
+        fullSelector.walk(function (node) {
+          if (node.value === "}") {
+            return;
+          }
+          if (expectation === "always") {
+            if (node.type === "selector") {
+              return;
+            }
+            if (node.parent && node.parent.type === "selector" && node.parent.parent && node.parent.parent.type === "pseudo") {
+              return;
+            }
+            if (!node.prev()) {
+              return;
+            }
+            if (node.next() && precedesParentSelector(node)) {
+              return;
+            }
+            if (node.type === "combinator") {
+              if (node.next() && !chainingTypes.includes(node.next().type)) {
+                return;
+              }
+              if (!chainingTypes.includes(node.prev().type)) {
+                return;
+              }
+            }
+            if (chainingTypes.includes(node.type) && !chainingTypes.includes(node.prev().type)) {
+              return;
+            }
+            if (node.type !== "combinator" && !chainingTypes.includes(node.type)) {
+              return;
+            }
+            var hasInterpolation = interpolationRe.test(rule.selector);
+            if (node.type !== "combinator" && hasInterpolation) {
+              return;
+            }
+            if (hasInterpolation) {
+              message = messages.expectedInterpolation;
+            } else {
+              message = messages.expected(node.value, node.type);
+            }
+          }
+          if (expectation === "never") {
+            if (rule.parent.type === "root" || rule.parent.type === "atrule") {
+              return;
+            }
+            message = messages.rejected;
+          }
+          _stylelint.utils.report({
+            ruleName: ruleName,
+            result: result,
+            node: rule,
+            message: message,
+            index: node.sourceIndex
+          });
+        });
+      });
+    });
+  };
+}
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;

node_modules/stylelint-scss/dist/rules/selector-no-redundant-nesting-selector/index.js

@@ -0,0 +1,69 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = rule;
+exports.ruleName = exports.meta = exports.messages = void 0;
+var _stylelint = require("stylelint");
+var _optionsMatches = _interopRequireDefault(require("stylelint/lib/utils/optionsMatches"));
+var _utils = require("../../utils");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+var ruleName = (0, _utils.namespace)("selector-no-redundant-nesting-selector");
+exports.ruleName = ruleName;
+var messages = _stylelint.utils.ruleMessages(ruleName, {
+  rejected: "Unnecessary nesting selector (&)"
+});
+exports.messages = messages;
+var meta = {
+  url: (0, _utils.ruleUrl)(ruleName)
+};
+exports.meta = meta;
+function rule(actual, options) {
+  return function (root, result) {
+    var validOptions = _stylelint.utils.validateOptions(result, ruleName, {
+      actual: actual
+    }, {
+      actual: options,
+      possible: {
+        ignoreKeywords: [_utils.isString, _utils.isRegExp]
+      },
+      optional: true
+    });
+    if (!validOptions) {
+      return;
+    }
+    root.walkRules(/&/, function (rule) {
+      (0, _utils.parseSelector)(rule.selector, result, rule, function (fullSelector) {
+        // "Ampersand followed by a combinator followed by non-combinator non-ampersand and not the selector end"
+        fullSelector.walkNesting(function (node) {
+          var prev = node.prev();
+          if (prev || (0, _utils.hasNestedSibling)(node)) {
+            return;
+          }
+          var next = node.next();
+          if (!next && node.parent.parent.nodes.length > 1) {
+            return;
+          }
+          if (next && next.type !== "combinator") {
+            return;
+          }
+          var nextNext = next ? next.next() : null;
+          if ((0, _utils.isType)(nextNext, "tag") && (0, _optionsMatches["default"])(options, "ignoreKeywords", nextNext.value.trim()) || (0, _utils.isType)(nextNext, "combinator")) {
+            return;
+          }
+          _stylelint.utils.report({
+            ruleName: ruleName,
+            result: result,
+            node: rule,
+            message: messages.rejected,
+            index: node.sourceIndex
+          });
+        });
+      });
+    });
+  };
+}
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;

node_modules/stylelint-scss/dist/rules/selector-no-union-class-name/index.js

@@ -0,0 +1,82 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = rule;
+exports.ruleName = exports.meta = exports.messages = void 0;
+var _postcssSelectorParser = require("postcss-selector-parser");
+var _stylelint = require("stylelint");
+var _utils = require("../../utils");
+var ruleName = (0, _utils.namespace)("selector-no-union-class-name");
+exports.ruleName = ruleName;
+var messages = _stylelint.utils.ruleMessages(ruleName, {
+  rejected: "Unexpected union class name with the parent selector (&)"
+});
+exports.messages = messages;
+var meta = {
+  url: (0, _utils.ruleUrl)(ruleName)
+};
+exports.meta = meta;
+var validNestingTypes = [_postcssSelectorParser.isClassName, _postcssSelectorParser.isCombinator, _postcssSelectorParser.isAttribute, _postcssSelectorParser.isIdentifier, _postcssSelectorParser.isPseudoClass, _postcssSelectorParser.isPseudoElement];
+function rule(actual) {
+  return function (root, result) {
+    var validOptions = _stylelint.utils.validateOptions(result, ruleName, {
+      actual: actual
+    });
+    if (!validOptions) {
+      return;
+    }
+    root.walkRules(/&/, function (rule) {
+      var parentNodes = [];
+      var selector = getSelectorFromRule(rule.parent);
+      if (selector) {
+        (0, _utils.parseSelector)(selector, result, rule, function (fullSelector) {
+          fullSelector.walk(function (node) {
+            return parentNodes.push(node);
+          });
+        });
+      }
+      if (parentNodes.length === 0) return;
+      var lastParentNode = parentNodes[parentNodes.length - 1];
+      if (!(0, _postcssSelectorParser.isClassName)(lastParentNode)) return;
+      (0, _utils.parseSelector)(rule.selector, result, rule, function (fullSelector) {
+        fullSelector.walkNesting(function (node) {
+          var next = node.next();
+          if (!next) return;
+          if (validNestingTypes.some(function (isType) {
+            return isType(next);
+          })) return;
+          _stylelint.utils.report({
+            ruleName: ruleName,
+            result: result,
+            node: rule,
+            message: messages.rejected,
+            index: node.sourceIndex
+          });
+        });
+      });
+    });
+  };
+}
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+
+/**
+ * Searches for the closest rule which
+ * has a selector and returns the selector
+ * @returns {string|undefined}
+ */
+function getSelectorFromRule(rule) {
+  // All non at-rules have their own selector
+  if (rule.selector !== undefined) {
+    return rule.selector;
+  }
+
+  // At-rules like @mixin don't have a selector themself
+  // but their parents might have one
+  if (rule.parent) {
+    return getSelectorFromRule(rule.parent);
+  }
+}

node_modules/stylelint-scss/dist/utils/addEmptyLineBefore.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.addEmptyLineBefore = addEmptyLineBefore;
+// Add an empty line before a node. Mutates the node.
+function addEmptyLineBefore(node /*: postcss$node*/, newline /*: '\n' | '\r\n'*/) /*: postcss$node*/{
+  if (!/\r?\n/.test(node.raws.before)) {
+    node.raws.before = newline.repeat(2) + node.raws.before;
+  } else {
+    node.raws.before = node.raws.before.replace(/(\r?\n)/, "".concat(newline, "$1"));
+  }
+  return node;
+}

node_modules/stylelint-scss/dist/utils/atRuleBaseName.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = _default;
+/**
+ * Get an at rule's base name
+ *
+ * @param {AtRule} atRule
+ * @return {string} The name
+ */
+function _default(atRule) {
+  return atRule.params.replace(/\([^)]*\)/, "").trim();
+}

node_modules/stylelint-scss/dist/utils/atRuleParamIndex.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = _default;
+/**
+ * Get the index of a media query's params
+ *
+ * @param {AtRule} atRule
+ * @return {int} The index
+ */
+function _default(atRule) {
+  // Initial 1 is for the `@`
+  var index = 1 + atRule.name.length;
+  if (atRule.raw("afterName")) {
+    index += atRule.raw("afterName").length;
+  }
+  return index;
+}

node_modules/stylelint-scss/dist/utils/beforeBlockString.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = _default;
+/**
+ * Given a CSS statement, return the string before the block.
+ * For rules, this is the selector list (and surrounding whitespace).
+ * For at-rules, this is the name and params (and surrounding whitespace).
+ *
+ * If there is no block, return empty string.
+ *
+ * @param {Rule|AtRule} statement - postcss rule or at-rule node
+ * @param {object} options
+ * @param {boolean} [options.noRawBefore] - Leave out the `before` string
+ * @return {string}
+ */
+function _default(statement) {
+  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+    noRawBefore = _ref.noRawBefore;
+  var result = "";
+  if (statement.type !== "rule" && statement.type !== "atrule") {
+    return result;
+  }
+  if (!noRawBefore) {
+    result += statement.raws.before;
+  }
+  if (statement.type === "rule") {
+    result += statement.selector;
+  } else {
+    result += "@".concat(statement.name).concat(statement.raws.afterName).concat(statement.params);
+  }
+  var between = statement.raws.between;
+  if (between !== undefined) {
+    result += between;
+  }
+  return result;
+}

node_modules/stylelint-scss/dist/utils/blockString.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = _default;
+var _beforeBlockString = _interopRequireDefault(require("./beforeBlockString"));
+var _hasBlock = _interopRequireDefault(require("./hasBlock"));
+var _rawNodeString = _interopRequireDefault(require("./rawNodeString"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+/**
+ * Return a CSS statement's block -- the string that starts with `{` and ends with `}`.
+ *
+ * If the statement has no block (e.g. `@import url(foo.css);`),
+ * return undefined.
+ *
+ * @param {Rule|AtRule} statement - postcss rule or at-rule node
+ * @return {string|undefined}
+ */
+function _default(statement) {
+  if (!(0, _hasBlock["default"])(statement)) {
+    return;
+  }
+  return (0, _rawNodeString["default"])(statement).slice((0, _beforeBlockString["default"])(statement).length);
+}

node_modules/stylelint-scss/dist/utils/configurationError.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = _default;
+/**
+ * Create configurationError from text and set CLI exit code
+ *
+ * @param {string} text
+ * @return {Error} - The error, with text and exit code
+ */
+function _default(text) {
+  var err = new Error(text);
+  err.code = 78;
+  return err;
+}

node_modules/stylelint-scss/dist/utils/declarationValueIndex.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = _default;
+/**
+ * Get the index of a declaration's value
+ *
+ * @param {Decl} decl
+ * @return {int} The index
+ */
+function _default(decl) {
+  var beforeColon = decl.toString().indexOf(":");
+  var afterColon = decl.raw("between").length - decl.raw("between").indexOf(":");
+  return beforeColon + afterColon;
+}

node_modules/stylelint-scss/dist/utils/eachRoot.js

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = _default;
+/**
+ * Executes a provided function once for each CSS block element.
+ *
+ * @param {Root|Document} root - root element of file.
+ * @param {function} cb - Function to execute for each CSS block element
+ */
+function _default(root, cb) {
+  // class `Document` is a part of `postcss-html`,
+  // It is collection of roots in HTML File.
+  // See: https://github.com/gucong3000/postcss-html/blob/master/lib/document.js
+  if (root.constructor.name === "Document") {
+    root.nodes.forEach(cb);
+  } else {
+    cb(root);
+  }
+}

node_modules/stylelint-scss/dist/utils/findCommentsInRaws.js

@@ -0,0 +1,209 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = findCommentsInRaws;
+/**
+ * Finds comments, both CSS comments and double slash ones, in a CSS string
+ * This helper exists because PostCSS drops some inline comments (those
+ * between selectors, property values, etc.)
+ * https://github.com/postcss/postcss/issues/845#issuecomment-232306259
+ *
+ * @param {string} rawString -- the source raw CSS string
+ * @return {array} array of objects with these props:
+ *    <20> type -- "css" or "double-slash"
+ *    <20> source: { start, end }
+ *      IMPORTANT: the function itself considers \r as a character, and counts
+ *      it for `start` and `end`. But if their values are passed to PostCSS's
+ *      result.warn(), than "\r\n" is consideren ONE CHAR (newline)!
+ *    <20> raws
+ *      raws.startToken -- `/*`, `/**`, `/**!`, etc.
+ *      raws.left -- whitespace after the comment opening marker
+ *      raws.text -- the full comment, including markers (//, /*)
+ *      raws.right -- whitespace before the comment closing marker
+ *      raws.endToken -- `*\/`, `**\/` for CSS comments
+ *    <20> text -- the comment text only, excluding //, /*, trailing whitespaces
+ *    <20> inlineAfter -- true, if there is something before the comment on
+ *      the same line
+ *    <20> inlineBefore -- true, if there is something after the comment on
+ *      the same line
+ */
+
+function findCommentsInRaws(rawString) {
+  var result = [];
+  var comment = {};
+  // Keeps track of which structure the parser is inside (string, comment,
+  // url function, parens). E.g., /* comment */ inside a string doesn't
+  // constitute a comment, so as url(//path)
+  var modesEntered = [{
+    mode: "normal",
+    character: null
+  }];
+  var commentStart = null;
+
+  // postcss-scss transforms //-comments into CSS comments, like so:
+  // `// comment` -> `/* comment*/`. So to have a correct intex we need to
+  // keep track on the added `*/` sequences
+  var offset = 0;
+  for (var i = 0; i < rawString.length; i++) {
+    var character = rawString[i];
+    var prevChar = i > 0 ? rawString[i - 1] : null;
+    var nextChar = i + 1 < rawString.length ? rawString[i + 1] : null;
+    var lastModeIndex = modesEntered.length - 1;
+    var mode = modesEntered[lastModeIndex] && modesEntered[lastModeIndex].mode;
+    switch (character) {
+      // If entering/exiting a string
+      case '"':
+      case "'":
+        {
+          if (mode === "comment") {
+            break;
+          }
+          if (mode === "string" && modesEntered[lastModeIndex].character === character && prevChar !== "\\") {
+            // Exiting a string
+            modesEntered.pop();
+          } else {
+            // Entering a string
+            modesEntered.push({
+              mode: "string",
+              character: character
+            });
+          }
+          break;
+        }
+      // Entering url, other function or parens (only url matters)
+      case "(":
+        {
+          if (mode === "comment" || mode === "string") {
+            break;
+          }
+          var functionNameRegSearch = /(?:^|[\n\r]|\s-|[:\s,.(){}*+/%])([\w-]*)$/.exec(rawString.substring(0, i));
+
+          // A `\S(` can be in, say, `@media(`
+          if (!functionNameRegSearch) {
+            modesEntered.push({
+              mode: "parens",
+              character: "("
+            });
+            break;
+          }
+          var functionName = functionNameRegSearch[1];
+          modesEntered.push({
+            mode: functionName === "url" ? "url" : "parens",
+            character: "("
+          });
+          break;
+        }
+      // Exiting url, other function or parens
+      case ")":
+        {
+          if (mode === "comment" || mode === "string") {
+            break;
+          }
+          modesEntered.pop();
+          break;
+        }
+      // checking for comment
+      case "/":
+        {
+          // Break if the / is inside a comment because we leap over the second
+          // slash in // and in */, so the / is not from a marker. Also break
+          // if inside a string
+          if (mode === "comment" || mode === "string") {
+            break;
+          }
+          if (nextChar === "*") {
+            modesEntered.push({
+              mode: "comment",
+              character: "/*"
+            });
+            comment = {
+              type: "css",
+              source: {
+                start: i + offset
+              },
+              // If i is 0 then the file/the line starts with this comment
+              inlineAfter: i > 0 && rawString.substring(0, i).search(/\n\s*$/) === -1
+            };
+            commentStart = i;
+            // Skip the next iteration as the * is already checked
+            i++;
+          } else if (nextChar === "/") {
+            // `url(//path/to/file)` has no comment
+            if (mode === "url") {
+              break;
+            }
+            modesEntered.push({
+              mode: "comment",
+              character: "//"
+            });
+            comment = {
+              type: "double-slash",
+              source: {
+                start: i + offset
+              },
+              // If i is 0 then the file/the line starts with this comment
+              inlineAfter: i > 0 && rawString.substring(0, i).search(/\n\s*$/) === -1
+            };
+            commentStart = i;
+            // Skip the next iteration as the second slash in // is already checked
+            i++;
+          }
+          break;
+        }
+      // Might be a closing `*/`
+      case "*":
+        {
+          if (mode === "comment" && modesEntered[lastModeIndex].character === "/*" && nextChar === "/") {
+            comment.source.end = i + 1 + offset;
+            var commentRaw = rawString.substring(commentStart, i + 2);
+            var matches = /^(\/\*+[!#]?)(\s*)([\s\S]*?)(\s*)(\*+\/)$/.exec(commentRaw);
+            modesEntered.pop();
+            comment.raws = {
+              startToken: matches[1],
+              left: matches[2],
+              text: commentRaw,
+              right: matches[4],
+              endToken: matches[5]
+            };
+            comment.text = matches[3];
+            comment.inlineBefore = rawString.substring(i + 2).search(/^\s*\S+\s*?\n/) !== -1;
+            result.push(Object.assign({}, comment));
+            comment = {};
+            // Skip the next loop as the / in */ is already checked
+            i++;
+          }
+          break;
+        }
+      default:
+        {
+          var isNewline = character === "\r" && rawString[i + 1] === "\n" || character === "\n" && rawString[i - 1] !== "\r";
+
+          // //-comments end before newline and if the code string ends
+          if (isNewline || i === rawString.length - 1) {
+            if (mode === "comment" && modesEntered[lastModeIndex].character === "//") {
+              comment.source.end = (isNewline ? i - 1 : i) + offset;
+              var _commentRaw = rawString.substring(commentStart, isNewline ? i : i + 1);
+              var _matches = /^(\/+)(\s*)(.*?)(\s*)$/.exec(_commentRaw);
+              modesEntered.pop();
+              comment.raws = {
+                startToken: _matches[1],
+                left: _matches[2],
+                text: _commentRaw,
+                right: _matches[4]
+              };
+              comment.text = _matches[3];
+              comment.inlineBefore = false;
+              result.push(Object.assign({}, comment));
+              comment = {};
+              // Compensate for the `*/` added by postcss-scss
+              offset += 2;
+            }
+          }
+          break;
+        }
+    }
+  }
+  return result;
+}

node_modules/stylelint-scss/dist/utils/functions.js

@@ -0,0 +1,75 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.STRING_FUNCTIONS = exports.SELECTOR_FUNCTIONS = exports.META_FUNCTIONS = exports.MATH_FUNCTIONS = exports.MAP_FUNCTIONS = exports.LIST_FUNCTIONS = exports.GLOBAL_FUNCTIONS = exports.COLOR_FUNCTIONS = exports.ALL_FUNCTIONS = void 0;
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+/**
+ * @see https://sass-lang.com/documentation/modules#global-functions
+ */
+var GLOBAL_FUNCTIONS = Object.freeze(["hsl", "hsla", "if", "rgb", "rgba"]);
+
+/**
+ * @see https://sass-lang.com/documentation/modules/color
+ */
+exports.GLOBAL_FUNCTIONS = GLOBAL_FUNCTIONS;
+var COLOR_FUNCTIONS = Object.freeze(["adjust-color", "adjust-hue", "alpha", "blackness", "blue", "change-color", "complement", "darken", "desaturate", "fade-in", "fade-out", "grayscale", "green", "hue", "ie-hex-str", "invert", "lighten", "lightness", "mix", "opacity", "red", "saturate", "saturation", "scale-color", "transparentize",
+// with namespace
+"color.adjust", "color.alpha", "color.blackness", "color.blue", "color.change", "color.complement", "color.grayscale", "color.green", "color.hue", "color.hwb", "color.ie-hex-str", "color.invert", "color.lightness", "color.mix", "color.red", "color.saturation", "color.scale", "color.whiteness"]);
+
+/**
+ * @see https://sass-lang.com/documentation/modules/list
+ */
+exports.COLOR_FUNCTIONS = COLOR_FUNCTIONS;
+var LIST_FUNCTIONS = Object.freeze(["append", "index", "is-bracketed", "join", "length", "list-separator", "nth", "set-nth", "list.zip",
+// with namespace
+"list.append", "list.index", "list.is-bracketed", "list.join", "list.length", "list.nth", "list.separator", "list.set-nth", "list.slash", "zip"]);
+
+/**
+ * @see https://sass-lang.com/documentation/modules/map
+ */
+exports.LIST_FUNCTIONS = LIST_FUNCTIONS;
+var MAP_FUNCTIONS = Object.freeze(["map-get", "map-has-key", "map-keys", "map-merge", "map-remove", "map-values",
+// with namespace
+"map.deep-merge", "map.deep-remove", "map.get", "map.has-key", "map.keys", "map.merge", "map.remove", "map.set", "map.values"]);
+
+/**
+ * @see https://sass-lang.com/documentation/modules/math
+ */
+exports.MAP_FUNCTIONS = MAP_FUNCTIONS;
+var MATH_FUNCTIONS = Object.freeze(["abs", "ceil", "comparable", "floor", "max", "min", "percentage", "random", "round", "unit", "unitless",
+// with namespace
+"math.abs", "math.acos", "math.asin", "math.atan", "math.atan2", "math.ceil", "math.clamp", "math.compatible", "math.cos", "math.div", "math.floor", "math.hypot", "math.is-unitless", "math.log", "math.max", "math.min", "math.percentage", "math.pow", "math.random", "math.round", "math.sin", "math.sqrt", "math.tan", "math.unit"]);
+
+/**
+ * @see https://sass-lang.com/documentation/modules/meta
+ */
+exports.MATH_FUNCTIONS = MATH_FUNCTIONS;
+var META_FUNCTIONS = Object.freeze(["call", "content-exists", "feature-exists", "function-exists", "get-function", "global-variable-exists", "inspect", "keywords", "mixin-exists", "type-of", "variable-exists",
+// with namespace
+"meta.calc-args", "meta.calc-name", "meta.call", "meta.content-exists", "meta.feature-exists", "meta.function-exists", "meta.get-function", "meta.global-variable-exists", "meta.inspect", "meta.keywords", "meta.mixin-exists", "meta.module-functions", "meta.module-variables", "meta.type-of", "meta.variable-exists"]);
+
+/**
+ * @see https://sass-lang.com/documentation/modules/selector
+ */
+exports.META_FUNCTIONS = META_FUNCTIONS;
+var SELECTOR_FUNCTIONS = Object.freeze(["is-superselector", "selector-append", "selector-extend", "selector-nest", "selector-parse", "selector-replace", "selector-unify", "simple-selectors",
+// with namespace
+"selector.append", "selector.extend", "selector.is-superselector", "selector.nest", "selector.parse", "selector.replace", "selector.simple-selectors", "selector.unify"]);
+
+/**
+ * @see https://sass-lang.com/documentation/modules/string
+ */
+exports.SELECTOR_FUNCTIONS = SELECTOR_FUNCTIONS;
+var STRING_FUNCTIONS = Object.freeze(["quote", "str-index", "str-insert", "str-length", "str-slice", "to-lower-case", "to-upper-case", "unique-id", "unquote",
+// with namespace
+"string.index", "string.insert", "string.length", "string.quote", "string.slice", "string.to-lower-case", "string.to-upper-case", "string.unique-id", "string.unquote"]);
+exports.STRING_FUNCTIONS = STRING_FUNCTIONS;
+var ALL_FUNCTIONS = Object.freeze([].concat(_toConsumableArray(GLOBAL_FUNCTIONS), _toConsumableArray(COLOR_FUNCTIONS), _toConsumableArray(LIST_FUNCTIONS), _toConsumableArray(MAP_FUNCTIONS), _toConsumableArray(MATH_FUNCTIONS), _toConsumableArray(META_FUNCTIONS), _toConsumableArray(SELECTOR_FUNCTIONS), _toConsumableArray(STRING_FUNCTIONS)));
+exports.ALL_FUNCTIONS = ALL_FUNCTIONS;

node_modules/stylelint-scss/dist/utils/hasBlock.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = _default;
+/**
+ * Check if a statement has an block (empty or otherwise).
+ *
+ * @param {Rule|AtRule} statement - postcss rule or at-rule node
+ * @return {boolean} True if `statement` has a block (empty or otherwise)
+ */
+function _default(statement) {
+  return statement.nodes !== undefined;
+}

node_modules/stylelint-scss/dist/utils/hasEmptyLine.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = _default;
+/**
+ * Check if a string contains at least one empty line
+ *
+ * @param {string} string
+ * @return {boolean}
+ */
+function _default(string) {
+  return string && (string.includes("\n\n") || string.includes("\n\r\n"));
+}

node_modules/stylelint-scss/dist/utils/hasInterpolatingAmpersand.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = _default;
+/**
+ * Check whether a selector has an interpolating ampersand
+ * An "interpolating ampersand" is an "&" used to interpolate within another
+ * simple selector (e.g. `&-modifier`), rather than an "&" that stands
+ * on its own as a simple selector (e.g. `& .child`)
+ *
+ * @param {string} selector
+ * @return {boolean} If `true`, the selector has an interpolating ampersand
+ */
+function _default(selector) {
+  for (var i = 0; i < selector.length; i++) {
+    if (selector[i] !== "&") {
+      continue;
+    }
+    if (selector[i - 1] !== undefined && !isCombinator(selector[i - 1])) {
+      return true;
+    }
+    if (selector[i + 1] !== undefined && !isCombinator(selector[i + 1])) {
+      return true;
+    }
+  }
+  return false;
+}
+function isCombinator(x) {
+  return /[\s+>~]/.test(x);
+}

node_modules/stylelint-scss/dist/utils/hasInterpolation.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = _default;
+var _hasLessInterpolation = _interopRequireDefault(require("./hasLessInterpolation"));
+var _hasPsvInterpolation = _interopRequireDefault(require("./hasPsvInterpolation"));
+var _hasScssInterpolation = _interopRequireDefault(require("./hasScssInterpolation"));
+var _hasTplInterpolation = _interopRequireDefault(require("./hasTplInterpolation"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+/**
+ * Check whether a string has interpolation
+ *
+ * @param {string} string
+ * @return {boolean} If `true`, a string has interpolation
+ */
+function _default(string) {
+  // SCSS or Less interpolation
+  return !!((0, _hasLessInterpolation["default"])(string) || (0, _hasScssInterpolation["default"])(string) || (0, _hasTplInterpolation["default"])(string) || (0, _hasPsvInterpolation["default"])(string));
+}

node_modules/stylelint-scss/dist/utils/hasLessInterpolation.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = _default;
+/**
+ * Check whether a string has less interpolation
+ *
+ * @param {string} string
+ * @return {boolean} If `true`, a string has less interpolation
+ */
+function _default(string) {
+  return /@{.+?}/.test(string);
+}

node_modules/stylelint-scss/dist/utils/hasNestedSibling.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = _default;
+/**
+ * Determines whether a given node has nested sibling.
+ *
+ * @param  {import('postcss').Node} node
+ * @return {boolean}
+ */
+function _default(node) {
+  return node && node.parent.nodes.some(function (n) {
+    return n !== node && n.type === "nesting";
+  });
+}

node_modules/stylelint-scss/dist/utils/hasPsvInterpolation.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = _default;
+/**
+ * Check whether a string has postcss-simple-vars interpolation
+ *
+ * @param {string} string
+ */
+function _default(string) {
+  return /\$\(.+?\)/.test(string);
+}

node_modules/stylelint-scss/dist/utils/hasScssInterpolation.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = _default;
+/**
+ * Check whether a string has scss interpolation
+ *
+ * @param {string} string
+ */
+function _default(string) {
+  return /#{.+?}/.test(string);
+}

node_modules/stylelint-scss/dist/utils/hasTplInterpolation.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = _default;
+/**
+ * Check whether a string has JS template literal interpolation or HTML-like template
+ *
+ * @param {string} string
+ * @return {boolean} If `true`, a string has template literal interpolation
+ */
+function _default(string) {
+  return /{.+?}/.test(string);
+}

node_modules/stylelint-scss/dist/utils/index.js

@@ -0,0 +1,292 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  addEmptyLineBefore: true,
+  atRuleBaseName: true,
+  atRuleParamIndex: true,
+  beforeBlockString: true,
+  blockString: true,
+  declarationValueIndex: true,
+  eachRoot: true,
+  findCommentsInRaws: true,
+  hasBlock: true,
+  hasEmptyLine: true,
+  hasInterpolatingAmpersand: true,
+  isInlineComment: true,
+  isNativeCssFunction: true,
+  isSingleLineString: true,
+  isStandardRule: true,
+  isStandardSelector: true,
+  isStandardSyntaxProperty: true,
+  isWhitespace: true,
+  namespace: true,
+  optionsHaveException: true,
+  optionsHaveIgnored: true,
+  parseFunctionArguments: true,
+  parseNestedPropRoot: true,
+  parseSelector: true,
+  rawNodeString: true,
+  removeEmptyLinesBefore: true,
+  findOperators: true,
+  whitespaceChecker: true,
+  hasNestedSibling: true,
+  isType: true,
+  moduleNamespace: true
+};
+Object.defineProperty(exports, "addEmptyLineBefore", {
+  enumerable: true,
+  get: function get() {
+    return _addEmptyLineBefore.addEmptyLineBefore;
+  }
+});
+Object.defineProperty(exports, "atRuleBaseName", {
+  enumerable: true,
+  get: function get() {
+    return _atRuleBaseName["default"];
+  }
+});
+Object.defineProperty(exports, "atRuleParamIndex", {
+  enumerable: true,
+  get: function get() {
+    return _atRuleParamIndex["default"];
+  }
+});
+Object.defineProperty(exports, "beforeBlockString", {
+  enumerable: true,
+  get: function get() {
+    return _beforeBlockString["default"];
+  }
+});
+Object.defineProperty(exports, "blockString", {
+  enumerable: true,
+  get: function get() {
+    return _blockString["default"];
+  }
+});
+Object.defineProperty(exports, "declarationValueIndex", {
+  enumerable: true,
+  get: function get() {
+    return _declarationValueIndex["default"];
+  }
+});
+Object.defineProperty(exports, "eachRoot", {
+  enumerable: true,
+  get: function get() {
+    return _eachRoot["default"];
+  }
+});
+Object.defineProperty(exports, "findCommentsInRaws", {
+  enumerable: true,
+  get: function get() {
+    return _findCommentsInRaws["default"];
+  }
+});
+Object.defineProperty(exports, "findOperators", {
+  enumerable: true,
+  get: function get() {
+    return _sassValueParser["default"];
+  }
+});
+Object.defineProperty(exports, "hasBlock", {
+  enumerable: true,
+  get: function get() {
+    return _hasBlock["default"];
+  }
+});
+Object.defineProperty(exports, "hasEmptyLine", {
+  enumerable: true,
+  get: function get() {
+    return _hasEmptyLine["default"];
+  }
+});
+Object.defineProperty(exports, "hasInterpolatingAmpersand", {
+  enumerable: true,
+  get: function get() {
+    return _hasInterpolatingAmpersand["default"];
+  }
+});
+Object.defineProperty(exports, "hasNestedSibling", {
+  enumerable: true,
+  get: function get() {
+    return _hasNestedSibling["default"];
+  }
+});
+Object.defineProperty(exports, "isInlineComment", {
+  enumerable: true,
+  get: function get() {
+    return _isInlineComment["default"];
+  }
+});
+Object.defineProperty(exports, "isNativeCssFunction", {
+  enumerable: true,
+  get: function get() {
+    return _isNativeCssFunction["default"];
+  }
+});
+Object.defineProperty(exports, "isSingleLineString", {
+  enumerable: true,
+  get: function get() {
+    return _isSingleLineString["default"];
+  }
+});
+Object.defineProperty(exports, "isStandardRule", {
+  enumerable: true,
+  get: function get() {
+    return _isStandardRule["default"];
+  }
+});
+Object.defineProperty(exports, "isStandardSelector", {
+  enumerable: true,
+  get: function get() {
+    return _isStandardSelector["default"];
+  }
+});
+Object.defineProperty(exports, "isStandardSyntaxProperty", {
+  enumerable: true,
+  get: function get() {
+    return _isStandardSyntaxProperty["default"];
+  }
+});
+Object.defineProperty(exports, "isType", {
+  enumerable: true,
+  get: function get() {
+    return _isType["default"];
+  }
+});
+Object.defineProperty(exports, "isWhitespace", {
+  enumerable: true,
+  get: function get() {
+    return _isWhitespace["default"];
+  }
+});
+Object.defineProperty(exports, "moduleNamespace", {
+  enumerable: true,
+  get: function get() {
+    return _moduleNamespace.moduleNamespace;
+  }
+});
+Object.defineProperty(exports, "namespace", {
+  enumerable: true,
+  get: function get() {
+    return _namespace["default"];
+  }
+});
+Object.defineProperty(exports, "optionsHaveException", {
+  enumerable: true,
+  get: function get() {
+    return _optionsHaveException["default"];
+  }
+});
+Object.defineProperty(exports, "optionsHaveIgnored", {
+  enumerable: true,
+  get: function get() {
+    return _optionsHaveIgnored["default"];
+  }
+});
+Object.defineProperty(exports, "parseFunctionArguments", {
+  enumerable: true,
+  get: function get() {
+    return _parseFunctionArguments.parseFunctionArguments;
+  }
+});
+Object.defineProperty(exports, "parseNestedPropRoot", {
+  enumerable: true,
+  get: function get() {
+    return _parseNestedPropRoot["default"];
+  }
+});
+Object.defineProperty(exports, "parseSelector", {
+  enumerable: true,
+  get: function get() {
+    return _parseSelector["default"];
+  }
+});
+Object.defineProperty(exports, "rawNodeString", {
+  enumerable: true,
+  get: function get() {
+    return _rawNodeString["default"];
+  }
+});
+Object.defineProperty(exports, "removeEmptyLinesBefore", {
+  enumerable: true,
+  get: function get() {
+    return _removeEmptyLinesBefore.removeEmptyLinesBefore;
+  }
+});
+Object.defineProperty(exports, "whitespaceChecker", {
+  enumerable: true,
+  get: function get() {
+    return _whitespaceChecker["default"];
+  }
+});
+var _addEmptyLineBefore = require("./addEmptyLineBefore");
+var _atRuleBaseName = _interopRequireDefault(require("./atRuleBaseName"));
+var _atRuleParamIndex = _interopRequireDefault(require("./atRuleParamIndex"));
+var _beforeBlockString = _interopRequireDefault(require("./beforeBlockString"));
+var _blockString = _interopRequireDefault(require("./blockString"));
+var _declarationValueIndex = _interopRequireDefault(require("./declarationValueIndex"));
+var _eachRoot = _interopRequireDefault(require("./eachRoot"));
+var _findCommentsInRaws = _interopRequireDefault(require("./findCommentsInRaws"));
+var _functions = require("./functions");
+Object.keys(_functions).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _functions[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _functions[key];
+    }
+  });
+});
+var _hasBlock = _interopRequireDefault(require("./hasBlock"));
+var _hasEmptyLine = _interopRequireDefault(require("./hasEmptyLine"));
+var _hasInterpolatingAmpersand = _interopRequireDefault(require("./hasInterpolatingAmpersand"));
+var _isInlineComment = _interopRequireDefault(require("./isInlineComment"));
+var _isNativeCssFunction = _interopRequireDefault(require("./isNativeCssFunction"));
+var _isSingleLineString = _interopRequireDefault(require("./isSingleLineString"));
+var _isStandardRule = _interopRequireDefault(require("./isStandardRule"));
+var _isStandardSelector = _interopRequireDefault(require("./isStandardSelector"));
+var _isStandardSyntaxProperty = _interopRequireDefault(require("./isStandardSyntaxProperty"));
+var _isWhitespace = _interopRequireDefault(require("./isWhitespace"));
+var _namespace = _interopRequireDefault(require("./namespace"));
+var _optionsHaveException = _interopRequireDefault(require("./optionsHaveException"));
+var _optionsHaveIgnored = _interopRequireDefault(require("./optionsHaveIgnored"));
+var _parseFunctionArguments = require("./parseFunctionArguments");
+var _parseNestedPropRoot = _interopRequireDefault(require("./parseNestedPropRoot"));
+var _parseSelector = _interopRequireDefault(require("./parseSelector"));
+var _rawNodeString = _interopRequireDefault(require("./rawNodeString"));
+var _removeEmptyLinesBefore = require("./removeEmptyLinesBefore");
+var _ruleUrl = require("./ruleUrl");
+Object.keys(_ruleUrl).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _ruleUrl[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _ruleUrl[key];
+    }
+  });
+});
+var _sassValueParser = _interopRequireDefault(require("./sassValueParser"));
+var _whitespaceChecker = _interopRequireDefault(require("./whitespaceChecker"));
+var _hasNestedSibling = _interopRequireDefault(require("./hasNestedSibling"));
+var _isType = _interopRequireDefault(require("./isType"));
+var _moduleNamespace = require("./moduleNamespace");
+var _validateTypes = require("./validateTypes");
+Object.keys(_validateTypes).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _validateTypes[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _validateTypes[key];
+    }
+  });
+});
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

node_modules/stylelint-scss/dist/utils/isCustomPropertySet.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = _default;
+/**
+ * Check whether a Node is a custom property set
+ *
+ * @param {import('postcss').Rule} node
+ * @returns {boolean}
+ */
+function _default(node) {
+  var _node$raws, _node$raws$prop, _node$raws2, _node$raws2$value;
+  var prop = (node === null || node === void 0 ? void 0 : (_node$raws = node.raws) === null || _node$raws === void 0 ? void 0 : (_node$raws$prop = _node$raws.prop) === null || _node$raws$prop === void 0 ? void 0 : _node$raws$prop.raw) || node.prop;
+  var value = (node === null || node === void 0 ? void 0 : (_node$raws2 = node.raws) === null || _node$raws2 === void 0 ? void 0 : (_node$raws2$value = _node$raws2.value) === null || _node$raws2$value === void 0 ? void 0 : _node$raws2$value.raw) || node.value;
+  return node.type === "decl" && prop.startsWith("--") && value.startsWith("{") && value.endsWith("}");
+}

node_modules/stylelint-scss/dist/utils/isInlineComment.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = isInlineComment;
+/**
+ * Check if a comment is inline one (i.e. on the same line as some non-comment
+ * code). Only works with comments that are not ignored by PostCSS. To work
+ * with those that are ignored use `findCommentInRaws`
+ *
+ * @param {Comment} comment - PostCSS comment node
+ * @return {boolean} true, if the comment is an inline one
+ */
+
+function isInlineComment(comment) {
+  var nextNode = comment.next();
+  var isBeforeSomething = !!nextNode && nextNode.type !== "comment" && comment.source.end.line === nextNode.source.start.line;
+  var isAfterSomething = comment.raws.before.search(/\n/) === -1;
+  return isAfterSomething || isBeforeSomething;
+}

node_modules/stylelint-scss/dist/utils/isNativeCssFunction.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = isNativeCssFunction;
+var nativeCssFunctions = new Set(["annotation", "attr", "blur", "brightness", "calc", "character-variant", "circle", "contrast", "cross-fade", "cubic-bezier", "drop-shadow", "element", "ellipse", "fit-content", "format", "frames", "grayscale", "hsl", "hsla", "hue-rotate", "image", "image-set", "inset", "invert", "leader", "linear-gradient", "local", "matrix", "matrix3d", "minmax", "opacity", "ornaments", "perspective", "polygon", "radial-gradient", "rect", "repeat", "repeating-linear-gradient", "repeating-radial-gradient", "rgb", "rgba", "rotate", "rotate3d", "rotateX", "rotatex", "rotateY", "rotatey", "rotateZ", "rotatez", "saturate", "scale", "scale3d", "scaleX", "scalex", "scaleY", "scaley", "scaleZ", "scalez", "sepia", "skew", "skewX", "skewY", "steps", "styleset", "stylistic", "swash", "symbols", "target-counter", "target-counters", "target-text", "translate", "translate3d", "translateX", "translatex", "translateY", "translatey", "translateZ", "translatez", "url", "var"]);
+
+/**
+ * Check if a function name is a native CSS function name.
+ *
+ * @param {string} functionName The name to check.
+ * @returns {boolean} Whether or not the given function name is a native CSS function name.
+ */
+function isNativeCssFunction(functionName) {
+  return nativeCssFunctions.has(functionName);
+}

node_modules/stylelint-scss/dist/utils/isSingleLineString.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = _default;
+/**
+ * Check if a string is a single line (i.e. does not contain
+ * any newline characters).
+ *
+ * @param {string} input
+ * @return {boolean}
+ */
+function _default(input) {
+  return !/[\n\r]/.test(input);
+}

node_modules/stylelint-scss/dist/utils/isStandardRule.js

@@ -0,0 +1,68 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = _default;
+var _isCustomPropertySet = _interopRequireDefault(require("./isCustomPropertySet"));
+var _isStandardSelector = _interopRequireDefault(require("./isStandardSelector"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+/**
+ * Check whether a Node is a standard rule
+ *
+ * @param {import('postcss').Rule} rule
+ * @returns {boolean}
+ */
+function _default(rule) {
+  var _rule$raws, _rule$raws$selector;
+  // Get full selector
+  var selector = (rule === null || rule === void 0 ? void 0 : (_rule$raws = rule.raws) === null || _rule$raws === void 0 ? void 0 : (_rule$raws$selector = _rule$raws.selector) === null || _rule$raws$selector === void 0 ? void 0 : _rule$raws$selector.raw) || rule.selector;
+  if (!(0, _isStandardSelector["default"])(rule.selector)) {
+    return false;
+  }
+
+  // Custom property set (e.g. --custom-property-set: {})
+  if ((0, _isCustomPropertySet["default"])(rule)) {
+    return false;
+  }
+
+  // Called Less mixin (e.g. a { .mixin() })
+  // @ts-ignore TODO TYPES support LESS and SASS types somehow
+  if (rule.mixin) {
+    return false;
+  }
+
+  // Less detached rulesets
+  if (selector.startsWith("@") && selector.endsWith(":")) {
+    return false;
+  }
+
+  // Ignore Less &:extend rule
+  // @ts-ignore TODO TYPES support LESS and SASS types somehow
+  if (rule.extend) {
+    return false;
+  }
+
+  // Ignore mixin or &:extend rule
+  // https://github.com/shellscape/postcss-less/blob/master/lib/less-parser.js#L52
+  // @ts-ignore TODO TYPES support LESS and SASS types somehow
+  if (rule.params && rule.params[0]) {
+    return false;
+  }
+
+  // Non-outputting Less mixin definition (e.g. .mixin() {})
+  if (selector.endsWith(")") && !selector.includes(":")) {
+    return false;
+  }
+
+  // Less guards
+  if (/when\s+(not\s+)*\(/.test(selector)) {
+    return false;
+  }
+
+  // Ignore Scss nested properties
+  if (selector.endsWith(":")) {
+    return false;
+  }
+  return true;
+}

node_modules/stylelint-scss/dist/utils/isStandardSelector.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = _default;
+var _isStandardSyntaxSelector = _interopRequireDefault(require("./isStandardSyntaxSelector"));
+var _hasInterpolation = _interopRequireDefault(require("./hasInterpolation"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+/**
+ * Check whether a selector is standard
+ *
+ * @param {string} selector
+ * @return {boolean} If `true`, the selector is standard
+ */
+function _default(selector) {
+  var standardSyntaxSelector = (0, _isStandardSyntaxSelector["default"])(selector);
+
+  // SCSS placeholder selectors
+  if (!standardSyntaxSelector) {
+    if (selector.indexOf("%") === 0 && !(0, _hasInterpolation["default"])(selector)) {
+      return true;
+    }
+  }
+  return standardSyntaxSelector;
+}

node_modules/stylelint-scss/dist/utils/isStandardSyntaxProperty.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = _default;
+var _hasInterpolation = _interopRequireDefault(require("./hasInterpolation"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+/**
+ * Check whether a property is standard
+ *
+ * @param {string} property
+ * @returns {boolean}
+ */
+function _default(property) {
+  // SCSS var (e.g. $var: x), list (e.g. $list: (x)) or map (e.g. $map: (key:value))
+  if (property.startsWith("$")) {
+    return false;
+  }
+
+  // Less var (e.g. @var: x)
+  if (property.startsWith("@")) {
+    return false;
+  }
+
+  // Less append property value with space (e.g. transform+_: scale(2))
+  if (property.endsWith("+") || property.endsWith("+_")) {
+    return false;
+  }
+
+  // SCSS or Less interpolation
+  if ((0, _hasInterpolation["default"])(property)) {
+    return false;
+  }
+  return true;
+}

node_modules/stylelint-scss/dist/utils/isStandardSyntaxSelector.js

@@ -0,0 +1,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = _default;
+var _hasInterpolation = _interopRequireDefault(require("./hasInterpolation"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+/**
+ * Check whether a selector is standard
+ *
+ * @param {string} selector
+ * @returns {boolean}
+ */
+function _default(selector) {
+  // SCSS or Less interpolation
+  if ((0, _hasInterpolation["default"])(selector)) {
+    return false;
+  }
+
+  // SCSS placeholder selectors
+  if (selector.startsWith("%")) {
+    return false;
+  }
+
+  // Less :extend()
+  if (/:extend(\(.*?\))?/.test(selector)) {
+    return false;
+  }
+
+  // Less mixin with resolved nested selectors (e.g. .foo().bar or .foo(@a, @b)[bar])
+  if (/\.[\w-]+\(.*\).+/.test(selector)) {
+    return false;
+  }
+
+  // ERB template tags
+  if (selector.includes("<%") || selector.includes("%>")) {
+    return false;
+  }
+  return true;
+}

node_modules/stylelint-scss/dist/utils/isType.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = _default;
+/**
+ * Determine whether the given node is of the given type.
+ *
+ * @param  {import('postcss').Node} node
+ * @param  {string} type
+ * @return {boolean}
+ */
+function _default(node, type) {
+  return node && node.type === type;
+}

node_modules/stylelint-scss/dist/utils/isWhitespace.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = _default;
+/**
+ * Check if a character is whitespace.
+ *
+ * @param {string} char - A single character
+ * @return {boolean}
+ */
+function _default(_char) {
+  return [" ", "\n", "\t", "\r", "\f"].includes(_char);
+}

node_modules/stylelint-scss/dist/utils/moduleNamespace.js

@@ -0,0 +1,54 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.moduleNamespace = moduleNamespace;
+/**
+ * Returns the namespace of an imported module or `null` if the namespace is removed.
+ *
+ * Example: no import found, possibly using global function
+ * `@use "sass:color";`
+ * `moduleNamespace(root, 'sass:map')` returns 'map'
+ *
+ * Example: default namespace
+ * `@use "sass:map";`
+ * `moduleNamespace(root, 'sass:map')` returns `map`
+ *
+ * Example: custom namespace
+ * `@use "sass:map" as ns;`
+ * `moduleNamespace(root, 'sass:map')` returns 'ns'
+ *
+ * Example: no namespace
+ * `@use "sass:map" as *;`
+ * `moduleNamespace(root, 'sass:map')` returns `null`
+ *
+ * Have a look at the tests for more examples.
+ */
+function moduleNamespace(root, module) {
+  var moduleNamespace = getDefaultNamespace(module);
+  root.walkAtRules("use", function (rule) {
+    var customNamespace = getCustomNamespace(module, rule);
+    switch (customNamespace) {
+      case null:
+        return;
+      case "*":
+        moduleNamespace = null;
+        return;
+      default:
+        moduleNamespace = customNamespace;
+    }
+  });
+  return moduleNamespace;
+}
+function getDefaultNamespace(module) {
+  return module.match(/([^/:]+)$/)[1].replace(/\.[^.]+$/, "");
+}
+function getCustomNamespace(module, rule) {
+  var ruleParamsParts = rule.params.split(new RegExp("[\"']".concat(module, "['\"][ \n]*as")));
+  if (ruleParamsParts.length < 2) {
+    return null;
+  }
+  var secondRuleParamsPart = ruleParamsParts[1].trim();
+  return !secondRuleParamsPart.startsWith("*") ? secondRuleParamsPart.split(" ")[0] : "*";
+}

node_modules/stylelint-scss/dist/utils/namespace.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = namespace;
+var prefix = "scss";
+function namespace(ruleName) {
+  return "".concat(prefix, "/").concat(ruleName);
+}

node_modules/stylelint-scss/dist/utils/optionsHaveException.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = _default;
+/**
+ * Check if an options object contains a certain `except` keyword.
+ * It will look for an `except` property whose value should
+ * be an array of keywords.
+ *
+ * @param {object} options
+ * @param {string} exceptionName
+ * @return {boolean}
+ */
+function _default(options, exceptionName) {
+  return options && options.except && options.except.includes(exceptionName);
+}

node_modules/stylelint-scss/dist/utils/optionsHaveIgnored.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = _default;
+/**
+ * Check if an options object contains a certain `ignore` keyword.
+ * It will look for an `ignore` property whose value should
+ * be an array of keywords.
+ *
+ * @param {object} options
+ * @param {string} ignoredName
+ * @return {boolean}
+ */
+function _default(options, ignoredName) {
+  return options && options.ignore && options.ignore.includes(ignoredName);
+}

node_modules/stylelint-scss/dist/utils/parseFunctionArguments.js

@@ -0,0 +1,61 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.groupByKeyValue = groupByKeyValue;
+exports.mapToKeyValue = mapToKeyValue;
+exports.parseFunctionArguments = parseFunctionArguments;
+var _postcssValueParser = _interopRequireDefault(require("postcss-value-parser"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+function groupByKeyValue(nodes) {
+  if (!nodes) {
+    return [];
+  }
+  var groupIndex = 0;
+  return nodes.reduce(function (acc, node, nodeIndex) {
+    var isComma = node.type === "div" && node.value === ",";
+    var skipTrailingComma = isComma && nodeIndex === nodes.length - 1;
+    if (skipTrailingComma) {
+      return acc;
+    }
+    if (isComma) {
+      groupIndex++;
+    }
+    acc[groupIndex] = acc[groupIndex] || [];
+    if (!isComma) {
+      acc[groupIndex].push(node);
+    }
+    return acc;
+  }, []);
+}
+function mapToKeyValue(nodes) {
+  var keyVal = nodes.reduce(function (acc, curr, i) {
+    if (acc.length === 1) {
+      return acc;
+    }
+    var nextNode = nodes[i + 1];
+    var isNextNodeColon = nextNode && nextNode.type === "div" && nextNode.value === ":";
+    if (isNextNodeColon) {
+      acc.push({
+        key: _postcssValueParser["default"].stringify(nodes[i]),
+        value: _postcssValueParser["default"].stringify(nodes.slice(2))
+      });
+      return acc;
+    }
+    acc.push({
+      value: _postcssValueParser["default"].stringify(nodes)
+    });
+    return acc;
+  }, []);
+  return keyVal[0];
+}
+function parseFunctionArguments(value) {
+  var parsed = (0, _postcssValueParser["default"])(value);
+  if (!parsed.nodes[0] || parsed.nodes[0].type !== "function") {
+    return [];
+  }
+  return parsed.nodes.map(function (node) {
+    return groupByKeyValue(node.nodes).map(mapToKeyValue);
+  })[0];
+}

node_modules/stylelint-scss/dist/utils/parseNestedPropRoot.js

@@ -0,0 +1,84 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = parseNestedPropRoot;
+/**
+ * Attempts to parse a selector as if it"s a root for a group of nested props
+ * E.g.: `margin: {`, `font: 10px/1.1 Arial {` ("{" excluded)
+ */
+
+function parseNestedPropRoot(propString) {
+  var modesEntered = [{
+    mode: "normal",
+    character: null,
+    isCalculationEnabled: true
+  }];
+  var result = {};
+  var lastModeIndex = 0;
+  var propName = "";
+  for (var i = 0; i < propString.length; i++) {
+    var character = propString[i];
+    var prevCharacter = propString[i - 1];
+
+    // If entering/exiting a string
+    if (character === '"' || character === "'") {
+      if (modesEntered[lastModeIndex].isCalculationEnabled === true) {
+        modesEntered.push({
+          mode: "string",
+          isCalculationEnabled: false,
+          character: character
+        });
+        lastModeIndex++;
+      } else if (modesEntered[lastModeIndex].mode === "string" && modesEntered[lastModeIndex].character === character && prevCharacter !== "\\") {
+        modesEntered.pop();
+        lastModeIndex--;
+      }
+    }
+
+    // If entering/exiting interpolation
+    if (character === "{") {
+      modesEntered.push({
+        mode: "interpolation",
+        isCalculationEnabled: true
+      });
+      lastModeIndex++;
+    } else if (character === "}") {
+      modesEntered.pop();
+      lastModeIndex--;
+    }
+
+    // Check for : outside fn call, string or interpolation. It must be at the
+    // end of a string or have a whitespace between it and following value
+    if (modesEntered[lastModeIndex].mode === "normal" && character === ":" && prevCharacter !== "\\") {
+      var propValueStr = propString.substring(i + 1);
+      if (propValueStr.length) {
+        var propValue = {
+          before: /^(\s*)/.exec(propValueStr)[1],
+          value: propValueStr.trim()
+        };
+
+        // It's a declaration if 1) there is a whitespace after :, or
+        // 2) the value is a number with/without a unit (starts with a number
+        // or a dot), or
+        // 3) the value is a variable (starts with $), or
+        // 4) the value a string, surprisingly
+        if (propValue.before === "" && !/^[\d.$'"]/.test(propValue.value)) {
+          return null;
+        }
+
+        // +1 for the colon
+        propValue.sourceIndex = propValue.before.length + i + 1;
+        result.propValue = propValue;
+      }
+      result.propName = {
+        after: /(\s*)$/.exec(propName)[1],
+        value: propName.trim()
+      };
+      return result;
+    }
+    propName += character;
+  }
+  return null;
+}

node_modules/stylelint-scss/dist/utils/parseSelector.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = _default;
+var _postcssSelectorParser = _interopRequireDefault(require("postcss-selector-parser"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+function _default(selector, result, node, cb) {
+  try {
+    return (0, _postcssSelectorParser["default"])(cb).processSync(selector);
+  } catch (e) {
+    result.warn("Cannot parse selector", {
+      node: node
+    });
+  }
+}

node_modules/stylelint-scss/dist/utils/rawNodeString.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = _default;
+/**
+ * Stringify PostCSS node including its raw "before" string.
+ *
+ * @param {Node} node - Any PostCSS node
+ * @return {string}
+ */
+function _default(node) {
+  var result = "";
+  if (node.raws.before) {
+    result += node.raws.before;
+  }
+  result += node.toString();
+  return result;
+}

node_modules/stylelint-scss/dist/utils/removeEmptyLinesBefore.js

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.removeEmptyLinesBefore = removeEmptyLinesBefore;
+// Remove empty lines before a node. Mutates the node.
+function removeEmptyLinesBefore(node /*: postcss$node*/, newline /*: '\n' | '\r\n'*/) /*: postcss$node*/{
+  node.raws.before = node.raws.before.replace(/(\r?\n\s*\n)+/g, newline);
+  return node;
+}