postcss-merge-rules 4.0.3 → 5.0.0

package/CHANGELOG.md

@@ -0,0 +1,75 @@
+# Change Log
+
+All notable changes to this project will be documented in this file.
+See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
+
+# [5.0.0](https://github.com/cssnano/cssnano/compare/postcss-merge-rules@5.0.0-rc.2...postcss-merge-rules@5.0.0) (2021-04-06)
+
+**Note:** Version bump only for package postcss-merge-rules
+
+
+
+
+
+# [5.0.0-rc.2](https://github.com/cssnano/cssnano/compare/postcss-merge-rules@5.0.0-rc.1...postcss-merge-rules@5.0.0-rc.2) (2021-03-15)
+
+**Note:** Version bump only for package postcss-merge-rules
+
+
+
+
+
+# [5.0.0-rc.1](https://github.com/cssnano/cssnano/compare/postcss-merge-rules@5.0.0-rc.0...postcss-merge-rules@5.0.0-rc.1) (2021-03-04)
+
+**Note:** Version bump only for package postcss-merge-rules
+
+
+
+
+
+# 5.0.0-rc.0 (2021-02-19)
+
+
+### Bug Fixes
+
+* don't unsafe merge 'all' declaration ([#872](https://github.com/cssnano/cssnano/issues/872)) ([6ea9e5d](https://github.com/cssnano/cssnano/commit/6ea9e5dcad2d8ea22be7209332ee29d352c807de))
+* focus-visible issue ([#882](https://github.com/cssnano/cssnano/issues/882)) ([4cfcaaf](https://github.com/cssnano/cssnano/commit/4cfcaaf25b162ec2b0308907a408d7dba6a354c3))
+* **merge-rules, merge-idents:** add support for nested at-rules ([#719](https://github.com/cssnano/cssnano/issues/719)) ([cdedda7](https://github.com/cssnano/cssnano/commit/cdedda7f9d67873d872add044ad34c91616579f3))
+* **postcss-merge-rules:** don't change specificity of prefixed properties ([#723](https://github.com/cssnano/cssnano/issues/723)) ([863cf2b](https://github.com/cssnano/cssnano/commit/863cf2b3470d3172523a3165dc368abcfa18809c))
+
+
+### chore
+
+* minimum require version of node is 10.13 ([#871](https://github.com/cssnano/cssnano/issues/871)) ([28bda24](https://github.com/cssnano/cssnano/commit/28bda243e32ce3ba89b3c358a5f78727b3732f11))
+
+
+### Features
+
+* migarete to PostCSS 8 ([#975](https://github.com/cssnano/cssnano/issues/975)) ([40b82dc](https://github.com/cssnano/cssnano/commit/40b82dca7f53ac02cd4fe62846dec79b898ccb49))
+* **postcss-merge-rules:** merge at-rules ([#722](https://github.com/cssnano/cssnano/issues/722)) ([8d4610a](https://github.com/cssnano/cssnano/commit/8d4610a6391ddab29bcb08ef0522d0b7ce2d6582))
+
+
+### BREAKING CHANGES
+
+* minimum supported `postcss` version is `8.2.1`
+* minimum require version of node is 10.13
+
+
+
+## 4.1.9 (2019-02-12)
+
+
+### Performance Improvements
+
+* **postcss-merge-rules:** increase perf ([#681](https://github.com/cssnano/cssnano/issues/681)) ([35bad2b](https://github.com/cssnano/cssnano/commit/35bad2b70fca5390c88eaabc24c25bb8d28b2f95))
+
+
+
+## 4.1.1 (2018-09-24)
+
+
+### Bug Fixes
+
+* handle uppercase `all` property in merge rules ([#611](https://github.com/cssnano/cssnano/issues/611)) ([0dfe335](https://github.com/cssnano/cssnano/commit/0dfe3355951fa4a080a04dca34c6d99420def7ac))
+* merge same atrules with difference case ([#605](https://github.com/cssnano/cssnano/issues/605)) ([ca350fd](https://github.com/cssnano/cssnano/commit/ca350fda779bab5ca2eadf70299d92f8e495a273))
+* **postcss-merge-longhand:** not mangle border output ([#555](https://github.com/cssnano/cssnano/issues/555)) ([9a70605](https://github.com/cssnano/cssnano/commit/9a706050b621e7795a9bf74eb7110b5c81804ffe)), closes [#553](https://github.com/cssnano/cssnano/issues/553) [#554](https://github.com/cssnano/cssnano/issues/554)

package/dist/index.js

@@ -1,241 +1,445 @@
-'use strict';
+"use strict";
 
 Object.defineProperty(exports, "__esModule", {
-    value: true
+  value: true
 });
+exports.default = void 0;
 
-var _browserslist = require('browserslist');
+var _browserslist = _interopRequireDefault(require("browserslist"));
 
-var _browserslist2 = _interopRequireDefault(_browserslist);
+var _vendors = _interopRequireDefault(require("vendors"));
 
-var _postcss = require('postcss');
+var _cssnanoUtils = require("cssnano-utils");
 
-var _postcss2 = _interopRequireDefault(_postcss);
+var _ensureCompatibility = _interopRequireDefault(require("./lib/ensureCompatibility"));
 
-var _vendors = require('vendors');
-
-var _vendors2 = _interopRequireDefault(_vendors);
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-var _cssnanoUtilSameParent = require('cssnano-util-same-parent');
+/** @type {string[]} */
+const prefixes = _vendors.default.map(v => `-${v}-`);
+/**
+ * @param {postcss.Declaration} a
+ * @param {postcss.Declaration} b
+ * @return {boolean}
+ */
 
-var _cssnanoUtilSameParent2 = _interopRequireDefault(_cssnanoUtilSameParent);
 
-var _ensureCompatibility = require('./lib/ensureCompatibility');
+function declarationIsEqual(a, b) {
+  return a.important === b.important && a.prop === b.prop && a.value === b.value;
+}
+/**
+ * @param {postcss.Declaration[]} array
+ * @param {postcss.Declaration} decl
+ * @return {number}
+ */
 
-var _ensureCompatibility2 = _interopRequireDefault(_ensureCompatibility);
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function indexOfDeclaration(array, 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 {boolean} [not=false]
+ * @return {postcss.Declaration[]}
+ */
 
-const prefixes = _vendors2.default.map(v => `-${v}-`);
 
 function intersect(a, b, not) {
-    return a.filter(c => {
-        const index = ~b.indexOf(c);
-        return not ? !index : index;
-    });
+  return a.filter(c => {
+    const index = ~indexOfDeclaration(b, c);
+    return not ? !index : index;
+  });
 }
+/**
+ * @param {postcss.Declaration[]} a
+ * @param {postcss.Declaration[]} b
+ * @return {boolean}
+ */
+
 
-// Internet Explorer use :-ms-input-placeholder.
+function sameDeclarationsAndOrder(a, b) {
+  if (a.length !== b.length) {
+    return false;
+  }
+
+  return a.every((d, index) => declarationIsEqual(d, b[index]));
+} // Internet Explorer use :-ms-input-placeholder.
 // Microsoft Edge use ::-ms-input-placeholder.
+
+
 const findMsInputPlaceholder = selector => ~selector.search(/-ms-input-placeholder/i);
-const different = (a, b) => intersect(a, b, true).concat(intersect(b, a, true));
-const filterPrefixes = selector => intersect(prefixes, selector);
+/**
+ * @param {string} selector
+ * @return {string[]}
+ */
+
+
+function filterPrefixes(selector) {
+  return prefixes.filter(prefix => selector.indexOf(prefix) !== -1);
+}
 
 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));
+  let same = selectors => selectors.map(filterPrefixes).join();
+
+  let findMsVendor = selectors => selectors.find(findMsInputPlaceholder);
+
+  return same(selectorsA) === same(selectorsB) && !(findMsVendor(selectorsA) && findMsVendor(selectorsB));
 }
+/**
+ * @param {string} selector
+ * @return {boolean}
+ */
+
+
+function noVendor(selector) {
+  return !filterPrefixes(selector).length;
+}
+/**
+ * @param {postcss.Rule} ruleA
+ * @param {postcss.Rule} ruleB
+ * @param {string[]=} browsers
+ * @param {Object.<string, boolean>=} compatibilityCache
+ * @return {boolean}
+ */
 
-const noVendor = selector => !filterPrefixes(selector).length;
 
 function canMerge(ruleA, ruleB, browsers, compatibilityCache) {
-    const a = ruleA.selectors;
-    const b = ruleB.selectors;
+  const a = ruleA.selectors;
+  const b = ruleB.selectors;
+  const selectors = a.concat(b);
 
-    const selectors = a.concat(b);
+  if (!(0, _ensureCompatibility.default)(selectors, browsers, compatibilityCache)) {
+    return false;
+  }
 
-    if (!(0, _ensureCompatibility2.default)(selectors, browsers, compatibilityCache)) {
-        return false;
-    }
+  const parent = (0, _cssnanoUtils.sameParent)(ruleA, ruleB);
+  const {
+    name
+  } = ruleA.parent;
 
-    const parent = (0, _cssnanoUtilSameParent2.default)(ruleA, ruleB);
-    const { name } = ruleA.parent;
-    if (parent && name && ~name.indexOf('keyframes')) {
-        return false;
-    }
-    return parent && (selectors.every(noVendor) || sameVendor(a, b));
+  if (parent && name && ~name.indexOf('keyframes')) {
+    return false;
+  }
+
+  return parent && (selectors.every(noVendor) || sameVendor(a, b));
+}
+/**
+ * @param {postcss.Rule} rule
+ * @return {postcss.Declaration[]}
+ */
+
+
+function getDecls(rule) {
+  return rule.nodes.filter(node => node.type === 'decl');
 }
 
-const getDecls = rule => rule.nodes && rule.nodes.map(String);
 const joinSelectors = (...rules) => rules.map(s => s.selector).join();
 
 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[]}}
+ */
+
 
 function splitProp(prop) {
-    const parts = prop.split('-');
-    let base, rest;
-    // 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.
-    if (prop[0] === '-') {
-        base = parts[2];
-        rest = parts.slice(3);
-    } else {
-        base = parts[0];
-        rest = parts.slice(1);
-    }
-    return [base, rest];
+  // 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('-');
+
+  if (prop[0] !== '-') {
+    return {
+      prefix: '',
+      base: parts[0],
+      rest: parts.slice(1)
+    };
+  } // Don't split css variables
+
+
+  if (prop[1] === '-') {
+    return {
+      prefix: null,
+      base: null,
+      rest: [prop]
+    };
+  } // Found prefix
+
+
+  return {
+    prefix: parts[1],
+    base: parts[2],
+    rest: parts.slice(3)
+  };
 }
+/**
+ * @param {string} propA
+ * @param {string} propB
+ */
+
 
 function isConflictingProp(propA, propB) {
-    if (propA === propB) {
-        return true;
-    }
-    const a = splitProp(propA);
-    const b = splitProp(propB);
-    return a[0] === b[0] && a[1].length !== b[1].length;
+  if (propA === propB) {
+    // Same specificity
+    return true;
+  }
+
+  const a = splitProp(propA);
+  const b = splitProp(propB); // Don't resort css variables
+
+  if (!a.base && !b.base) {
+    return true;
+  } // Different base;
+
+
+  if (a.base !== b.base) {
+    return false;
+  } // Conflict if rest-count mismatches
+
+
+  if (a.rest.length !== b.rest.length) {
+    return true;
+  } // 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
+ * @return {boolean} merged
+ */
+
+
+function mergeParents(first, second) {
+  // Null check for detached rules
+  if (!first.parent || !second.parent) {
+    return false;
+  } // Check if parents share node
+
 
-function hasConflicts(declProp, notMoved) {
-    return notMoved.some(prop => isConflictingProp(prop, declProp));
+  if (first.parent === second.parent) {
+    return false;
+  } // 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
+ */
+
 
 function partialMerge(first, second) {
-    let intersection = intersect(getDecls(first), getDecls(second));
-    if (!intersection.length) {
-        return 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();
+    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;
+      second = nextRule;
+      intersection = nextIntersection;
     }
-    let nextRule = second.next();
-    if (nextRule && nextRule.type === 'rule' && canMerge(second, nextRule)) {
-        let nextIntersection = intersect(getDecls(second), getDecls(nextRule));
-        if (nextIntersection.length > intersection.length) {
-            first = second;second = nextRule;intersection = nextIntersection;
-        }
+  }
+
+  const firstDecls = getDecls(first); // Filter out intersections with later conflicts in First
+
+  intersection = intersection.filter((decl, intersectIndex) => {
+    const index = indexOfDeclaration(firstDecls, decl);
+    const nextConflictInFirst = firstDecls.slice(index + 1).find(d => isConflictingProp(d.prop, decl.prop));
+
+    if (!nextConflictInFirst) {
+      return true;
     }
-    const recievingBlock = second.clone();
-    recievingBlock.selector = joinSelectors(first, second);
-    recievingBlock.nodes = [];
-    const difference = different(getDecls(first), getDecls(second));
-    const filterConflicts = (decls, intersectn) => {
-        let willNotMove = [];
-        return decls.reduce((willMove, decl) => {
-            let intersects = ~intersectn.indexOf(decl);
-            let prop = decl.split(':')[0];
-            let base = prop.split('-')[0];
-            let canMove = difference.every(d => d.split(':')[0] !== base);
-            if (intersects && canMove && !hasConflicts(prop, willNotMove)) {
-                willMove.push(decl);
-            } else {
-                willNotMove.push(prop);
-            }
-            return willMove;
-        }, []);
-    };
-    const containsAllDeclaration = intersectionList => {
-        return intersectionList.some(declaration => {
-            return declaration.split(':')[0].toLowerCase() === 'all';
-        });
-    };
-    intersection = filterConflicts(getDecls(first).reverse(), intersection);
-    intersection = filterConflicts(getDecls(second), intersection);
-
-    // Rules with "all" declarations must be on top
-    if (containsAllDeclaration(intersection)) {
-        second.parent.insertBefore(first, recievingBlock);
-    } else {
-        second.parent.insertBefore(second, recievingBlock);
+
+    const nextConflictInIntersection = intersection.slice(intersectIndex + 1).find(d => isConflictingProp(d.prop, decl.prop));
+
+    if (!nextConflictInIntersection) {
+      return false;
+    }
+
+    if (declarationIsEqual(nextConflictInFirst, nextConflictInIntersection)) {
+      return true;
+    }
+
+    return false;
+  }); // 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));
+
+    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')) {
+      return false;
     }
 
-    const firstClone = first.clone();
-    const secondClone = second.clone();
-    const moveDecl = callback => {
-        return decl => {
-            if (~intersection.indexOf(String(decl))) {
-                callback.call(this, decl);
-            }
-        };
+    secondDecls.splice(nextConflictIndex, 1);
+    return true;
+  });
+
+  if (!intersection.length) {
+    // Nothing to merge
+    return second;
+  }
+
+  const receivingBlock = second.clone();
+  receivingBlock.selector = joinSelectors(first, second);
+  receivingBlock.nodes = [];
+  second.parent.insertBefore(second, receivingBlock);
+  const firstClone = first.clone();
+  const secondClone = second.clone();
+  /**
+   * @param {function(postcss.Declaration):void} callback
+   * @return {function(postcss.Declaration)}
+   */
+
+  function moveDecl(callback) {
+    return decl => {
+      if (~indexOfDeclaration(intersection, decl)) {
+        callback.call(this, decl);
+      }
     };
-    firstClone.walkDecls(moveDecl(decl => {
-        decl.remove();
-        recievingBlock.append(decl);
-    }));
-    secondClone.walkDecls(moveDecl(decl => decl.remove()));
-    const merged = ruleLength(firstClone, recievingBlock, secondClone);
-    const original = ruleLength(first, second);
-    if (merged < original) {
-        first.replaceWith(firstClone);
-        second.replaceWith(secondClone);
-        [firstClone, recievingBlock, secondClone].forEach(r => {
-            if (!r.nodes.length) {
-                r.remove();
-            }
-        });
-        if (!secondClone.parent) {
-            return recievingBlock;
-        }
-        return secondClone;
-    } else {
-        recievingBlock.remove();
-        return second;
+  }
+
+  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 => {
+      if (!r.nodes.length) {
+        r.remove();
+      }
+    });
+
+    if (!secondClone.parent) {
+      return receivingBlock;
     }
+
+    return secondClone;
+  } else {
+    receivingBlock.remove();
+    return second;
+  }
 }
+/**
+ * @param {string[]} browsers
+ * @param {Object.<string, boolean>} compatibilityCache
+ * @return {function(postcss.Rule)}
+ */
+
 
 function selectorMerger(browsers, compatibilityCache) {
-    let cache = null;
-    return function (rule) {
-        // Prime the cache with the first rule, or alternately ensure that it is
-        // safe to merge both declarations before continuing
-        if (!cache || !canMerge(rule, cache, browsers, compatibilityCache)) {
-            cache = rule;
-            return;
-        }
-        // Ensure that we don't deduplicate the same rule; this is sometimes
-        // caused by a partial merge
-        if (cache === rule) {
-            cache = rule;
-            return;
-        }
-        // Merge when declarations are exactly equal
-        // e.g. h1 { color: red } h2 { color: red }
-        if (getDecls(rule).join(';') === getDecls(cache).join(';')) {
-            rule.selector = joinSelectors(cache, rule);
-            cache.remove();
-            cache = rule;
-            return;
+  /** @type {postcss.Rule} */
+  let cache = null;
+  return function (rule) {
+    // Prime the cache with the first rule, or alternately ensure that it is
+    // safe to merge both declarations before continuing
+    if (!cache || !canMerge(rule, cache, browsers, compatibilityCache)) {
+      cache = rule;
+      return;
+    } // 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
+
+
+    mergeParents(cache, rule); // 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
+    // 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();
         }
-        // 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 (~cached.indexOf(String(decl))) {
-                    return decl.remove();
-                }
-                cache.append(decl);
-            });
-            rule.remove();
-            return;
+
+        cache.append(decl);
+      });
+      rule.remove();
+      return;
+    } // 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);
+  };
+}
+
+function pluginCreator() {
+  return {
+    postcssPlugin: 'postcss-merge-rules',
+
+    prepare(result) {
+      const resultOpts = result.opts || {};
+      const browsers = (0, _browserslist.default)(null, {
+        stats: resultOpts.stats,
+        path: __dirname,
+        env: resultOpts.env
+      });
+      const compatibilityCache = {};
+      return {
+        OnceExit(css) {
+          css.walkRules(selectorMerger(browsers, compatibilityCache));
         }
-        // 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);
-    };
+
+      };
+    }
+
+  };
 }
 
-exports.default = _postcss2.default.plugin('postcss-merge-rules', () => {
-    return (css, result) => {
-        const resultOpts = result.opts || {};
-        const browsers = (0, _browserslist2.default)(null, {
-            stats: resultOpts.stats,
-            path: __dirname,
-            env: resultOpts.env
-        });
-        const compatibilityCache = {};
-        css.walkRules(selectorMerger(browsers, compatibilityCache));
-    };
-});
-module.exports = exports['default'];
+pluginCreator.postcss = true;
+var _default = pluginCreator;
+exports.default = _default;
+module.exports = exports.default;

package/dist/lib/ensureCompatibility.js

@@ -1,155 +1,170 @@
-'use strict';
+"use strict";
 
 Object.defineProperty(exports, "__esModule", {
-    value: true
+  value: true
 });
-exports.pseudoElements = undefined;
 exports.default = ensureCompatibility;
+exports.pseudoElements = void 0;
 
-var _caniuseApi = require('caniuse-api');
+var _caniuseApi = require("caniuse-api");
 
-var _postcssSelectorParser = require('postcss-selector-parser');
-
-var _postcssSelectorParser2 = _interopRequireDefault(_postcssSelectorParser);
+var _postcssSelectorParser = _interopRequireDefault(require("postcss-selector-parser"));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 const simpleSelectorRe = /^#?[-._a-z0-9 ]+$/i;
-
 const cssSel2 = 'css-sel2';
 const cssSel3 = 'css-sel3';
 const cssGencontent = 'css-gencontent';
 const cssFirstLetter = 'css-first-letter';
 const cssFirstLine = 'css-first-line';
 const cssInOutOfRange = 'css-in-out-of-range';
-
-const pseudoElements = exports.pseudoElements = {
-    ':active': cssSel2,
-    ':after': cssGencontent,
-    ':before': cssGencontent,
-    ':checked': cssSel3,
-    ':default': 'css-default-pseudo',
-    ':dir': 'css-dir-pseudo',
-    ':disabled': cssSel3,
-    ':empty': cssSel3,
-    ':enabled': cssSel3,
-    ':first-child': cssSel2,
-    ':first-letter': cssFirstLetter,
-    ':first-line': cssFirstLine,
-    ':first-of-type': cssSel3,
-    ':focus': cssSel2,
-    ':focus-within': 'css-focus-within',
-    ':has': 'css-has',
-    ':hover': cssSel2,
-    ':in-range': cssInOutOfRange,
-    ':indeterminate': 'css-indeterminate-pseudo',
-    ':lang': cssSel2,
-    ':last-child': cssSel3,
-    ':last-of-type': cssSel3,
-    ':matches': 'css-matches-pseudo',
-    ':not': cssSel3,
-    ':nth-child': cssSel3,
-    ':nth-last-child': cssSel3,
-    ':nth-last-of-type': cssSel3,
-    ':nth-of-type': cssSel3,
-    ':only-child': cssSel3,
-    ':only-of-type': cssSel3,
-    ':optional': 'css-optional-pseudo',
-    ':out-of-range': cssInOutOfRange,
-    ':placeholder-shown': 'css-placeholder-shown',
-    ':root': cssSel3,
-    ':target': cssSel3,
-    '::after': cssGencontent,
-    '::backdrop': 'dialog',
-    '::before': cssGencontent,
-    '::first-letter': cssFirstLetter,
-    '::first-line': cssFirstLine,
-    '::marker': 'css-marker-pseudo',
-    '::placeholder': 'css-placeholder',
-    '::selection': 'css-selection'
+const pseudoElements = {
+  ':active': cssSel2,
+  ':after': cssGencontent,
+  ':before': cssGencontent,
+  ':checked': cssSel3,
+  ':default': 'css-default-pseudo',
+  ':dir': 'css-dir-pseudo',
+  ':disabled': cssSel3,
+  ':empty': cssSel3,
+  ':enabled': cssSel3,
+  ':first-child': cssSel2,
+  ':first-letter': cssFirstLetter,
+  ':first-line': cssFirstLine,
+  ':first-of-type': cssSel3,
+  ':focus': cssSel2,
+  ':focus-within': 'css-focus-within',
+  ':focus-visible': 'css-focus-visible',
+  ':has': 'css-has',
+  ':hover': cssSel2,
+  ':in-range': cssInOutOfRange,
+  ':indeterminate': 'css-indeterminate-pseudo',
+  ':lang': cssSel2,
+  ':last-child': cssSel3,
+  ':last-of-type': cssSel3,
+  ':matches': 'css-matches-pseudo',
+  ':not': cssSel3,
+  ':nth-child': cssSel3,
+  ':nth-last-child': cssSel3,
+  ':nth-last-of-type': cssSel3,
+  ':nth-of-type': cssSel3,
+  ':only-child': cssSel3,
+  ':only-of-type': cssSel3,
+  ':optional': 'css-optional-pseudo',
+  ':out-of-range': cssInOutOfRange,
+  ':placeholder-shown': 'css-placeholder-shown',
+  ':root': cssSel3,
+  ':target': cssSel3,
+  '::after': cssGencontent,
+  '::backdrop': 'dialog',
+  '::before': cssGencontent,
+  '::first-letter': cssFirstLetter,
+  '::first-line': cssFirstLine,
+  '::marker': 'css-marker-pseudo',
+  '::placeholder': 'css-placeholder',
+  '::selection': 'css-selection'
 };
+exports.pseudoElements = pseudoElements;
 
 function isCssMixin(selector) {
-    return selector[selector.length - 1] === ':';
+  return selector[selector.length - 1] === ':';
 }
 
-const isSupportedCache = {};
+const isSupportedCache = {}; // Move to util in future
 
-// Move to util in future
 function isSupportedCached(feature, browsers) {
-    const key = JSON.stringify({ feature, browsers });
-    let result = isSupportedCache[key];
-
-    if (!result) {
-        result = (0, _caniuseApi.isSupported)(feature, browsers);
-        isSupportedCache[key] = result;
-    }
-
-    return result;
+  const key = JSON.stringify({
+    feature,
+    browsers
+  });
+  let result = isSupportedCache[key];
+
+  if (!result) {
+    result = (0, _caniuseApi.isSupported)(feature, browsers);
+    isSupportedCache[key] = result;
+  }
+
+  return result;
 }
 
 function ensureCompatibility(selectors, browsers, compatibilityCache) {
-    // Should not merge mixins
-    if (selectors.some(isCssMixin)) {
-        return false;
+  // Should not merge mixins
+  if (selectors.some(isCssMixin)) {
+    return false;
+  }
+
+  return selectors.every(selector => {
+    if (simpleSelectorRe.test(selector)) {
+      return true;
     }
-    return selectors.every(selector => {
-        if (simpleSelectorRe.test(selector)) {
-            return true;
+
+    if (compatibilityCache && selector in compatibilityCache) {
+      return compatibilityCache[selector];
+    }
+
+    let compatible = true;
+    (0, _postcssSelectorParser.default)(ast => {
+      ast.walk(node => {
+        const {
+          type,
+          value
+        } = node;
+
+        if (type === 'pseudo') {
+          const entry = pseudoElements[value];
+
+          if (entry && compatible) {
+            compatible = isSupportedCached(entry, browsers);
+          }
+        }
+
+        if (type === 'combinator') {
+          if (~value.indexOf('~')) {
+            compatible = isSupportedCached(cssSel3, browsers);
+          }
+
+          if (~value.indexOf('>') || ~value.indexOf('+')) {
+            compatible = isSupportedCached(cssSel2, browsers);
+          }
         }
-        if (compatibilityCache && selector in compatibilityCache) {
-            return compatibilityCache[selector];
+
+        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)) {
+              compatible = isSupportedCached(cssSel2, browsers);
+            } // [foo^="bar"], [foo$="bar"], [foo*="bar"]
+
+
+            if (~['^=', '$=', '*='].indexOf(node.operator)) {
+              compatible = isSupportedCached(cssSel3, browsers);
+            }
+          } // [foo="bar" i]
+
+
+          if (node.insensitive) {
+            compatible = isSupportedCached('css-case-insensitive', browsers);
+          }
         }
-        let compatible = true;
-        (0, _postcssSelectorParser2.default)(ast => {
-            ast.walk(node => {
-                const { type, value } = node;
-                if (type === 'pseudo') {
-                    const entry = pseudoElements[value];
-                    if (entry && compatible) {
-                        compatible = isSupportedCached(entry, browsers);
-                    }
-                }
-                if (type === 'combinator') {
-                    if (~value.indexOf('~')) {
-                        compatible = isSupportedCached(cssSel3, browsers);
-                    }
-                    if (~value.indexOf('>') || ~value.indexOf('+')) {
-                        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)) {
-                            compatible = isSupportedCached(cssSel2, browsers);
-                        }
-                        // [foo^="bar"], [foo$="bar"], [foo*="bar"]
-                        if (~['^=', '$=', '*='].indexOf(node.operator)) {
-                            compatible = isSupportedCached(cssSel3, browsers);
-                        }
-                    }
-
-                    // [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
-                    return false;
-                }
-            });
-        }).processSync(selector);
-        if (compatibilityCache) {
-            compatibilityCache[selector] = compatible;
+
+        if (!compatible) {
+          // If this node was not compatible,
+          // break out early from walking the rest
+          return false;
         }
-        return compatible;
-    });
+      });
+    }).processSync(selector);
+
+    if (compatibilityCache) {
+      compatibilityCache[selector] = compatible;
+    }
+
+    return compatible;
+  });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "postcss-merge-rules",
-  "version": "4.0.3",
+  "version": "5.0.0",
   "description": "Merge CSS rules with PostCSS.",
   "main": "dist/index.js",
   "files": [
@@ -8,7 +8,9 @@
     "dist"
   ],
   "scripts": {
-    "prepublish": "cross-env BABEL_ENV=publish babel src --out-dir dist --ignore /__tests__/"
+    "prebuild": "del-cli dist",
+    "build": "cross-env BABEL_ENV=publish babel src --config-file ../../babel.config.js --out-dir dist --ignore \"**/__tests__/\"",
+    "prepublish": "yarn build"
   },
   "keywords": [
     "css",
@@ -17,12 +19,6 @@
     "postcss-plugin"
   ],
   "license": "MIT",
-  "devDependencies": {
-    "babel-cli": "^6.0.0",
-    "cross-env": "^5.0.0",
-    "postcss-discard-comments": "^4.0.0",
-    "postcss-simple-vars": "^5.0.1"
-  },
   "homepage": "https://github.com/cssnano/cssnano",
   "author": {
     "name": "Ben Briggs",
@@ -31,17 +27,23 @@
   },
   "repository": "cssnano/cssnano",
   "dependencies": {
-    "browserslist": "^4.0.0",
+    "browserslist": "^4.16.0",
     "caniuse-api": "^3.0.0",
-    "cssnano-util-same-parent": "^4.0.0",
-    "postcss": "^7.0.0",
-    "postcss-selector-parser": "^3.0.0",
-    "vendors": "^1.0.0"
+    "cssnano-utils": "^2.0.0",
+    "postcss-selector-parser": "^6.0.4",
+    "vendors": "^1.0.3"
   },
   "bugs": {
     "url": "https://github.com/cssnano/cssnano/issues"
   },
   "engines": {
-    "node": ">=6.9.0"
-  }
+    "node": "^10 || ^12 || >=14.0"
+  },
+  "devDependencies": {
+    "postcss": "^8.2.1"
+  },
+  "peerDependencies": {
+    "postcss": "^8.2.1"
+  },
+  "gitHead": "0e2c3bf5835bafcdc8783bef66f730a24194c8f3"
 }