postcss-merge-rules 5.0.4 → 5.1.0

package/package.json

@@ -1,11 +1,13 @@
 {
   "name": "postcss-merge-rules",
-  "version": "5.0.4",
+  "version": "5.1.0",
   "description": "Merge CSS rules with PostCSS.",
-  "main": "dist/index.js",
+  "types": "types/index.d.ts",
+  "main": "src/index.js",
   "files": [
     "LICENSE-MIT",
-    "dist"
+    "src",
+    "types"
   ],
   "keywords": [
     "css",
@@ -24,7 +26,7 @@
   "dependencies": {
     "browserslist": "^4.16.6",
     "caniuse-api": "^3.0.0",
-    "cssnano-utils": "^3.0.0",
+    "cssnano-utils": "^3.1.0",
     "postcss-selector-parser": "^6.0.5"
   },
   "bugs": {
@@ -34,15 +36,12 @@
     "node": "^10 || ^12 || >=14.0"
   },
   "devDependencies": {
+    "@types/caniuse-api": "^3.0.2",
     "postcss": "^8.2.15",
-    "postcss-discard-comments": "^5.0.1"
+    "postcss-discard-comments": "^5.1.0"
   },
   "peerDependencies": {
     "postcss": "^8.2.15"
   },
-  "scripts": {
-    "prebuild": "rimraf dist",
-    "build": "babel src --config-file ../../babel.config.json --out-dir dist --ignore \"**/__tests__/\""
-  },
   "readme": "# [postcss][postcss]-merge-rules\n\n> Merge CSS rules with PostCSS.\n\n## Install\n\nWith [npm](https://npmjs.org/package/postcss-merge-rules) do:\n\n```\nnpm install postcss-merge-rules --save\n```\n\n## Examples\n\nThis module will attempt to merge *adjacent* CSS rules:\n\n### By declarations\n\n#### Input\n\n```css\na {\n    color: blue;\n    font-weight: bold\n}\n\np {\n    color: blue;\n    font-weight: bold\n}\n```\n\n#### Output\n\n```css\na,p {\n    color: blue;\n    font-weight: bold\n}\n```\n\n### By selectors\n\n#### Input\n\n```css\na {\n    color: blue\n}\n\na {\n    font-weight: bold\n}\n```\n\n#### Output\n\n```css\na {\n    color: blue;\n    font-weight: bold\n}\n```\n\n### By partial declarations\n\n#### Input\n\n```css\na {\n    font-weight: bold\n}\n\np {\n    color: blue;\n    font-weight: bold\n}\n```\n\n#### Output\n\n```css\na,p {\n    font-weight: bold\n}\n\np {\n    color: blue\n}\n```\n\n## Usage\n\nSee the [PostCSS documentation](https://github.com/postcss/postcss#usage) for\nexamples for your environment.\n\n## Contributors\n\nSee [CONTRIBUTORS.md](https://github.com/cssnano/cssnano/blob/master/CONTRIBUTORS.md).\n\n## License\n\nMIT © [Ben Briggs](http://beneb.info)\n\n[postcss]: https://github.com/postcss/postcss\n"
 }

package/{dist → src}/index.js

@@ -1,226 +1,214 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _browserslist = _interopRequireDefault(require("browserslist"));
-
-var _cssnanoUtils = require("cssnano-utils");
-
-var _ensureCompatibility = require("./lib/ensureCompatibility");
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+'use strict';
+const browserslist = require('browserslist');
+const { sameParent } = require('cssnano-utils');
+const {
+  ensureCompatibility,
+  sameVendor,
+  noVendor,
+} = require('./lib/ensureCompatibility');
 
 /**
- * @param {postcss.Declaration} a
- * @param {postcss.Declaration} b
+ * @param {import('postcss').Declaration} a
+ * @param {import('postcss').Declaration} b
  * @return {boolean}
  */
 function declarationIsEqual(a, b) {
-  return a.important === b.important && a.prop === b.prop && a.value === b.value;
+  return (
+    a.important === b.important && a.prop === b.prop && a.value === b.value
+  );
 }
+
 /**
- * @param {postcss.Declaration[]} array
- * @param {postcss.Declaration} decl
+ * @param {import('postcss').Declaration[]} array
+ * @param {import('postcss').Declaration} decl
  * @return {number}
  */
-
-
 function indexOfDeclaration(array, decl) {
-  return array.findIndex(d => declarationIsEqual(d, decl));
+  return array.findIndex((d) => declarationIsEqual(d, decl));
 }
+
 /**
  * Returns filtered array of matched or unmatched declarations
- * @param {postcss.Declaration[]} a
- * @param {postcss.Declaration[]} b
+ * @param {import('postcss').Declaration[]} a
+ * @param {import('postcss').Declaration[]} b
  * @param {boolean} [not=false]
- * @return {postcss.Declaration[]}
+ * @return {import('postcss').Declaration[]}
  */
-
-
 function intersect(a, b, not) {
-  return a.filter(c => {
+  return a.filter((c) => {
     const index = ~indexOfDeclaration(b, c);
     return not ? !index : index;
   });
 }
+
 /**
- * @param {postcss.Declaration[]} a
- * @param {postcss.Declaration[]} b
+ * @param {import('postcss').Declaration[]} a
+ * @param {import('postcss').Declaration[]} b
  * @return {boolean}
  */
-
-
 function sameDeclarationsAndOrder(a, b) {
   if (a.length !== b.length) {
     return false;
   }
-
   return a.every((d, index) => declarationIsEqual(d, b[index]));
 }
+
 /**
- * @param {postcss.Rule} ruleA
- * @param {postcss.Rule} ruleB
+ * @param {import('postcss').Rule} ruleA
+ * @param {import('postcss').Rule} ruleB
  * @param {string[]=} browsers
  * @param {Map<string, boolean>=} compatibilityCache
  * @return {boolean}
  */
-
-
 function canMerge(ruleA, ruleB, browsers, compatibilityCache) {
   const a = ruleA.selectors;
   const b = ruleB.selectors;
+
   const selectors = a.concat(b);
 
-  if (!(0, _ensureCompatibility.ensureCompatibility)(selectors, browsers, compatibilityCache)) {
+  if (!ensureCompatibility(selectors, browsers, compatibilityCache)) {
     return false;
   }
 
-  const parent = (0, _cssnanoUtils.sameParent)(ruleA, ruleB);
-  const {
-    name
-  } = ruleA.parent;
-
-  if (parent && name && ~name.indexOf('keyframes')) {
+  const parent = sameParent(
+    /** @type {any} */ (ruleA),
+    /** @type {any} */ (ruleB)
+  );
+  const { name } = /** @type {any} */ (ruleA).parent;
+  if (parent && name && name.includes('keyframes')) {
     return false;
   }
-
-  return parent && (selectors.every(_ensureCompatibility.noVendor) || (0, _ensureCompatibility.sameVendor)(a, b));
+  return parent && (selectors.every(noVendor) || sameVendor(a, b));
 }
+
 /**
- * @param {postcss.Rule} rule
- * @return {postcss.Declaration[]}
+ * @param {import('postcss').Rule} rule
+ * @return {import('postcss').Declaration[]}
  */
-
-
 function getDecls(rule) {
-  return rule.nodes.filter(node => node.type === 'decl');
+  return /** @type {import('postcss').Declaration[]} */ (
+    rule.nodes.filter((node) => node.type === 'decl')
+  );
 }
 
-const joinSelectors = (...rules) => rules.map(s => s.selector).join();
+/** @type {(...rules: import('postcss').Rule[]) => string} */
+const joinSelectors = (...rules) => rules.map((s) => s.selector).join();
 
+/**
+ * @param {...import('postcss').Rule} rules
+ * @return {number}
+ */
 function ruleLength(...rules) {
-  return rules.map(r => r.nodes.length ? String(r) : '').join('').length;
+  return rules.map((r) => (r.nodes.length ? String(r) : '')).join('').length;
 }
+
 /**
  * @param {string} prop
- * @return {{prefix: string, base:string, rest:string[]}}
+ * @return {{prefix: string?, base:string?, rest:string[]}}
  */
-
-
 function splitProp(prop) {
   // Treat vendor prefixed properties as if they were unprefixed;
   // moving them when combined with non-prefixed properties can
   // cause issues. e.g. moving -webkit-background-clip when there
   // is a background shorthand definition.
-  const parts = prop.split('-');
 
+  const parts = prop.split('-');
   if (prop[0] !== '-') {
     return {
       prefix: '',
       base: parts[0],
-      rest: parts.slice(1)
+      rest: parts.slice(1),
     };
-  } // Don't split css variables
-
-
+  }
+  // Don't split css variables
   if (prop[1] === '-') {
     return {
       prefix: null,
       base: null,
-      rest: [prop]
+      rest: [prop],
     };
-  } // Found prefix
-
-
+  }
+  // Found prefix
   return {
     prefix: parts[1],
     base: parts[2],
-    rest: parts.slice(3)
+    rest: parts.slice(3),
   };
 }
+
 /**
  * @param {string} propA
  * @param {string} propB
  */
-
-
 function isConflictingProp(propA, propB) {
   if (propA === propB) {
     // Same specificity
     return true;
   }
-
   const a = splitProp(propA);
-  const b = splitProp(propB); // Don't resort css variables
-
+  const b = splitProp(propB);
+  // Don't resort css variables
   if (!a.base && !b.base) {
     return true;
-  } // Different base;
-
-
+  }
+  // Different base;
   if (a.base !== b.base) {
     return false;
-  } // Conflict if rest-count mismatches
-
-
+  }
+  // Conflict if rest-count mismatches
   if (a.rest.length !== b.rest.length) {
     return true;
-  } // Conflict if rest parameters are equal (same but unprefixed)
-
+  }
 
+  // Conflict if rest parameters are equal (same but unprefixed)
   return a.rest.every((s, index) => b.rest[index] === s);
 }
+
 /**
- * @param {postcss.Rule} first
- * @param {postcss.Rule} second
+ * @param {import('postcss').Rule} first
+ * @param {import('postcss').Rule} second
  * @return {boolean} merged
  */
-
-
 function mergeParents(first, second) {
   // Null check for detached rules
   if (!first.parent || !second.parent) {
     return false;
-  } // Check if parents share node
-
+  }
 
+  // Check if parents share node
   if (first.parent === second.parent) {
     return false;
-  } // sameParent() already called by canMerge()
+  }
 
+  // sameParent() already called by canMerge()
 
   second.remove();
   first.parent.append(second);
   return true;
 }
+
 /**
- * @param {postcss.Rule} first
- * @param {postcss.Rule} second
- * @return {postcss.Rule} mergedRule
+ * @param {import('postcss').Rule} first
+ * @param {import('postcss').Rule} second
+ * @return {import('postcss').Rule} mergedRule
  */
-
-
 function partialMerge(first, second) {
   let intersection = intersect(getDecls(first), getDecls(second));
-
   if (!intersection.length) {
     return second;
   }
-
   let nextRule = second.next();
-
   if (!nextRule) {
     // Grab next cousin
-    const parentSibling = second.parent.next();
+    /** @type {any} */
+    const parentSibling =
+      /** @type {import('postcss').Container<import('postcss').ChildNode>} */ (
+        second.parent
+      ).next();
     nextRule = parentSibling && parentSibling.nodes && parentSibling.nodes[0];
   }
-
   if (nextRule && nextRule.type === 'rule' && canMerge(second, nextRule)) {
     let nextIntersection = intersect(getDecls(second), getDecls(nextRule));
-
     if (nextIntersection.length > intersection.length) {
       mergeParents(second, nextRule);
       first = second;
@@ -229,45 +217,52 @@ function partialMerge(first, second) {
     }
   }
 
-  const firstDecls = getDecls(first); // Filter out intersections with later conflicts in First
+  const firstDecls = getDecls(first);
 
+  // Filter out intersections with later conflicts in First
   intersection = intersection.filter((decl, intersectIndex) => {
     const indexOfDecl = indexOfDeclaration(firstDecls, decl);
-    const nextConflictInFirst = firstDecls.slice(indexOfDecl + 1).filter(d => isConflictingProp(d.prop, decl.prop));
-
+    const nextConflictInFirst = firstDecls
+      .slice(indexOfDecl + 1)
+      .filter((d) => isConflictingProp(d.prop, decl.prop));
     if (!nextConflictInFirst.length) {
       return true;
     }
-
-    const nextConflictInIntersection = intersection.slice(intersectIndex + 1).filter(d => isConflictingProp(d.prop, decl.prop));
-
+    const nextConflictInIntersection = intersection
+      .slice(intersectIndex + 1)
+      .filter((d) => isConflictingProp(d.prop, decl.prop));
     if (!nextConflictInIntersection.length) {
       return false;
     }
-
     if (nextConflictInFirst.length !== nextConflictInIntersection.length) {
       return false;
     }
+    return nextConflictInFirst.every((d, index) =>
+      declarationIsEqual(d, nextConflictInIntersection[index])
+    );
+  });
 
-    return nextConflictInFirst.every((d, index) => declarationIsEqual(d, nextConflictInIntersection[index]));
-  }); // Filter out intersections with previous conflicts in Second
-
+  // Filter out intersections with previous conflicts in Second
   const secondDecls = getDecls(second);
-  intersection = intersection.filter(decl => {
-    const nextConflictIndex = secondDecls.findIndex(d => isConflictingProp(d.prop, decl.prop));
-
+  intersection = intersection.filter((decl) => {
+    const nextConflictIndex = secondDecls.findIndex((d) =>
+      isConflictingProp(d.prop, decl.prop)
+    );
     if (nextConflictIndex === -1) {
       return false;
     }
-
     if (!declarationIsEqual(secondDecls[nextConflictIndex], decl)) {
       return false;
     }
-
-    if (decl.prop.toLowerCase() !== 'direction' && decl.prop.toLowerCase() !== 'unicode-bidi' && secondDecls.some(declaration => declaration.prop.toLowerCase() === 'all')) {
+    if (
+      decl.prop.toLowerCase() !== 'direction' &&
+      decl.prop.toLowerCase() !== 'unicode-bidi' &&
+      secondDecls.some(
+        (declaration) => declaration.prop.toLowerCase() === 'all'
+      )
+    ) {
       return false;
     }
-
     secondDecls.splice(nextConflictIndex, 1);
     return true;
   });
@@ -280,58 +275,60 @@ function partialMerge(first, second) {
   const receivingBlock = second.clone();
   receivingBlock.selector = joinSelectors(first, second);
   receivingBlock.nodes = [];
-  second.parent.insertBefore(second, receivingBlock);
+
+  /** @type {import('postcss').Container<import('postcss').ChildNode>} */ (
+    second.parent
+  ).insertBefore(second, receivingBlock);
+
   const firstClone = first.clone();
   const secondClone = second.clone();
+
   /**
-   * @param {function(postcss.Declaration):void} callback
-   * @return {function(postcss.Declaration)}
+   * @param {function(import('postcss').Declaration):void} callback
+   * @this {import('postcss').Rule}
+   * @return {function(import('postcss').Declaration)}
    */
-
   function moveDecl(callback) {
-    return decl => {
+    return (decl) => {
       if (~indexOfDeclaration(intersection, decl)) {
         callback.call(this, decl);
       }
     };
   }
-
-  firstClone.walkDecls(moveDecl(decl => {
-    decl.remove();
-    receivingBlock.append(decl);
-  }));
-  secondClone.walkDecls(moveDecl(decl => decl.remove()));
+  firstClone.walkDecls(
+    moveDecl((decl) => {
+      decl.remove();
+      receivingBlock.append(decl);
+    })
+  );
+  secondClone.walkDecls(moveDecl((decl) => decl.remove()));
   const merged = ruleLength(firstClone, receivingBlock, secondClone);
   const original = ruleLength(first, second);
-
   if (merged < original) {
     first.replaceWith(firstClone);
     second.replaceWith(secondClone);
-    [firstClone, receivingBlock, secondClone].forEach(r => {
+    [firstClone, receivingBlock, secondClone].forEach((r) => {
       if (!r.nodes.length) {
         r.remove();
       }
     });
-
     if (!secondClone.parent) {
       return receivingBlock;
     }
-
     return secondClone;
   } else {
     receivingBlock.remove();
     return second;
   }
 }
+
 /**
  * @param {string[]} browsers
  * @param {Map<string, boolean>} compatibilityCache
- * @return {function(postcss.Rule)}
+ * @return {function(import('postcss').Rule)}
  */
-
-
 function selectorMerger(browsers, compatibilityCache) {
-  /** @type {postcss.Rule} */
+  /** @type {import('postcss').Rule | null} */
   let cache = null;
   return function (rule) {
     // Prime the cache with the first rule, or alternately ensure that it is
@@ -339,71 +336,75 @@ function selectorMerger(browsers, compatibilityCache) {
     if (!cache || !canMerge(rule, cache, browsers, compatibilityCache)) {
       cache = rule;
       return;
-    } // Ensure that we don't deduplicate the same rule; this is sometimes
+    }
+    // Ensure that we don't deduplicate the same rule; this is sometimes
     // caused by a partial merge
-
-
     if (cache === rule) {
       cache = rule;
       return;
-    } // Parents merge: check if the rules have same parents, but not same parent nodes
+    }
 
+    // Parents merge: check if the rules have same parents, but not same parent nodes
+    mergeParents(cache, rule);
 
-    mergeParents(cache, rule); // Merge when declarations are exactly equal
+    // Merge when declarations are exactly equal
     // e.g. h1 { color: red } h2 { color: red }
-
     if (sameDeclarationsAndOrder(getDecls(rule), getDecls(cache))) {
       rule.selector = joinSelectors(cache, rule);
       cache.remove();
       cache = rule;
       return;
-    } // Merge when both selectors are exactly equal
+    }
+    // Merge when both selectors are exactly equal
     // e.g. a { color: blue } a { font-weight: bold }
-
-
     if (cache.selector === rule.selector) {
       const cached = getDecls(cache);
-      rule.walk(decl => {
-        if (~indexOfDeclaration(cached, decl)) {
-          return decl.remove();
+      rule.walk((decl) => {
+        if (
+          ~indexOfDeclaration(
+            cached,
+            /** @type {import('postcss').Declaration} */ (decl)
+          )
+        ) {
+          decl.remove();
+          return;
         }
-
-        cache.append(decl);
+        /** @type {import('postcss').Rule} */ (cache).append(decl);
       });
       rule.remove();
       return;
-    } // Partial merge: check if the rule contains a subset of the last; if
+    }
+    // Partial merge: check if the rule contains a subset of the last; if
     // so create a joined selector with the subset, if smaller.
-
-
     cache = partialMerge(cache, rule);
   };
 }
-
+/**
+ * @type {import('postcss').PluginCreator<void>}
+ * @return {import('postcss').Plugin}
+ */
 function pluginCreator() {
   return {
     postcssPlugin: 'postcss-merge-rules',
 
     prepare(result) {
+      /** @type {typeof result.opts & browserslist.Options} */
       const resultOpts = result.opts || {};
-      const browsers = (0, _browserslist.default)(null, {
+      const browsers = browserslist(null, {
         stats: resultOpts.stats,
         path: __dirname,
-        env: resultOpts.env
+        env: resultOpts.env,
       });
+
       const compatibilityCache = new Map();
       return {
         OnceExit(css) {
           css.walkRules(selectorMerger(browsers, compatibilityCache));
-        }
-
+        },
       };
-    }
-
+    },
   };
 }
 
 pluginCreator.postcss = true;
-var _default = pluginCreator;
-exports.default = _default;
-module.exports = exports.default;
+module.exports = pluginCreator;

package/{dist → src}/lib/ensureCompatibility.js

@@ -1,20 +1,9 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.ensureCompatibility = ensureCompatibility;
-exports.noVendor = noVendor;
-exports.pseudoElements = void 0;
-exports.sameVendor = sameVendor;
-
-var _caniuseApi = require("caniuse-api");
-
-var _postcssSelectorParser = _interopRequireDefault(require("postcss-selector-parser"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+'use strict';
+const { isSupported } = require('caniuse-api');
+const selectorParser = require('postcss-selector-parser');
 
 const simpleSelectorRe = /^#?[-._a-z0-9 ]+$/i;
+
 const cssSel2 = 'css-sel2';
 const cssSel3 = 'css-sel3';
 const cssGencontent = 'css-gencontent';
@@ -22,33 +11,50 @@ const cssFirstLetter = 'css-first-letter';
 const cssFirstLine = 'css-first-line';
 const cssInOutOfRange = 'css-in-out-of-range';
 const formValidation = 'form-validation';
-const vendorPrefix = /-(ah|apple|atsc|epub|hp|khtml|moz|ms|o|rim|ro|tc|wap|webkit|xv)-/;
+
+const vendorPrefix =
+  /-(ah|apple|atsc|epub|hp|khtml|moz|ms|o|rim|ro|tc|wap|webkit|xv)-/;
+
+const level2Sel = new Set(['=', '~=', '|=']);
+const level3Sel = new Set(['^=', '$=', '*=']);
+
 /**
  * @param {string} selector
- * @return {string[]}
+ * @return {RegExpMatchArray | null}
  */
-
 function filterPrefixes(selector) {
   return selector.match(vendorPrefix);
-} // Internet Explorer use :-ms-input-placeholder.
-// Microsoft Edge use ::-ms-input-placeholder.
-
+}
 
-const findMsInputPlaceholder = selector => ~selector.search(/-ms-input-placeholder/i);
+/**
+ * Internet Explorer use :-ms-input-placeholder.
+ * Microsoft Edge use ::-ms-input-placeholder.
+ *
+ * @type {(selector: string) => number}
+ */
+const findMsInputPlaceholder = (selector) =>
+  ~selector.search(/-ms-input-placeholder/i);
 
+/**
+ * @param {string[]} selectorsA
+ * @param {string[]} selectorsB
+ * @return {boolean}
+ */
 function sameVendor(selectorsA, selectorsB) {
-  let same = selectors => selectors.map(filterPrefixes).join();
-
-  let findMsVendor = selectors => selectors.find(findMsInputPlaceholder);
-
-  return same(selectorsA) === same(selectorsB) && !(findMsVendor(selectorsA) && findMsVendor(selectorsB));
+  /** @type {(selectors: string[]) => string} */
+  let same = (selectors) => selectors.map(filterPrefixes).join();
+  /** @type {(selectors: string[]) => string | undefined} */
+  let findMsVendor = (selectors) => selectors.find(findMsInputPlaceholder);
+  return (
+    same(selectorsA) === same(selectorsB) &&
+    !(findMsVendor(selectorsA) && findMsVendor(selectorsB))
+  );
 }
+
 /**
  * @param {string} selector
  * @return {boolean}
  */
-
-
 function noVendor(selector) {
   return !vendorPrefix.test(selector);
 }
@@ -104,109 +110,110 @@ const pseudoElements = {
   '::placeholder': 'css-placeholder',
   '::selection': 'css-selection',
   ':valid': formValidation,
-  ':visited': cssSel2
+  ':visited': cssSel2,
 };
-exports.pseudoElements = pseudoElements;
 
+/**
+ * @param {string} selector
+ * @return {boolean}
+ */
 function isCssMixin(selector) {
   return selector[selector.length - 1] === ':';
 }
 
+/**
+ * @param {string} selector
+ * @return {boolean}
+ */
 function isHostPseudoClass(selector) {
   return selector.includes(':host');
 }
 
-const isSupportedCache = new Map(); // Move to util in future
+const isSupportedCache = new Map();
 
+// Move to util in future
+/**
+ * @param {string} feature
+ * @param {string[] | undefined} browsers
+ */
 function isSupportedCached(feature, browsers) {
-  const key = JSON.stringify({
-    feature,
-    browsers
-  });
+  const key = JSON.stringify({ feature, browsers });
   let result = isSupportedCache.get(key);
 
   if (!result) {
-    result = (0, _caniuseApi.isSupported)(feature, browsers);
+    result = isSupported(feature, /** @type {string[]} */ (browsers));
     isSupportedCache.set(key, result);
   }
 
   return result;
 }
 
+/**
+ * @param {string[]} selectors
+ * @param{string[]=} browsers
+ * @param{Map<string,boolean>=} compatibilityCache
+ * @return {boolean}
+ */
 function ensureCompatibility(selectors, browsers, compatibilityCache) {
   // Should not merge mixins
   if (selectors.some(isCssMixin)) {
     return false;
-  } // Should not merge :host selector https://github.com/angular/angular-cli/issues/18672
-
+  }
 
+  // Should not merge :host selector https://github.com/angular/angular-cli/issues/18672
   if (selectors.some(isHostPseudoClass)) {
     return false;
   }
-
-  return selectors.every(selector => {
+  return selectors.every((selector) => {
     if (simpleSelectorRe.test(selector)) {
       return true;
     }
-
     if (compatibilityCache && compatibilityCache.has(selector)) {
       return compatibilityCache.get(selector);
     }
-
     let compatible = true;
-    (0, _postcssSelectorParser.default)(ast => {
-      ast.walk(node => {
-        const {
-          type,
-          value
-        } = node;
-
+    selectorParser((ast) => {
+      ast.walk((node) => {
+        const { type, value } = node;
         if (type === 'pseudo') {
-          const entry = pseudoElements[value];
-
+          const entry =
+            pseudoElements[/** @type {keyof pseudoElements} */ (value)];
           if (!entry && noVendor(value)) {
             compatible = false;
           }
-
           if (entry && compatible) {
             compatible = isSupportedCached(entry, browsers);
           }
         }
-
         if (type === 'combinator') {
-          if (~value.indexOf('~')) {
+          if (value.includes('~')) {
             compatible = isSupportedCached(cssSel3, browsers);
           }
-
-          if (~value.indexOf('>') || ~value.indexOf('+')) {
+          if (value.includes('>') || value.includes('+')) {
             compatible = isSupportedCached(cssSel2, browsers);
           }
         }
-
         if (type === 'attribute' && node.attribute) {
           // [foo]
           if (!node.operator) {
             compatible = isSupportedCached(cssSel2, browsers);
           }
-
           if (value) {
             // [foo="bar"], [foo~="bar"], [foo|="bar"]
-            if (~['=', '~=', '|='].indexOf(node.operator)) {
+            if (level2Sel.has(/** @type {string} */ (node.operator))) {
               compatible = isSupportedCached(cssSel2, browsers);
-            } // [foo^="bar"], [foo$="bar"], [foo*="bar"]
-
-
-            if (~['^=', '$=', '*='].indexOf(node.operator)) {
+            }
+            // [foo^="bar"], [foo$="bar"], [foo*="bar"]
+            if (level3Sel.has(/** @type {string} */ (node.operator))) {
               compatible = isSupportedCached(cssSel3, browsers);
             }
-          } // [foo="bar" i]
-
+          }
 
+          // [foo="bar" i]
           if (node.insensitive) {
             compatible = isSupportedCached('css-case-insensitive', browsers);
           }
         }
-
         if (!compatible) {
           // If this node was not compatible,
           // break out early from walking the rest
@@ -214,11 +221,11 @@ function ensureCompatibility(selectors, browsers, compatibilityCache) {
         }
       });
     }).processSync(selector);
-
     if (compatibilityCache) {
       compatibilityCache.set(selector, compatible);
     }
-
     return compatible;
   });
-}
+}
+
+module.exports = { sameVendor, noVendor, pseudoElements, ensureCompatibility };

package/types/index.d.ts

@@ -0,0 +1,9 @@
+export = pluginCreator;
+/**
+ * @type {import('postcss').PluginCreator<void>}
+ * @return {import('postcss').Plugin}
+ */
+declare function pluginCreator(): import('postcss').Plugin;
+declare namespace pluginCreator {
+    const postcss: true;
+}

package/types/lib/ensureCompatibility.d.ts

@@ -0,0 +1,71 @@
+/**
+ * @param {string[]} selectorsA
+ * @param {string[]} selectorsB
+ * @return {boolean}
+ */
+export function sameVendor(selectorsA: string[], selectorsB: string[]): boolean;
+/**
+ * @param {string} selector
+ * @return {boolean}
+ */
+export function noVendor(selector: string): boolean;
+export const pseudoElements: {
+    ':active': string;
+    ':after': string;
+    ':any-link': string;
+    ':before': string;
+    ':checked': string;
+    ':default': string;
+    ':dir': string;
+    ':disabled': string;
+    ':empty': string;
+    ':enabled': string;
+    ':first-child': string;
+    ':first-letter': string;
+    ':first-line': string;
+    ':first-of-type': string;
+    ':focus': string;
+    ':focus-within': string;
+    ':focus-visible': string;
+    ':has': string;
+    ':hover': string;
+    ':in-range': string;
+    ':indeterminate': string;
+    ':invalid': string;
+    ':is': string;
+    ':lang': string;
+    ':last-child': string;
+    ':last-of-type': string;
+    ':link': string;
+    ':matches': string;
+    ':not': string;
+    ':nth-child': string;
+    ':nth-last-child': string;
+    ':nth-last-of-type': string;
+    ':nth-of-type': string;
+    ':only-child': string;
+    ':only-of-type': string;
+    ':optional': string;
+    ':out-of-range': string;
+    ':placeholder-shown': string;
+    ':required': string;
+    ':root': string;
+    ':target': string;
+    '::after': string;
+    '::backdrop': string;
+    '::before': string;
+    '::first-letter': string;
+    '::first-line': string;
+    '::marker': string;
+    '::placeholder': string;
+    '::selection': string;
+    ':valid': string;
+    ':visited': string;
+};
+/**
+ * @param {string[]} selectors
+ * @param{string[]=} browsers
+ * @param{Map<string,boolean>=} compatibilityCache
+ * @return {boolean}
+ */
+export function ensureCompatibility(selectors: string[], browsers?: string[] | undefined, compatibilityCache?: Map<string, boolean> | undefined): boolean;