nav tabs on admin dashboard

node_modules/postcss-merge-rules/dist/index.js

@@ -1,6 +1,8 @@
 'use strict';
 
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
 
 var _browserslist = require('browserslist');
 
@@ -14,9 +16,9 @@ var _vendors = require('vendors');
 
 var _vendors2 = _interopRequireDefault(_vendors);
 
-var _clone = require('./lib/clone');
+var _cssnanoUtilSameParent = require('cssnano-util-same-parent');
 
-var _clone2 = _interopRequireDefault(_clone);
+var _cssnanoUtilSameParent2 = _interopRequireDefault(_cssnanoUtilSameParent);
 
 var _ensureCompatibility = require('./lib/ensureCompatibility');
 
@@ -24,91 +26,57 @@ var _ensureCompatibility2 = _interopRequireDefault(_ensureCompatibility);
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-var prefixes = _vendors2.default.map(function (v) {
-    return '-' + v + '-';
-});
+const prefixes = _vendors2.default.map(v => `-${v}-`);
 
 function intersect(a, b, not) {
-    return a.filter(function (c) {
-        var index = ~b.indexOf(c);
+    return a.filter(c => {
+        const index = ~b.indexOf(c);
         return not ? !index : index;
     });
 }
 
-var different = function different(a, b) {
-    return intersect(a, b, true).concat(intersect(b, a, true));
-};
-var filterPrefixes = function filterPrefixes(selector) {
-    return intersect(prefixes, selector);
-};
+// 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);
 
 function sameVendor(selectorsA, selectorsB) {
-    var same = function same(selectors) {
-        return selectors.map(filterPrefixes).join();
-    };
-    return same(selectorsA) === same(selectorsB);
+    let same = selectors => selectors.map(filterPrefixes).join();
+    let findMsVendor = selectors => selectors.find(findMsInputPlaceholder);
+    return same(selectorsA) === same(selectorsB) && !(findMsVendor(selectorsA) && findMsVendor(selectorsB));
 }
 
-var noVendor = function noVendor(selector) {
-    return !filterPrefixes(selector).length;
-};
-
-function sameParent(ruleA, ruleB) {
-    var hasParent = ruleA.parent && ruleB.parent;
-    var sameType = hasParent && ruleA.parent.type === ruleB.parent.type;
-    // If an at rule, ensure that the parameters are the same
-    if (hasParent && ruleA.parent.type !== 'root' && ruleB.parent.type !== 'root') {
-        sameType = sameType && ruleA.parent.params === ruleB.parent.params && ruleA.parent.name === ruleB.parent.name;
-    }
-    return hasParent ? sameType : true;
-}
+const noVendor = selector => !filterPrefixes(selector).length;
 
 function canMerge(ruleA, ruleB, browsers, compatibilityCache) {
-    var a = ruleA.selectors;
-    var b = ruleB.selectors;
+    const a = ruleA.selectors;
+    const b = ruleB.selectors;
 
-    var selectors = a.concat(b);
+    const selectors = a.concat(b);
 
     if (!(0, _ensureCompatibility2.default)(selectors, browsers, compatibilityCache)) {
         return false;
     }
 
-    var parent = sameParent(ruleA, ruleB);
-    var name = ruleA.parent.name;
-
+    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));
 }
 
-var getDecls = function getDecls(rule) {
-    return rule.nodes ? rule.nodes.map(String) : [];
-};
-var joinSelectors = function joinSelectors() {
-    for (var _len = arguments.length, rules = Array(_len), _key = 0; _key < _len; _key++) {
-        rules[_key] = arguments[_key];
-    }
+const getDecls = rule => rule.nodes && rule.nodes.map(String);
+const joinSelectors = (...rules) => rules.map(s => s.selector).join();
 
-    return rules.map(function (s) {
-        return s.selector;
-    }).join();
-};
-
-function ruleLength() {
-    for (var _len2 = arguments.length, rules = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
-        rules[_key2] = arguments[_key2];
-    }
-
-    return rules.map(function (r) {
-        return r.nodes.length ? String(r) : '';
-    }).join('').length;
+function ruleLength(...rules) {
+    return rules.map(r => r.nodes.length ? String(r) : '').join('').length;
 }
 
 function splitProp(prop) {
-    var parts = prop.split('-');
-    var base = void 0,
-        rest = void 0;
+    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
@@ -127,45 +95,38 @@ function isConflictingProp(propA, propB) {
     if (propA === propB) {
         return true;
     }
-    var a = splitProp(propA);
-    var b = splitProp(propB);
+    const a = splitProp(propA);
+    const b = splitProp(propB);
     return a[0] === b[0] && a[1].length !== b[1].length;
 }
 
 function hasConflicts(declProp, notMoved) {
-    return notMoved.some(function (prop) {
-        return isConflictingProp(prop, declProp);
-    });
+    return notMoved.some(prop => isConflictingProp(prop, declProp));
 }
 
 function partialMerge(first, second) {
-    var _this = this;
-
-    var intersection = intersect(getDecls(first), getDecls(second));
+    let intersection = intersect(getDecls(first), getDecls(second));
     if (!intersection.length) {
         return second;
     }
-    var nextRule = second.next();
+    let nextRule = second.next();
     if (nextRule && nextRule.type === 'rule' && canMerge(second, nextRule)) {
-        var nextIntersection = intersect(getDecls(second), getDecls(nextRule));
+        let nextIntersection = intersect(getDecls(second), getDecls(nextRule));
         if (nextIntersection.length > intersection.length) {
             first = second;second = nextRule;intersection = nextIntersection;
         }
     }
-    var recievingBlock = (0, _clone2.default)(second);
+    const recievingBlock = second.clone();
     recievingBlock.selector = joinSelectors(first, second);
     recievingBlock.nodes = [];
-    second.parent.insertBefore(second, recievingBlock);
-    var difference = different(getDecls(first), getDecls(second));
-    var filterConflicts = function filterConflicts(decls, intersectn) {
-        var willNotMove = [];
-        return decls.reduce(function (willMove, decl) {
-            var intersects = ~intersectn.indexOf(decl);
-            var prop = decl.split(':')[0];
-            var base = prop.split('-')[0];
-            var canMove = difference.every(function (d) {
-                return d.split(':')[0] !== base;
-            });
+    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 {
@@ -174,30 +135,41 @@ function partialMerge(first, second) {
             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);
-    var firstClone = (0, _clone2.default)(first);
-    var secondClone = (0, _clone2.default)(second);
-    var moveDecl = function moveDecl(callback) {
-        return function (decl) {
+
+    // Rules with "all" declarations must be on top
+    if (containsAllDeclaration(intersection)) {
+        second.parent.insertBefore(first, recievingBlock);
+    } else {
+        second.parent.insertBefore(second, recievingBlock);
+    }
+
+    const firstClone = first.clone();
+    const secondClone = second.clone();
+    const moveDecl = callback => {
+        return decl => {
             if (~intersection.indexOf(String(decl))) {
-                callback.call(_this, decl);
+                callback.call(this, decl);
             }
         };
     };
-    firstClone.walkDecls(moveDecl(function (decl) {
+    firstClone.walkDecls(moveDecl(decl => {
         decl.remove();
         recievingBlock.append(decl);
     }));
-    secondClone.walkDecls(moveDecl(function (decl) {
-        return decl.remove();
-    }));
-    var merged = ruleLength(firstClone, recievingBlock, secondClone);
-    var original = ruleLength(first, second);
+    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(function (r) {
+        [firstClone, recievingBlock, secondClone].forEach(r => {
             if (!r.nodes.length) {
                 r.remove();
             }
@@ -213,7 +185,7 @@ function partialMerge(first, second) {
 }
 
 function selectorMerger(browsers, compatibilityCache) {
-    var cache = null;
+    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
@@ -238,12 +210,12 @@ function selectorMerger(browsers, compatibilityCache) {
         // Merge when both selectors are exactly equal
         // e.g. a { color: blue } a { font-weight: bold }
         if (cache.selector === rule.selector) {
-            var cached = getDecls(cache);
-            rule.walk(function (decl) {
+            const cached = getDecls(cache);
+            rule.walk(decl => {
                 if (~cached.indexOf(String(decl))) {
                     return decl.remove();
                 }
-                decl.moveTo(cache);
+                cache.append(decl);
             });
             rule.remove();
             return;
@@ -254,16 +226,15 @@ function selectorMerger(browsers, compatibilityCache) {
     };
 }
 
-exports.default = _postcss2.default.plugin('postcss-merge-rules', function () {
-    return function (css, result) {
-        var opts = result.opts;
-
-        var browsers = (0, _browserslist2.default)(null, {
-            stats: opts && opts.stats,
-            path: opts && opts.from,
-            env: opts && opts.env
+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
         });
-        var compatibilityCache = {};
+        const compatibilityCache = {};
         css.walkRules(selectorMerger(browsers, compatibilityCache));
     };
 });

node_modules/postcss-merge-rules/dist/lib/clone.js

@@ -1,35 +0,0 @@
-'use strict';
-
-exports.__esModule = true;
-
-var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
-
-var clone = function clone(obj, parent) {
-    if ((typeof obj === 'undefined' ? 'undefined' : _typeof(obj)) !== 'object' || obj === null) {
-        return obj;
-    }
-    var cloned = new obj.constructor();
-    for (var i in obj) {
-        if (!{}.hasOwnProperty.call(obj, i)) {
-            continue;
-        }
-        var value = obj[i];
-        if (i === 'parent' && (typeof value === 'undefined' ? 'undefined' : _typeof(value)) === 'object') {
-            if (parent) {
-                cloned[i] = parent;
-            }
-        } else if (i === 'source') {
-            cloned[i] = value;
-        } else if (value instanceof Array) {
-            cloned[i] = value.map(function (j) {
-                return clone(j, cloned);
-            });
-        } else {
-            cloned[i] = clone(value, cloned);
-        }
-    }
-    return cloned;
-};
-
-exports.default = clone;
-module.exports = exports['default'];

node_modules/postcss-merge-rules/dist/lib/ensureCompatibility.js

@@ -1,6 +1,8 @@
 'use strict';
 
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
 exports.pseudoElements = undefined;
 exports.default = ensureCompatibility;
 
@@ -12,16 +14,16 @@ var _postcssSelectorParser2 = _interopRequireDefault(_postcssSelectorParser);
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-var simpleSelectorRe = /^#?[-._a-z0-9 ]+$/i;
+const simpleSelectorRe = /^#?[-._a-z0-9 ]+$/i;
 
-var cssSel2 = 'css-sel2';
-var cssSel3 = 'css-sel3';
-var cssGencontent = 'css-gencontent';
-var cssFirstLetter = 'css-first-letter';
-var cssFirstLine = 'css-first-line';
-var cssInOutOfRange = 'css-in-out-of-range';
+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';
 
-var pseudoElements = exports.pseudoElements = {
+const pseudoElements = exports.pseudoElements = {
     ':active': cssSel2,
     ':after': cssGencontent,
     ':before': cssGencontent,
@@ -71,58 +73,71 @@ function isCssMixin(selector) {
     return selector[selector.length - 1] === ':';
 }
 
+const isSupportedCache = {};
+
+// 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;
+}
+
 function ensureCompatibility(selectors, browsers, compatibilityCache) {
     // Should not merge mixins
     if (selectors.some(isCssMixin)) {
         return false;
     }
-    return selectors.every(function (selector) {
+    return selectors.every(selector => {
         if (simpleSelectorRe.test(selector)) {
             return true;
         }
         if (compatibilityCache && selector in compatibilityCache) {
             return compatibilityCache[selector];
         }
-        var compatible = true;
-        (0, _postcssSelectorParser2.default)(function (ast) {
-            ast.walk(function (node) {
-                var type = node.type,
-                    value = node.value;
-
+        let compatible = true;
+        (0, _postcssSelectorParser2.default)(ast => {
+            ast.walk(node => {
+                const { type, value } = node;
                 if (type === 'pseudo') {
-                    var entry = pseudoElements[value];
+                    const entry = pseudoElements[value];
                     if (entry && compatible) {
-                        compatible = (0, _caniuseApi.isSupported)(entry, browsers);
+                        compatible = isSupportedCached(entry, browsers);
                     }
                 }
                 if (type === 'combinator') {
                     if (~value.indexOf('~')) {
-                        compatible = (0, _caniuseApi.isSupported)(cssSel3, browsers);
+                        compatible = isSupportedCached(cssSel3, browsers);
                     }
                     if (~value.indexOf('>') || ~value.indexOf('+')) {
-                        compatible = (0, _caniuseApi.isSupported)(cssSel2, browsers);
+                        compatible = isSupportedCached(cssSel2, browsers);
                     }
                 }
                 if (type === 'attribute' && node.attribute) {
                     // [foo]
                     if (!node.operator) {
-                        compatible = (0, _caniuseApi.isSupported)(cssSel2, browsers);
+                        compatible = isSupportedCached(cssSel2, browsers);
                     }
 
                     if (value) {
                         // [foo="bar"], [foo~="bar"], [foo|="bar"]
                         if (~['=', '~=', '|='].indexOf(node.operator)) {
-                            compatible = (0, _caniuseApi.isSupported)(cssSel2, browsers);
+                            compatible = isSupportedCached(cssSel2, browsers);
                         }
                         // [foo^="bar"], [foo$="bar"], [foo*="bar"]
                         if (~['^=', '$=', '*='].indexOf(node.operator)) {
-                            compatible = (0, _caniuseApi.isSupported)(cssSel3, browsers);
+                            compatible = isSupportedCached(cssSel3, browsers);
                         }
                     }
 
                     // [foo="bar" i]
                     if (node.insensitive) {
-                        compatible = (0, _caniuseApi.isSupported)('css-case-insensitive', browsers);
+                        compatible = isSupportedCached('css-case-insensitive', browsers);
                     }
                 }
                 if (!compatible) {
@@ -131,7 +146,7 @@ function ensureCompatibility(selectors, browsers, compatibilityCache) {
                     return false;
                 }
             });
-        }).process(selector);
+        }).processSync(selector);
         if (compatibilityCache) {
             compatibilityCache[selector] = compatible;
         }