.gitignore added

[dotfiles/.git] / .config / coc / extensions / node_modules / coc-prettier / node_modules / stylelint / lib / rules / font-weight-notation / index.js

diff --git a/.config/coc/extensions/node_modules/coc-prettier/node_modules/stylelint/lib/rules/font-weight-notation/index.js b/.config/coc/extensions/node_modules/coc-prettier/node_modules/stylelint/lib/rules/font-weight-notation/index.js
new file mode 100644 (file)
index 0000000..c1512b0
--- /dev/null
+++ b/.config/coc/extensions/node_modules/coc-prettier/node_modules/stylelint/lib/rules/font-weight-notation/index.js
@@ -0,0 +1,138 @@
+"use strict";
+
+const _ = require("lodash");
+const declarationValueIndex = require("../../utils/declarationValueIndex");
+const isNumbery = require("../../utils/isNumbery");
+const isStandardSyntaxValue = require("../../utils/isStandardSyntaxValue");
+const isVariable = require("../../utils/isVariable");
+const keywordSets = require("../../reference/keywordSets");
+const optionsMatches = require("../../utils/optionsMatches");
+const postcss = require("postcss");
+const report = require("../../utils/report");
+const ruleMessages = require("../../utils/ruleMessages");
+const validateOptions = require("../../utils/validateOptions");
+
+const ruleName = "font-weight-notation";
+
+const messages = ruleMessages(ruleName, {
+  expected: type => `Expected ${type} font-weight notation`,
+  invalidNamed: name => `Unexpected invalid font-weight name "${name}"`
+});
+
+const INHERIT_KEYWORD = "inherit";
+const INITIAL_KEYWORD = "initial";
+const NORMAL_KEYWORD = "normal";
+const WEIGHTS_WITH_KEYWORD_EQUIVALENTS = ["400", "700"];
+
+const rule = function(expectation, options) {
+  return (root, result) => {
+    const validOptions = validateOptions(
+      result,
+      ruleName,
+      {
+        actual: expectation,
+        possible: ["numeric", "named-where-possible"]
+      },
+      {
+        actual: options,
+        possible: {
+          ignore: ["relative"]
+        },
+        optional: true
+      }
+    );
+    if (!validOptions) {
+      return;
+    }
+
+    root.walkDecls(decl => {
+      if (decl.prop.toLowerCase() === "font-weight") {
+        checkWeight(decl.value, decl);
+      }
+
+      if (decl.prop.toLowerCase() === "font") {
+        checkFont(decl);
+      }
+    });
+
+    function checkFont(decl) {
+      const valueList = postcss.list.space(decl.value);
+      // We do not need to more carefully distinguish font-weight
+      // numbers from unitless line-heights because line-heights in
+      // `font` values need to be part of a font-size/line-height pair
+      const hasNumericFontWeight = valueList.some(isNumbery);
+
+      for (const value of postcss.list.space(decl.value)) {
+        if (
+          (value.toLowerCase() === NORMAL_KEYWORD && !hasNumericFontWeight) ||
+          isNumbery(value) ||
+          (value.toLowerCase() !== NORMAL_KEYWORD &&
+            keywordSets.fontWeightKeywords.has(value.toLowerCase()))
+        ) {
+          checkWeight(value, decl);
+          return;
+        }
+      }
+    }
+
+    function checkWeight(weightValue, decl) {
+      if (!isStandardSyntaxValue(weightValue)) {
+        return;
+      }
+      if (isVariable(weightValue)) {
+        return;
+      }
+      if (
+        weightValue.toLowerCase() === INHERIT_KEYWORD ||
+        weightValue.toLowerCase() === INITIAL_KEYWORD
+      ) {
+        return;
+      }
+
+      if (
+        optionsMatches(options, "ignore", "relative") &&
+        keywordSets.fontWeightRelativeKeywords.has(weightValue.toLowerCase())
+      ) {
+        return;
+      }
+
+      const weightValueOffset = decl.value.indexOf(weightValue);
+
+      if (expectation === "numeric") {
+        if (!isNumbery(weightValue)) {
+          return complain(messages.expected("numeric"));
+        }
+      }
+
+      if (expectation === "named-where-possible") {
+        if (isNumbery(weightValue)) {
+          if (_.includes(WEIGHTS_WITH_KEYWORD_EQUIVALENTS, weightValue)) {
+            complain(messages.expected("named"));
+          }
+          return;
+        }
+        if (
+          !keywordSets.fontWeightKeywords.has(weightValue.toLowerCase()) &&
+          weightValue.toLowerCase() !== NORMAL_KEYWORD
+        ) {
+          return complain(messages.invalidNamed(weightValue));
+        }
+        return;
+      }
+
+      function complain(message) {
+        report({
+          ruleName,
+          result,
+          message,
+          node: decl,
+          index: declarationValueIndex(decl) + weightValueOffset
+        });
+      }
+    }
+  };
+};
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+module.exports = rule;