Updated to v1.9.9

conf/site/node_modules/postcss-selector-parser/API.md

@@ -684,7 +684,7 @@ Example: `[ /*before*/ href /* after-attr */ = /* after-operator */ te/*inside-v
 ```js
 {
   attribute: "href",
-  operatator: "=",
+  operator: "=",
   value: "test",
   spaces: {
     before: '',

conf/site/node_modules/postcss-selector-parser/CHANGELOG.md

@@ -1,3 +1,13 @@
+# 6.0.4
+
+- Fixed: ts errors
+
+# 6.0.3
+
+- Fixed: replace node built-in "util" module with "util-deprecate"
+- Fixed: handle uppercase pseudo elements
+- Fixed: do not create invalid combinator before comment
+
 # 6.0.2
 
 - Fixed an issue with parsing and stringifying an empty attribute value

conf/site/node_modules/postcss-selector-parser/dist/__tests__/classes.js

@@ -213,4 +213,14 @@ var _helpers = require("./util/helpers");
   t.deepEqual(tree.nodes[0].nodes[0].value, '𝌆');
   t.deepEqual(tree.nodes[0].nodes[0].type, 'class');
   t.deepEqual(tree.nodes[0].nodes[0].raws.value, '\\1D306');
+});
+(0, _helpers.test)('class selector with escaping (35)', '.not-pseudo\\:focus', function (t, tree) {
+  t.deepEqual(tree.nodes[0].nodes[0].value, 'not-pseudo:focus');
+  t.deepEqual(tree.nodes[0].nodes[0].type, 'class');
+  t.deepEqual(tree.nodes[0].nodes[0].raws.value, 'not-pseudo\\:focus');
+});
+(0, _helpers.test)('class selector with escaping (36)', '.not-pseudo\\:\\:focus', function (t, tree) {
+  t.deepEqual(tree.nodes[0].nodes[0].value, 'not-pseudo::focus');
+  t.deepEqual(tree.nodes[0].nodes[0].type, 'class');
+  t.deepEqual(tree.nodes[0].nodes[0].raws.value, 'not-pseudo\\:\\:focus');
 });

conf/site/node_modules/postcss-selector-parser/dist/__tests__/comments.js

@@ -35,4 +35,47 @@ var _helpers = require("./util/helpers");
   t.deepEqual(classname.type, 'class', 'should have a tag');
   t.deepEqual(classname.spaces.after, ' ');
   t.deepEqual(classname.raws.spaces.after, ' /* comment 3 */');
+});
+(0, _helpers.test)('comments in selector list', 'h2, /*test*/ h4', function (t, tree) {
+  t.deepEqual(tree.nodes[0].nodes[0].type, 'tag');
+  t.deepEqual(tree.nodes[0].nodes[0].value, 'h2');
+  t.deepEqual(tree.nodes[1].nodes[0].rawSpaceBefore, ' ');
+  t.deepEqual(tree.nodes[1].nodes[0].type, 'comment');
+  t.deepEqual(tree.nodes[1].nodes[0].value, '/*test*/');
+  t.deepEqual(tree.nodes[1].nodes[1].rawSpaceBefore, ' ');
+  t.deepEqual(tree.nodes[1].nodes[1].type, 'tag');
+  t.deepEqual(tree.nodes[1].nodes[1].value, 'h4');
+});
+(0, _helpers.test)('comments in selector list (2)', 'h2,/*test*/h4', function (t, tree) {
+  t.deepEqual(tree.nodes[0].nodes[0].type, 'tag');
+  t.deepEqual(tree.nodes[0].nodes[0].value, 'h2');
+  t.deepEqual(tree.nodes[1].nodes[0].rawSpaceBefore, '');
+  t.deepEqual(tree.nodes[1].nodes[0].type, 'comment');
+  t.deepEqual(tree.nodes[1].nodes[0].value, '/*test*/');
+  t.deepEqual(tree.nodes[1].nodes[1].type, 'tag');
+  t.deepEqual(tree.nodes[1].nodes[1].value, 'h4');
+  t.deepEqual(tree.nodes[1].nodes[1].rawSpaceBefore, '');
+});
+(0, _helpers.test)('comments in selector list (3)', 'h2/*test*/, h4', function (t, tree) {
+  t.deepEqual(tree.nodes[0].nodes[0].type, 'tag');
+  t.deepEqual(tree.nodes[0].nodes[0].value, 'h2');
+  t.deepEqual(tree.nodes[0].nodes[1].rawSpaceBefore, '');
+  t.deepEqual(tree.nodes[0].nodes[1].type, 'comment');
+  t.deepEqual(tree.nodes[0].nodes[1].value, '/*test*/');
+  t.deepEqual(tree.nodes[1].nodes[0].type, 'tag');
+  t.deepEqual(tree.nodes[1].nodes[0].value, 'h4');
+  t.deepEqual(tree.nodes[1].nodes[0].rawSpaceBefore, ' ');
+});
+(0, _helpers.test)('comments in selector list (4)', 'h2, /*test*/ /*test*/ h4', function (t, tree) {
+  t.deepEqual(tree.nodes[0].nodes[0].type, 'tag');
+  t.deepEqual(tree.nodes[0].nodes[0].value, 'h2');
+  t.deepEqual(tree.nodes[1].nodes[0].rawSpaceBefore, ' ');
+  t.deepEqual(tree.nodes[1].nodes[0].type, 'comment');
+  t.deepEqual(tree.nodes[1].nodes[0].value, '/*test*/');
+  t.deepEqual(tree.nodes[1].nodes[1].rawSpaceBefore, ' ');
+  t.deepEqual(tree.nodes[1].nodes[1].type, 'comment');
+  t.deepEqual(tree.nodes[1].nodes[1].value, '/*test*/');
+  t.deepEqual(tree.nodes[1].nodes[2].rawSpaceBefore, ' ');
+  t.deepEqual(tree.nodes[1].nodes[2].type, 'tag');
+  t.deepEqual(tree.nodes[1].nodes[2].value, 'h4');
 });

conf/site/node_modules/postcss-selector-parser/dist/__tests__/guards.js

@@ -91,6 +91,15 @@ var node = function node(tree, n) {
     t.false(_.default.isNamespace(n));
   });
 });
+(0, _helpers.test)('special pseudo element guard (uppercase)', ':BEFORE:AFTER', function (t, tree) {
+  [node(tree), node(tree, 1)].forEach(function (n) {
+    t.true(_.default.isPseudo(n));
+    t.false(_.default.isPseudoClass(n));
+    t.true(_.default.isPseudoElement(n));
+    t.true(_.default.isContainer(n));
+    t.false(_.default.isNamespace(n));
+  });
+});
 (0, _helpers.test)('string guard', '"string"', function (t, tree) {
   var n = node(tree);
   t.true(_.default.isNode(n));

conf/site/node_modules/postcss-selector-parser/dist/__tests__/id.js

@@ -6,6 +6,12 @@ var _helpers = require("./util/helpers");
   t.deepEqual(tree.nodes[0].nodes[0].value, 'one');
   t.deepEqual(tree.nodes[0].nodes[0].type, 'id');
 });
+(0, _helpers.test)('id selector with universal', '*#z98y ', function (t, tree) {
+  t.deepEqual(tree.nodes[0].nodes[0].value, '*');
+  t.deepEqual(tree.nodes[0].nodes[0].type, 'universal');
+  t.deepEqual(tree.nodes[0].nodes[1].value, 'z98y');
+  t.deepEqual(tree.nodes[0].nodes[1].type, 'id');
+});
 (0, _helpers.test)('id hack', '#one#two', function (t, tree) {
   t.deepEqual(tree.nodes[0].nodes[0].type, 'id');
   t.deepEqual(tree.nodes[0].nodes[1].type, 'id');

conf/site/node_modules/postcss-selector-parser/dist/__tests__/nonstandard.js

@@ -19,20 +19,28 @@ var _helpers = require("./util/helpers");
   t.deepEqual(tree.nodes[0].nodes[1].value, '*');
 });
 (0, _helpers.test)('sass escapes', '.#{$classname}', function (t, tree) {
-  t.deepEqual(tree.nodes[0].nodes.map(function (n) {
-    return n.type;
-  }), ["class"]);
+  t.deepEqual(tree.nodes[0].nodes[0].type, "class");
   t.deepEqual(tree.nodes[0].nodes[0].value, "#{$classname}");
 });
 (0, _helpers.test)('sass escapes (2)', '[lang=#{$locale}]', function (t, tree) {
-  t.deepEqual(tree.nodes[0].nodes.map(function (n) {
-    return n.type;
-  }), ["attribute"]);
+  t.deepEqual(tree.nodes[0].nodes[0].type, "attribute");
+  t.deepEqual(tree.nodes[0].nodes[0].attribute, "lang");
+  t.deepEqual(tree.nodes[0].nodes[0].operator, "=");
   t.deepEqual(tree.nodes[0].nodes[0].value, "#{$locale}");
 });
 (0, _helpers.test)('placeholder', '%foo', function (t, tree) {
-  t.deepEqual(tree.nodes[0].nodes.map(function (n) {
-    return n.type;
-  }), ["tag"]);
+  t.deepEqual(tree.nodes[0].nodes[0].type, "tag");
   t.deepEqual(tree.nodes[0].nodes[0].value, "%foo");
+});
+(0, _helpers.test)('styled selector', '${Step}', function (t, tree) {
+  t.deepEqual(tree.nodes[0].nodes[0].type, "tag");
+  t.deepEqual(tree.nodes[0].nodes[0].value, "${Step}");
+});
+(0, _helpers.test)('styled selector (2)', '${Step}:nth-child(odd)', function (t, tree) {
+  t.deepEqual(tree.nodes[0].nodes[0].type, "tag");
+  t.deepEqual(tree.nodes[0].nodes[0].value, "${Step}");
+  t.deepEqual(tree.nodes[0].nodes[1].type, "pseudo");
+  t.deepEqual(tree.nodes[0].nodes[1].value, ":nth-child");
+  t.deepEqual(tree.nodes[0].nodes[1].nodes[0].nodes[0].type, "tag");
+  t.deepEqual(tree.nodes[0].nodes[1].nodes[0].nodes[0].value, "odd");
 });

conf/site/node_modules/postcss-selector-parser/dist/__tests__/pseudos.js

@@ -95,4 +95,71 @@ var _helpers = require("./util/helpers");
   t.deepEqual(tree.nodes[0].nodes[0].type, 'tag');
   t.deepEqual(tree.nodes[1].nodes[0].value, ':--foobar');
   t.deepEqual(tree.nodes[1].nodes[0].type, 'pseudo');
+});
+(0, _helpers.test)('current pseudo class', ':current(p, li, dt, dd)', function (t, tree) {
+  t.deepEqual(tree.nodes[0].nodes[0].type, 'pseudo');
+  t.deepEqual(tree.nodes[0].nodes[0].value, ':current');
+  t.deepEqual(tree.nodes[0].nodes[0].nodes[0].nodes[0].type, 'tag');
+  t.deepEqual(tree.nodes[0].nodes[0].nodes[0].nodes[0].value, 'p');
+  t.deepEqual(tree.nodes[0].nodes[0].nodes[1].nodes[0].type, 'tag');
+  t.deepEqual(tree.nodes[0].nodes[0].nodes[1].nodes[0].value, 'li');
+  t.deepEqual(tree.nodes[0].nodes[0].nodes[2].nodes[0].type, 'tag');
+  t.deepEqual(tree.nodes[0].nodes[0].nodes[2].nodes[0].value, 'dt');
+  t.deepEqual(tree.nodes[0].nodes[0].nodes[3].nodes[0].type, 'tag');
+  t.deepEqual(tree.nodes[0].nodes[0].nodes[3].nodes[0].value, 'dd');
+});
+(0, _helpers.test)('is pseudo class', ':is(p, li, dt, dd)', function (t, tree) {
+  t.deepEqual(tree.nodes[0].nodes[0].type, 'pseudo');
+  t.deepEqual(tree.nodes[0].nodes[0].value, ':is');
+  t.deepEqual(tree.nodes[0].nodes[0].nodes[0].nodes[0].type, 'tag');
+  t.deepEqual(tree.nodes[0].nodes[0].nodes[0].nodes[0].value, 'p');
+  t.deepEqual(tree.nodes[0].nodes[0].nodes[1].nodes[0].type, 'tag');
+  t.deepEqual(tree.nodes[0].nodes[0].nodes[1].nodes[0].value, 'li');
+  t.deepEqual(tree.nodes[0].nodes[0].nodes[2].nodes[0].type, 'tag');
+  t.deepEqual(tree.nodes[0].nodes[0].nodes[2].nodes[0].value, 'dt');
+  t.deepEqual(tree.nodes[0].nodes[0].nodes[3].nodes[0].type, 'tag');
+  t.deepEqual(tree.nodes[0].nodes[0].nodes[3].nodes[0].value, 'dd');
+});
+(0, _helpers.test)('is pseudo class with namespace', '*|*:is(:hover, :focus) ', function (t, tree) {
+  t.deepEqual(tree.nodes[0].nodes[0].type, 'universal');
+  t.deepEqual(tree.nodes[0].nodes[0].namespace, '*');
+  t.deepEqual(tree.nodes[0].nodes[0].value, '*');
+  t.deepEqual(tree.nodes[0].nodes[1].type, 'pseudo');
+  t.deepEqual(tree.nodes[0].nodes[1].value, ':is');
+  t.deepEqual(tree.nodes[0].nodes[1].nodes[0].nodes[0].type, 'pseudo');
+  t.deepEqual(tree.nodes[0].nodes[1].nodes[0].nodes[0].value, ':hover');
+  t.deepEqual(tree.nodes[0].nodes[1].nodes[1].nodes[0].type, 'pseudo');
+  t.deepEqual(tree.nodes[0].nodes[1].nodes[1].nodes[0].value, ':focus');
+});
+(0, _helpers.test)('has pseudo class', 'a:has(> img)', function (t, tree) {
+  t.deepEqual(tree.nodes[0].nodes[0].type, 'tag');
+  t.deepEqual(tree.nodes[0].nodes[0].value, 'a');
+  t.deepEqual(tree.nodes[0].nodes[1].type, 'pseudo');
+  t.deepEqual(tree.nodes[0].nodes[1].value, ':has');
+  t.deepEqual(tree.nodes[0].nodes[1].nodes[0].nodes[0].type, 'combinator');
+  t.deepEqual(tree.nodes[0].nodes[1].nodes[0].nodes[0].value, '>');
+  t.deepEqual(tree.nodes[0].nodes[1].nodes[0].nodes[1].type, 'tag');
+  t.deepEqual(tree.nodes[0].nodes[1].nodes[0].nodes[1].value, 'img');
+});
+(0, _helpers.test)('where pseudo class', 'a:where(:not(:hover))', function (t, tree) {
+  t.deepEqual(tree.nodes[0].nodes[0].type, 'tag');
+  t.deepEqual(tree.nodes[0].nodes[0].value, 'a');
+  t.deepEqual(tree.nodes[0].nodes[1].type, 'pseudo');
+  t.deepEqual(tree.nodes[0].nodes[1].value, ':where');
+  t.deepEqual(tree.nodes[0].nodes[1].nodes[0].nodes[0].type, 'pseudo');
+  t.deepEqual(tree.nodes[0].nodes[1].nodes[0].nodes[0].value, ':not');
+  t.deepEqual(tree.nodes[0].nodes[1].nodes[0].nodes[0].nodes[0].nodes[0].type, 'pseudo');
+  t.deepEqual(tree.nodes[0].nodes[1].nodes[0].nodes[0].nodes[0].nodes[0].value, ':hover');
+});
+(0, _helpers.test)('nested pseudo classes', "section:not( :has(h1, h2 ) )", function (t, tree) {
+  t.deepEqual(tree.nodes[0].nodes[0].type, 'tag');
+  t.deepEqual(tree.nodes[0].nodes[0].value, 'section');
+  t.deepEqual(tree.nodes[0].nodes[1].type, 'pseudo');
+  t.deepEqual(tree.nodes[0].nodes[1].value, ':not');
+  t.deepEqual(tree.nodes[0].nodes[1].nodes[0].nodes[0].type, 'pseudo');
+  t.deepEqual(tree.nodes[0].nodes[1].nodes[0].nodes[0].value, ':has');
+  t.deepEqual(tree.nodes[0].nodes[1].nodes[0].nodes[0].nodes[0].nodes[0].type, 'tag');
+  t.deepEqual(tree.nodes[0].nodes[1].nodes[0].nodes[0].nodes[0].nodes[0].value, 'h1');
+  t.deepEqual(tree.nodes[0].nodes[1].nodes[0].nodes[0].nodes[1].nodes[0].type, 'tag');
+  t.deepEqual(tree.nodes[0].nodes[1].nodes[0].nodes[0].nodes[1].nodes[0].value, 'h2');
 });

conf/site/node_modules/postcss-selector-parser/dist/__tests__/universal.js

@@ -11,6 +11,16 @@ var _helpers = require("./util/helpers");
   t.deepEqual(tree.nodes[0].nodes[1].type, 'combinator');
   t.deepEqual(tree.nodes[0].nodes[2].type, 'universal');
 });
+(0, _helpers.test)('universal selector with descendant combinator', '* *', function (t, tree) {
+  t.deepEqual(tree.nodes[0].nodes[0].type, 'universal');
+  t.deepEqual(tree.nodes[0].nodes[1].type, 'combinator');
+  t.deepEqual(tree.nodes[0].nodes[2].type, 'universal');
+});
+(0, _helpers.test)('universal selector with descendant combinator and extraneous non-combinating whitespace', '*         *', function (t, tree) {
+  t.deepEqual(tree.nodes[0].nodes[0].type, 'universal');
+  t.deepEqual(tree.nodes[0].nodes[1].type, 'combinator');
+  t.deepEqual(tree.nodes[0].nodes[2].type, 'universal');
+});
 (0, _helpers.test)('extraneous non-combinating whitespace', '  *   ,  *   ', function (t, tree) {
   t.deepEqual(tree.nodes[0].nodes[0].value, '*');
   t.deepEqual(tree.nodes[0].nodes[0].spaces.before, '  ');

conf/site/node_modules/postcss-selector-parser/dist/parser.js

@@ -885,7 +885,9 @@ function () {
   _proto.space = function space() {
     var content = this.content(); // Handle space before and after the selector
 
-    if (this.position === 0 || this.prevToken[_tokenize.FIELDS.TYPE] === tokens.comma || this.prevToken[_tokenize.FIELDS.TYPE] === tokens.openParenthesis) {
+    if (this.position === 0 || this.prevToken[_tokenize.FIELDS.TYPE] === tokens.comma || this.prevToken[_tokenize.FIELDS.TYPE] === tokens.openParenthesis || this.current.nodes.every(function (node) {
+      return node.type === 'comment';
+    })) {
       this.spaces = this.optionalSpace(content);
       this.position++;
     } else if (this.position === this.tokens.length - 1 || this.nextToken[_tokenize.FIELDS.TYPE] === tokens.comma || this.nextToken[_tokenize.FIELDS.TYPE] === tokens.closeParenthesis) {

conf/site/node_modules/postcss-selector-parser/dist/selectors/attribute.js

@@ -22,8 +22,7 @@ function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _d
 
 function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; subClass.__proto__ = superClass; }
 
-var _require = require("util"),
-    deprecate = _require.deprecate;
+var deprecate = require("util-deprecate");
 
 var WRAPPED_IN_QUOTES = /^('|")(.*)\1$/;
 var warnOfDeprecatedValueAssignment = deprecate(function () {}, "Assigning an attribute a value containing characters that might need to be escaped is deprecated. " + "Call attribute.setValue() instead.");

conf/site/node_modules/postcss-selector-parser/dist/selectors/className.js

@@ -35,8 +35,8 @@ function (_Node) {
 
   var _proto = ClassName.prototype;
 
-  _proto.toString = function toString() {
-    return [this.rawSpaceBefore, String('.' + this.stringifyProperty("value")), this.rawSpaceAfter].join('');
+  _proto.valueToString = function valueToString() {
+    return '.' + _Node.prototype.valueToString.call(this);
   };
 
   _createClass(ClassName, [{

conf/site/node_modules/postcss-selector-parser/dist/selectors/guards.js

@@ -48,7 +48,7 @@ var isUniversal = isNodeType.bind(null, _types.UNIVERSAL);
 exports.isUniversal = isUniversal;
 
 function isPseudoElement(node) {
-  return isPseudo(node) && node.value && (node.value.startsWith("::") || node.value === ":before" || node.value === ":after");
+  return isPseudo(node) && node.value && (node.value.startsWith("::") || node.value.toLowerCase() === ":before" || node.value.toLowerCase() === ":after");
 }
 
 function isPseudoClass(node) {

conf/site/node_modules/postcss-selector-parser/dist/selectors/id.js

@@ -26,8 +26,8 @@ function (_Node) {
 
   var _proto = ID.prototype;
 
-  _proto.toString = function toString() {
-    return [this.rawSpaceBefore, String('#' + this.stringifyProperty("value")), this.rawSpaceAfter].join('');
+  _proto.valueToString = function valueToString() {
+    return '#' + _Node.prototype.valueToString.call(this);
   };
 
   return ID;

conf/site/node_modules/postcss-selector-parser/dist/selectors/namespace.js

@@ -36,8 +36,8 @@ function (_Node) {
     }
   };
 
-  _proto.toString = function toString() {
-    return [this.rawSpaceBefore, this.qualifiedName(this.stringifyProperty("value")), this.rawSpaceAfter].join('');
+  _proto.valueToString = function valueToString() {
+    return this.qualifiedName(_Node.prototype.valueToString.call(this));
   };
 
   _createClass(Namespace, [{

conf/site/node_modules/postcss-selector-parser/dist/selectors/node.js

@@ -160,7 +160,7 @@ function () {
     }
   }
   /**
-   * 
+   *
    * @param {number} line The number (starting with 1)
    * @param {number} column The column number (starting with 1)
    */
@@ -194,8 +194,12 @@ function () {
     return this.raws && this.raws[name] || this[name];
   };
 
+  _proto.valueToString = function valueToString() {
+    return String(this.stringifyProperty("value"));
+  };
+
   _proto.toString = function toString() {
-    return [this.rawSpaceBefore, String(this.stringifyProperty("value")), this.rawSpaceAfter].join('');
+    return [this.rawSpaceBefore, this.valueToString(), this.rawSpaceAfter].join('');
   };
 
   _createClass(Node, [{

conf/site/node_modules/postcss-selector-parser/package.json

@@ -1,33 +1,33 @@
 {
   "_args": [
     [
-      "postcss-selector-parser@6.0.2",
+      "postcss-selector-parser@6.0.4",
       "/home/henry/Documents/git/Speedtest-tracker-docker/conf/site"
     ]
   ],
   "_development": true,
-  "_from": "postcss-selector-parser@6.0.2",
-  "_id": "postcss-selector-parser@6.0.2",
+  "_from": "postcss-selector-parser@6.0.4",
+  "_id": "postcss-selector-parser@6.0.4",
   "_inBundle": false,
-  "_integrity": "sha512-36P2QR59jDTOAiIkqEprfJDsoNrvwFei3eCqKd1Y0tUsBimsq39BLp7RD+JWny3WgB1zGhJX8XVePwm9k4wdBg==",
+  "_integrity": "sha512-gjMeXBempyInaBqpp8gODmwZ52WaYsVOsfr4L4lDQ7n3ncD6mEyySiDtgzCT+NYC0mmeOLvtsF8iaEf0YT6dBw==",
   "_location": "/postcss-selector-parser",
   "_phantomChildren": {},
   "_requested": {
     "type": "version",
     "registry": true,
-    "raw": "postcss-selector-parser@6.0.2",
+    "raw": "postcss-selector-parser@6.0.4",
     "name": "postcss-selector-parser",
     "escapedName": "postcss-selector-parser",
-    "rawSpec": "6.0.2",
+    "rawSpec": "6.0.4",
     "saveSpec": null,
-    "fetchSpec": "6.0.2"
+    "fetchSpec": "6.0.4"
   },
   "_requiredBy": [
     "/@vue/component-compiler-utils",
     "/postcss-calc"
   ],
-  "_resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-6.0.2.tgz",
-  "_spec": "6.0.2",
+  "_resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-6.0.4.tgz",
+  "_spec": "6.0.4",
   "_where": "/home/henry/Documents/git/Speedtest-tracker-docker/conf/site",
   "ava": {
     "require": [
@@ -53,7 +53,8 @@
   "dependencies": {
     "cssesc": "^3.0.0",
     "indexes-of": "^1.0.1",
-    "uniq": "^1.0.1"
+    "uniq": "^1.0.1",
+    "util-deprecate": "^1.0.2"
   },
   "description": "> Selector parser with built in methods for working with selector strings.",
   "devDependencies": {
@@ -74,7 +75,8 @@
     "minimist": "^1.2.0",
     "nyc": "^13.3.0",
     "postcss": "^7.0.14",
-    "semver": "^5.6.0"
+    "semver": "^5.6.0",
+    "typescript": "^4.0.3"
   },
   "engines": {
     "node": ">=4"
@@ -103,11 +105,11 @@
   "scripts": {
     "lintfix": "eslint --fix src",
     "prepare": "del-cli dist && BABEL_ENV=publish babel src --out-dir dist --ignore /__tests__/",
-    "pretest": "eslint src",
+    "pretest": "eslint src && tsc --noEmit postcss-selector-parser.d.ts",
     "report": "nyc report --reporter=html",
     "test": "nyc ava src/__tests__/*.js",
     "testone": "ava"
   },
   "types": "postcss-selector-parser.d.ts",
-  "version": "6.0.2"
+  "version": "6.0.4"
 }

conf/site/node_modules/postcss-selector-parser/postcss-selector-parser.d.ts

@@ -14,6 +14,9 @@
  */
 export = parser;
 
+// A type that's T but not U.
+type Diff<T, U> = T extends U ? never : T;
+
 // TODO: Conditional types in TS 1.8 will really clean this up.
 declare function parser(): parser.Processor<never>;
 declare function parser<Transform>(processor: parser.AsyncProcessor<Transform>): parser.Processor<Transform, never>;
@@ -203,11 +206,14 @@ declare namespace parser {
     interface ContainerOptions extends NodeOptions {
         nodes?: Array<Node>;
     }
-    interface Container<Value extends string | undefined = string> extends Base<Value> {
-        nodes: Array<Node>;
-        append(selector: Selector): Container;
-        prepend(selector: Selector): Container;
-        at(index: number): Node;
+    interface Container<
+        Value extends string | undefined = string,
+        Child extends Node = Node
+    > extends Base<Value> {
+        nodes: Array<Child>;
+        append(selector: Selector): this;
+        prepend(selector: Selector): this;
+        at(index: number): Child;
         /**
          * Return the most specific node at the line and column number given.
          * The source location is based on the original parsed location, locations aren't
@@ -221,33 +227,74 @@ declare namespace parser {
          * @param line The line number of the node to find. (1-based index)
          * @param col  The column number of the node to find. (1-based index)
          */
-        atPosition(line: number, column: number): Node;
-        index(child: Node): number;
-        readonly first: Node;
-        readonly last: Node;
+        atPosition(line: number, column: number): Child;
+        index(child: Child): number;
+        readonly first: Child;
+        readonly last: Child;
         readonly length: number;
-        removeChild(child: Node): Container;
+        removeChild(child: Child): this;
         removeAll(): Container;
         empty(): Container;
-        insertAfter(oldNode: Node, newNode: Node): Container;
-        insertBefore(oldNode: Node, newNode: Node): Container;
-        each(callback: (node: Node) => boolean | void): boolean | undefined;
-        walk(callback: (node: Node) => boolean | void): boolean | undefined;
-        walkAttributes(callback: (node: Node) => boolean | void): boolean | undefined;
-        walkClasses(callback: (node: Node) => boolean | void): boolean | undefined;
-        walkCombinators(callback: (node: Node) => boolean | void): boolean | undefined;
-        walkComments(callback: (node: Node) => boolean | void): boolean | undefined;
-        walkIds(callback: (node: Node) => boolean | void): boolean | undefined;
-        walkNesting(callback: (node: Node) => boolean | void): boolean | undefined;
-        walkPseudos(callback: (node: Node) => boolean | void): boolean | undefined;
-        walkTags(callback: (node: Node) => boolean | void): boolean | undefined;
-        split(callback: (node: Node) => boolean): [Node[], Node[]];
-        map(callback: (node: Node) => Node): Node[];
-        reduce<T>(callback: (node: Node) => Node, memo: T): T;
-        every(callback: (node: Node) => boolean): boolean;
-        some(callback: (node: Node) => boolean): boolean;
-        filter(callback: (node: Node) => boolean): Node[];
-        sort(callback: (nodeA: Node, nodeB: Node) => number): Node[];
+        insertAfter(oldNode: Child, newNode: Child): this;
+        insertBefore(oldNode: Child, newNode: Child): this;
+        each(callback: (node: Child) => boolean | void): boolean | undefined;
+        walk(
+            callback: (node: Node) => boolean | void
+        ): boolean | undefined;
+        walkAttributes(
+            callback: (node: Attribute) => boolean | void
+        ): boolean | undefined;
+        walkClasses(
+            callback: (node: ClassName) => boolean | void
+        ): boolean | undefined;
+        walkCombinators(
+            callback: (node: Combinator) => boolean | void
+        ): boolean | undefined;
+        walkComments(
+            callback: (node: Comment) => boolean | void
+        ): boolean | undefined;
+        walkIds(
+            callback: (node: Identifier) => boolean | void
+        ): boolean | undefined;
+        walkNesting(
+            callback: (node: Nesting) => boolean | void
+        ): boolean | undefined;
+        walkPseudos(
+            callback: (node: Pseudo) => boolean | void
+        ): boolean | undefined;
+        walkTags(callback: (node: Tag) => boolean | void): boolean | undefined;
+        split(callback: (node: Child) => boolean): [Child[], Child[]];
+        map<T>(callback: (node: Child) => T): T[];
+        reduce(
+            callback: (
+                previousValue: Child,
+                currentValue: Child,
+                currentIndex: number,
+                array: readonly Child[]
+            ) => Child
+        ): Child;
+        reduce(
+            callback: (
+                previousValue: Child,
+                currentValue: Child,
+                currentIndex: number,
+                array: readonly Child[]
+            ) => Child,
+            initialValue: Child
+        ): Child;
+        reduce<T>(
+            callback: (
+                previousValue: T,
+                currentValue: Child,
+                currentIndex: number,
+                array: readonly Child[]
+            ) => T,
+            initialValue: T
+        ): T;
+        every(callback: (node: Child) => boolean): boolean;
+        some(callback: (node: Child) => boolean): boolean;
+        filter(callback: (node: Child) => boolean): Child[];
+        sort(callback: (nodeA: Child, nodeB: Child) => number): Child[];
         toString(): string;
     }
     function isContainer(node: any): node is Root | Selector | Pseudo;
@@ -273,7 +320,7 @@ declare namespace parser {
     }
     function isNamespace(node: any): node is Attribute | Tag;
 
-    interface Root extends Container<undefined> {
+    interface Root extends Container<undefined, Selector> {
         type: "root";
         /**
          * Raises an error, if the processor is invoked on
@@ -285,9 +332,10 @@ declare namespace parser {
     function root(opts: ContainerOptions): Root;
     function isRoot(node: any): node is Root;
 
-    interface Selector extends Container {
+    interface _Selector<S> extends Container<string, Diff<Node, S>> {
         type: "selector";
     }
+    type Selector = _Selector<Selector>;
     function selector(opts: ContainerOptions): Selector;
     function isSelector(node: any): node is Selector;
 
@@ -439,7 +487,7 @@ declare namespace parser {
     function attribute(opts: AttributeOptions): Attribute;
     function isAttribute(node: any): node is Attribute;
 
-    interface Pseudo extends Container {
+    interface Pseudo extends Container<string, Selector> {
         type: "pseudo";
     }
     function pseudo(opts: ContainerOptions): Pseudo;