cssnano 3.8.1 → 3.10.0

package/CHANGELOG.md

@@ -1,3 +1,32 @@
+# 3.10.0
+
+* cssnano will no longer `console.warn` any messages when using deprecated
+  options; these are now sent to PostCSS. You will be able to see them if you
+  use a PostCSS runner with built-in messages support, or alternately by
+  loading `postcss-reporter` or `postcss-browser-reporter` in your plugins list.
+* Prepares support for `grid` identifier reduction by adding it to the list
+  of optimisations turned off when `options.safe` is set to `true`.
+* Adds support for normalizing `unicode-range` descriptors. Values will
+  be converted when the code matches `0` & `f` in the same place on both sides
+  of the range. So, `u+2000-2fff` can be converted to `u+2???`, but
+  `u+2100-2fff` will be left as it is.
+
+# 3.9.1
+
+* Resolves an integration issue with `v3.9.0`, where `undefined` values
+  would attempt to be parsed.
+
+# 3.9.0
+
+* Adds a new option to normalize wrapping quotes for strings & joining
+  multiple-line strings into a single line. This optimisation can potentially
+  reduce the final gzipped size of your CSS file.
+
+# 3.8.2
+
+* Resolves an issue where `display: list-item inline flow` would be normalized
+  to `inline list-item` rather than `inline-list-item` (thanks to @mattbasta).
+
 # 3.8.1
 
 * Adds a quick start file for easy integration with Runkit. Try cssnano online

package/dist/index.js

@@ -130,6 +130,14 @@ var _filterOptimiser = require('./lib/filterOptimiser');
 
 var _filterOptimiser2 = _interopRequireDefault(_filterOptimiser);
 
+var _normalizeString = require('./lib/normalizeString');
+
+var _normalizeString2 = _interopRequireDefault(_normalizeString);
+
+var _normalizeUnicode = require('./lib/normalizeUnicode');
+
+var _normalizeUnicode2 = _interopRequireDefault(_normalizeUnicode);
+
 var _reduceDisplayValues = require('./lib/reduceDisplayValues');
 
 var _reduceDisplayValues2 = _interopRequireDefault(_reduceDisplayValues);
@@ -154,12 +162,9 @@ var _styleCache = require('./lib/styleCache');
 
 var _styleCache2 = _interopRequireDefault(_styleCache);
 
-var _warnOnce = require('./lib/warnOnce');
-
-var _warnOnce2 = _interopRequireDefault(_warnOnce);
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
+// Processors
 var processors = {
     postcssFilterPlugins: function postcssFilterPlugins() {
         return (0, _postcssFilterPlugins3.default)({ silent: true });
@@ -181,6 +186,8 @@ var processors = {
     postcssMinifyParams: _postcssMinifyParams2.default,
     postcssNormalizeCharset: _postcssNormalizeCharset2.default,
     postcssDiscardOverridden: _postcssDiscardOverridden2.default,
+    normalizeString: _normalizeString2.default,
+    normalizeUnicode: _normalizeUnicode2.default,
     // minify-font-values should be run before discard-unused
     postcssMinifyFontValues: _postcssMinifyFontValues2.default,
     postcssDiscardUnused: _postcssDiscardUnused2.default,
@@ -202,13 +209,6 @@ var processors = {
     styleCache: _styleCache2.default
 };
 
-/**
- * Deprecation warnings
- */
-
-// Processors
-
-
 var defaultOptions = {
     autoprefixer: {
         add: false
@@ -233,6 +233,7 @@ var safeOptions = {
     },
     postcssReduceIdents: {
         counterStyle: false,
+        gridTemplate: false,
         keyframes: false
     },
     postcssNormalizeUrl: {
@@ -254,19 +255,30 @@ var cssnano = _postcss2.default.plugin('cssnano', function () {
 
     var safe = options.isSafe;
     var proc = (0, _postcss2.default)();
+    var warnings = [];
 
     if (typeof options.fontFamily !== 'undefined' || typeof options.minifyFontWeight !== 'undefined') {
-        (0, _warnOnce2.default)('The fontFamily & minifyFontWeight options have been ' + 'consolidated into minifyFontValues, and are now deprecated.');
+        warnings.push('The fontFamily & minifyFontWeight options have been ' + 'consolidated into minifyFontValues, and are now deprecated.');
         if (!options.minifyFontValues) {
             options.minifyFontValues = options.fontFamily;
         }
     }
 
     if (typeof options.singleCharset !== 'undefined') {
-        (0, _warnOnce2.default)('The singleCharset option has been renamed to ' + 'normalizeCharset, and is now deprecated.');
+        warnings.push('The singleCharset option has been renamed to ' + 'normalizeCharset, and is now deprecated.');
         options.normalizeCharset = options.singleCharset;
     }
 
+    if (warnings.length) {
+        proc.use(_postcss2.default.plugin('cssnano', function () {
+            return function (css, result) {
+                return warnings.forEach(function (w) {
+                    return result.warn(w);
+                });
+            };
+        }));
+    }
+
     Object.keys(processors).forEach(function (plugin) {
         var shortName = plugin.replace('postcss', '');
         shortName = shortName.slice(0, 1).toLowerCase() + shortName.slice(1);

package/dist/lib/normalizeString.js

@@ -0,0 +1,228 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
+
+var postcss = require('postcss');
+var valueParser = require('postcss-value-parser');
+
+/*
+ * Constants (parser usage)
+ */
+
+var SINGLE_QUOTE = 39;
+var DOUBLE_QUOTE = 34;
+var BACKSLASH = 92;
+var NEWLINE = 10;
+var SPACE = 32;
+var FEED = 12;
+var TAB = 9;
+var CR = 13;
+
+var WORD_END = /[ \n\t\r\f'"\\]/g;
+
+/*
+ * Constants (node type strings)
+ */
+
+var C_STRING = 'string';
+var C_ESCAPED_SINGLE_QUOTE = 'escapedSingleQuote';
+var C_ESCAPED_DOUBLE_QUOTE = 'escapedDoubleQuote';
+var C_SINGLE_QUOTE = 'singleQuote';
+var C_DOUBLE_QUOTE = 'doubleQuote';
+var C_NEWLINE = 'newline';
+var C_SINGLE = 'single';
+
+/*
+ * Literals
+ */
+
+var L_SINGLE_QUOTE = '\'';
+var L_DOUBLE_QUOTE = '"';
+var L_NEWLINE = '\\\n';
+
+/*
+ * Parser nodes
+ */
+
+var T_ESCAPED_SINGLE_QUOTE = { type: C_ESCAPED_SINGLE_QUOTE, value: '\\\'' };
+var T_ESCAPED_DOUBLE_QUOTE = { type: C_ESCAPED_DOUBLE_QUOTE, value: '\\"' };
+var T_SINGLE_QUOTE = { type: C_SINGLE_QUOTE, value: L_SINGLE_QUOTE };
+var T_DOUBLE_QUOTE = { type: C_DOUBLE_QUOTE, value: L_DOUBLE_QUOTE };
+var T_NEWLINE = { type: C_NEWLINE, value: L_NEWLINE };
+
+function stringify(ast) {
+    return ast.nodes.reduce(function (str, _ref) {
+        var value = _ref.value;
+
+        // Collapse multiple line strings automatically
+        if (value === L_NEWLINE) {
+            return str;
+        }
+        return str + value;
+    }, '');
+}
+
+function parse(str) {
+    var code = void 0,
+        next = void 0,
+        value = void 0;
+    var pos = 0;
+    var len = str.length;
+
+    var ast = {
+        nodes: [],
+        types: {
+            escapedSingleQuote: 0,
+            escapedDoubleQuote: 0,
+            singleQuote: 0,
+            doubleQuote: 0
+        },
+        quotes: false
+    };
+
+    while (pos < len) {
+        code = str.charCodeAt(pos);
+        switch (code) {
+            case SPACE:
+            case TAB:
+            case CR:
+            case FEED:
+                next = pos;
+                do {
+                    next += 1;
+                    code = str.charCodeAt(next);
+                } while (code === SPACE || code === NEWLINE || code === TAB || code === CR || code === FEED);
+
+                ast.nodes.push({
+                    type: 'space',
+                    value: str.slice(pos, next)
+                });
+                pos = next - 1;
+                break;
+            case SINGLE_QUOTE:
+                ast.nodes.push(T_SINGLE_QUOTE);
+                ast.types[C_SINGLE_QUOTE]++;
+                ast.quotes = true;
+                break;
+            case DOUBLE_QUOTE:
+                ast.nodes.push(T_DOUBLE_QUOTE);
+                ast.types[C_DOUBLE_QUOTE]++;
+                ast.quotes = true;
+                break;
+            case BACKSLASH:
+                next = pos + 1;
+                if (str.charCodeAt(next) === SINGLE_QUOTE) {
+                    ast.nodes.push(T_ESCAPED_SINGLE_QUOTE);
+                    ast.types[C_ESCAPED_SINGLE_QUOTE]++;
+                    ast.quotes = true;
+                    pos = next;
+                    break;
+                } else if (str.charCodeAt(next) === DOUBLE_QUOTE) {
+                    ast.nodes.push(T_ESCAPED_DOUBLE_QUOTE);
+                    ast.types[C_ESCAPED_DOUBLE_QUOTE]++;
+                    ast.quotes = true;
+                    pos = next;
+                    break;
+                } else if (str.charCodeAt(next) === NEWLINE) {
+                    ast.nodes.push(T_NEWLINE);
+                    pos = next;
+                    break;
+                }
+            /*
+             * We need to fall through here to handle the token as
+             * a whole word. The missing 'break' is intentional.
+             */
+            default:
+                WORD_END.lastIndex = pos + 1;
+                WORD_END.test(str);
+
+                if (WORD_END.lastIndex === 0) {
+                    next = len - 1;
+                } else {
+                    next = WORD_END.lastIndex - 2;
+                }
+
+                value = str.slice(pos, next + 1);
+
+                ast.nodes.push({
+                    type: C_STRING,
+                    value: value
+                });
+
+                pos = next;
+        }
+        pos++;
+    }
+
+    return ast;
+}
+
+function changeWrappingQuotes(node, ast) {
+    var types = ast.types;
+
+    if (types[C_SINGLE_QUOTE] || types[C_DOUBLE_QUOTE]) {
+        return;
+    }
+
+    if (node.quote === L_SINGLE_QUOTE && types[C_ESCAPED_SINGLE_QUOTE] > 0 && !types[C_ESCAPED_DOUBLE_QUOTE]) {
+        node.quote = L_DOUBLE_QUOTE;
+    }
+
+    if (node.quote === L_DOUBLE_QUOTE && types[C_ESCAPED_DOUBLE_QUOTE] > 0 && !types[C_ESCAPED_SINGLE_QUOTE]) {
+        node.quote = L_SINGLE_QUOTE;
+    }
+
+    ast.nodes = ast.nodes.reduce(function (newAst, child) {
+        if (child.type === C_ESCAPED_DOUBLE_QUOTE && node.quote === L_SINGLE_QUOTE) {
+            return [].concat(newAst, [T_DOUBLE_QUOTE]);
+        }
+        if (child.type === C_ESCAPED_SINGLE_QUOTE && node.quote === L_DOUBLE_QUOTE) {
+            return [].concat(newAst, [T_SINGLE_QUOTE]);
+        }
+        return [].concat(newAst, [child]);
+    }, []);
+}
+
+function normalize(value, preferredQuote) {
+    if (!value || !value.length) {
+        return value;
+    }
+    return valueParser(value).walk(function (child) {
+        if (child.type !== C_STRING) {
+            return;
+        }
+        var ast = parse(child.value);
+        if (ast.quotes) {
+            changeWrappingQuotes(child, ast);
+        } else if (preferredQuote === C_SINGLE) {
+            child.quote = L_SINGLE_QUOTE;
+        } else {
+            child.quote = L_DOUBLE_QUOTE;
+        }
+        child.value = stringify(ast);
+    }).toString();
+}
+
+exports.default = postcss.plugin('cssnano-normalize-string', function (opts) {
+    var _preferredQuote$opts = _extends({
+        preferredQuote: 'double'
+    }, opts),
+        preferredQuote = _preferredQuote$opts.preferredQuote;
+
+    return function (css) {
+        css.walk(function (node) {
+            if (node.type === 'rule') {
+                node.selector = normalize(node.selector, preferredQuote);
+            }
+            if (node.type === 'decl') {
+                node.value = normalize(node.value, preferredQuote);
+            }
+            if (node.type === 'atrule') {
+                node.params = normalize(node.params, preferredQuote);
+            }
+        });
+    };
+});
+module.exports = exports['default'];

package/dist/lib/normalizeUnicode.js

@@ -0,0 +1,67 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _postcss = require('postcss');
+
+var _postcss2 = _interopRequireDefault(_postcss);
+
+var _postcssValueParser = require('postcss-value-parser');
+
+var _postcssValueParser2 = _interopRequireDefault(_postcssValueParser);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function unicode(range) {
+    var values = range.slice(2).split('-');
+    if (values.length < 2) {
+        return range;
+    }
+    var left = values[0].split('');
+    var right = values[1].split('');
+
+    if (left.length !== right.length) {
+        return range;
+    }
+
+    var questionCounter = 0;
+
+    var merged = left.reduce(function (group, value, index) {
+        if (group === false) {
+            return false;
+        }
+        if (value === right[index] && !questionCounter) {
+            return group + value;
+        }
+        if (value === '0' && right[index] === 'f') {
+            questionCounter++;
+            return group + '?';
+        }
+        return false;
+    }, 'u+');
+
+    /*
+     * The maximum number of wildcard characters (?) for ranges is 5.
+     */
+
+    if (merged && questionCounter < 6) {
+        return merged;
+    }
+
+    return range;
+}
+
+exports.default = _postcss2.default.plugin('cssnano-normalize-unicode', function () {
+    return function (css) {
+        css.walkDecls(/^unicode-range$/i, function (node) {
+            node.prop = 'unicode-range';
+            node.value = (0, _postcssValueParser2.default)(node.value).walk(function (child) {
+                if (child.type === 'word') {
+                    child.value = unicode(child.value.toLowerCase());
+                }
+                return false;
+            }).toString();
+        });
+    };
+});
+module.exports = exports['default'];

package/dist/lib/reduceDisplayValues.js

@@ -24,7 +24,7 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
  * Specification: https://drafts.csswg.org/css-display/#the-display-properties
  */
 
-var mappings = [['block', ['block', 'flow']], ['flow-root', ['block', 'flow-root']], ['inline', ['inline', 'flow']], ['inline-block', ['inline', 'flow-root']], ['run-in', ['run-in', 'flow']], ['list-item', ['list-item', 'block', 'flow']], ['inline list-item', ['list-item', 'inline', 'flow']], ['flex', ['block', 'flex']], ['inline-flex', ['inline', 'flex']], ['grid', ['block', 'grid']], ['inline-grid', ['inline', 'grid']], ['ruby', ['inline', 'ruby']], ['table', ['block', 'table']], ['inline-table', ['inline', 'table']], ['table-cell', ['table-cell', 'flow']], ['table-caption', ['table-caption', 'flow']], ['ruby-base', ['ruby-base', 'flow']], ['ruby-text', ['ruby-text', 'flow']]];
+var mappings = [['block', ['block', 'flow']], ['flow-root', ['block', 'flow-root']], ['inline', ['inline', 'flow']], ['inline-block', ['inline', 'flow-root']], ['run-in', ['run-in', 'flow']], ['list-item', ['list-item', 'block', 'flow']], ['inline-list-item', ['list-item', 'inline', 'flow']], ['flex', ['block', 'flex']], ['inline-flex', ['inline', 'flex']], ['grid', ['block', 'grid']], ['inline-grid', ['inline', 'grid']], ['ruby', ['inline', 'ruby']], ['table', ['block', 'table']], ['inline-table', ['inline', 'table']], ['table-cell', ['table-cell', 'flow']], ['table-caption', ['table-caption', 'flow']], ['ruby-base', ['ruby-base', 'flow']], ['ruby-text', ['ruby-text', 'flow']]];
 
 var getMatch = (0, _getMatch2.default)(mappings);
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cssnano",
-  "version": "3.8.1",
+  "version": "3.10.0",
   "description": "A modular minifier, built on top of the PostCSS ecosystem.",
   "main": "dist/index.js",
   "scripts": {
@@ -63,6 +63,7 @@
     "babel-core": "^6.5.1",
     "babel-loader": "^6.2.4",
     "babel-plugin-add-module-exports": "^0.2.0",
+    "babel-plugin-precompile-charcodes": "^1.0.0",
     "babel-preset-es2015-loose": "^7.0.0",
     "babel-preset-stage-0": "^6.5.0",
     "coveralls": "^2.11.6",
@@ -75,10 +76,10 @@
     "eslint-plugin-babel": "^3.3.0",
     "eslint-plugin-import": "^2.0.1",
     "gh-pages": "^0.11.0",
-    "hook-std": "^0.2.0",
     "json-loader": "^0.5.4",
     "ncp": "^2.0.0",
-    "nyc": "^8.0.0",
+    "nyc": "^10.0.0",
+    "postcss-font-magician": "^1.5.0",
     "webpack": "^1.12.13",
     "webpack-bundle-size-analyzer": "^2.0.2"
   },

package/dist/lib/warnOnce.js

@@ -1,16 +0,0 @@
-'use strict';
-
-exports.__esModule = true;
-exports.default = warnOnce;
-var messages = {};
-
-function warnOnce(message) {
-    if (messages[message]) {
-        return;
-    }
-    messages[message] = true;
-    if (typeof console !== 'undefined' && console.warn) {
-        console.warn(message);
-    }
-}
-module.exports = exports['default'];