tailwindcss 0.0.0-insiders.ea139f2 → 0.0.0-insiders.ea4e1cd

package/lib/util/normalizeScreens.js

@@ -1,14 +1,61 @@
-"use strict";
+/**
+ * @typedef {object} ScreenValue
+ * @property {number|undefined} min
+ * @property {number|undefined} max
+ * @property {string|undefined} raw
+ */ /**
+ * @typedef {object} Screen
+ * @property {string} name
+ * @property {boolean} not
+ * @property {ScreenValue[]} values
+ */ /**
+ * A function that normalizes the various forms that the screens object can be
+ * provided in.
+ *
+ * Input(s):
+ *   - ['100px', '200px'] // Raw strings
+ *   - { sm: '100px', md: '200px' } // Object with string values
+ *   - { sm: { min: '100px' }, md: { max: '100px' } } // Object with object values
+ *   - { sm: [{ min: '100px' }, { max: '200px' }] } // Object with object array (multiple values)
+ *
+ * Output(s):
+ *   - [{ name: 'sm', values: [{ min: '100px', max: '200px' }] }] // List of objects, that contains multiple values
+ *
+ * @returns {Screen[]}
+ */ "use strict";
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-exports.normalizeScreens = normalizeScreens;
-function normalizeScreens(screens) {
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    normalizeScreens: function() {
+        return normalizeScreens;
+    },
+    isScreenSortable: function() {
+        return isScreenSortable;
+    },
+    compareScreens: function() {
+        return compareScreens;
+    },
+    toScreen: function() {
+        return toScreen;
+    }
+});
+function normalizeScreens(screens, root = true) {
     if (Array.isArray(screens)) {
         return screens.map((screen)=>{
-            if (typeof screen === 'string') {
+            if (root && Array.isArray(screen)) {
+                throw new Error("The tuple syntax is not supported for `screens`.");
+            }
+            if (typeof screen === "string") {
                 return {
                     name: screen.toString(),
+                    not: false,
                     values: [
                         {
                             min: screen,
@@ -19,9 +66,10 @@ function normalizeScreens(screens) {
             }
             let [name, options] = screen;
             name = name.toString();
-            if (typeof options === 'string') {
+            if (typeof options === "string") {
                 return {
                     name,
+                    not: false,
                     values: [
                         {
                             min: options,
@@ -33,23 +81,95 @@ function normalizeScreens(screens) {
             if (Array.isArray(options)) {
                 return {
                     name,
-                    values: options.map((option)=>resolveValue(option)
-                    )
+                    not: false,
+                    values: options.map((option)=>resolveValue(option))
                 };
             }
             return {
                 name,
+                not: false,
                 values: [
                     resolveValue(options)
                 ]
             };
         });
     }
-    return normalizeScreens(Object.entries(screens !== null && screens !== void 0 ? screens : {
-    }));
+    return normalizeScreens(Object.entries(screens !== null && screens !== void 0 ? screens : {}), false);
+}
+function isScreenSortable(screen) {
+    if (screen.values.length !== 1) {
+        return {
+            result: false,
+            reason: "multiple-values"
+        };
+    } else if (screen.values[0].raw !== undefined) {
+        return {
+            result: false,
+            reason: "raw-values"
+        };
+    } else if (screen.values[0].min !== undefined && screen.values[0].max !== undefined) {
+        return {
+            result: false,
+            reason: "min-and-max"
+        };
+    }
+    return {
+        result: true,
+        reason: null
+    };
+}
+function compareScreens(type, a, z) {
+    let aScreen = toScreen(a, type);
+    let zScreen = toScreen(z, type);
+    let aSorting = isScreenSortable(aScreen);
+    let bSorting = isScreenSortable(zScreen);
+    // These cases should never happen and indicate a bug in Tailwind CSS itself
+    if (aSorting.reason === "multiple-values" || bSorting.reason === "multiple-values") {
+        throw new Error("Attempted to sort a screen with multiple values. This should never happen. Please open a bug report.");
+    } else if (aSorting.reason === "raw-values" || bSorting.reason === "raw-values") {
+        throw new Error("Attempted to sort a screen with raw values. This should never happen. Please open a bug report.");
+    } else if (aSorting.reason === "min-and-max" || bSorting.reason === "min-and-max") {
+        throw new Error("Attempted to sort a screen with both min and max values. This should never happen. Please open a bug report.");
+    }
+    // Let the sorting begin
+    let { min: aMin , max: aMax  } = aScreen.values[0];
+    let { min: zMin , max: zMax  } = zScreen.values[0];
+    // Negating screens flip their behavior. Basically `not min-width` is `max-width`
+    if (a.not) [aMin, aMax] = [
+        aMax,
+        aMin
+    ];
+    if (z.not) [zMin, zMax] = [
+        zMax,
+        zMin
+    ];
+    aMin = aMin === undefined ? aMin : parseFloat(aMin);
+    aMax = aMax === undefined ? aMax : parseFloat(aMax);
+    zMin = zMin === undefined ? zMin : parseFloat(zMin);
+    zMax = zMax === undefined ? zMax : parseFloat(zMax);
+    let [aValue, zValue] = type === "min" ? [
+        aMin,
+        zMin
+    ] : [
+        zMax,
+        aMax
+    ];
+    return aValue - zValue;
+}
+function toScreen(value, type) {
+    if (typeof value === "object") {
+        return value;
+    }
+    return {
+        name: "arbitrary-screen",
+        values: [
+            {
+                [type]: value
+            }
+        ]
+    };
 }
-function resolveValue({ 'min-width': _minWidth , min =_minWidth , max , raw  } = {
-}) {
+function resolveValue({ "min-width": _minWidth , min =_minWidth , max , raw  } = {}) {
     return {
         min,
         max,

package/lib/util/parseAnimationValue.js

@@ -2,38 +2,43 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-exports.default = parseAnimationValue;
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return parseAnimationValue;
+    }
+});
 const DIRECTIONS = new Set([
-    'normal',
-    'reverse',
-    'alternate',
-    'alternate-reverse'
+    "normal",
+    "reverse",
+    "alternate",
+    "alternate-reverse"
 ]);
 const PLAY_STATES = new Set([
-    'running',
-    'paused'
+    "running",
+    "paused"
 ]);
 const FILL_MODES = new Set([
-    'none',
-    'forwards',
-    'backwards',
-    'both'
+    "none",
+    "forwards",
+    "backwards",
+    "both"
 ]);
 const ITERATION_COUNTS = new Set([
-    'infinite'
+    "infinite"
 ]);
 const TIMINGS = new Set([
-    'linear',
-    'ease',
-    'ease-in',
-    'ease-out',
-    'ease-in-out',
-    'step-start',
-    'step-end', 
+    "linear",
+    "ease",
+    "ease-in",
+    "ease-out",
+    "ease-in-out",
+    "step-start",
+    "step-end"
 ]);
 const TIMING_FNS = [
-    'cubic-bezier',
-    'steps'
+    "cubic-bezier",
+    "steps"
 ];
 const COMMA = /\,(?![^(]*\))/g // Comma separator that is not located between brackets. E.g.: `cubiz-bezier(a, b, c)` these don't count.
 ;
@@ -51,34 +56,33 @@ function parseAnimationValue(input) {
         let parts = value.split(SPACE);
         let seen = new Set();
         for (let part of parts){
-            if (!seen.has('DIRECTIONS') && DIRECTIONS.has(part)) {
+            if (!seen.has("DIRECTIONS") && DIRECTIONS.has(part)) {
                 result.direction = part;
-                seen.add('DIRECTIONS');
-            } else if (!seen.has('PLAY_STATES') && PLAY_STATES.has(part)) {
+                seen.add("DIRECTIONS");
+            } else if (!seen.has("PLAY_STATES") && PLAY_STATES.has(part)) {
                 result.playState = part;
-                seen.add('PLAY_STATES');
-            } else if (!seen.has('FILL_MODES') && FILL_MODES.has(part)) {
+                seen.add("PLAY_STATES");
+            } else if (!seen.has("FILL_MODES") && FILL_MODES.has(part)) {
                 result.fillMode = part;
-                seen.add('FILL_MODES');
-            } else if (!seen.has('ITERATION_COUNTS') && (ITERATION_COUNTS.has(part) || DIGIT.test(part))) {
+                seen.add("FILL_MODES");
+            } else if (!seen.has("ITERATION_COUNTS") && (ITERATION_COUNTS.has(part) || DIGIT.test(part))) {
                 result.iterationCount = part;
-                seen.add('ITERATION_COUNTS');
-            } else if (!seen.has('TIMING_FUNCTION') && TIMINGS.has(part)) {
+                seen.add("ITERATION_COUNTS");
+            } else if (!seen.has("TIMING_FUNCTION") && TIMINGS.has(part)) {
                 result.timingFunction = part;
-                seen.add('TIMING_FUNCTION');
-            } else if (!seen.has('TIMING_FUNCTION') && TIMING_FNS.some((f)=>part.startsWith(`${f}(`)
-            )) {
+                seen.add("TIMING_FUNCTION");
+            } else if (!seen.has("TIMING_FUNCTION") && TIMING_FNS.some((f)=>part.startsWith(`${f}(`))) {
                 result.timingFunction = part;
-                seen.add('TIMING_FUNCTION');
-            } else if (!seen.has('DURATION') && TIME.test(part)) {
+                seen.add("TIMING_FUNCTION");
+            } else if (!seen.has("DURATION") && TIME.test(part)) {
                 result.duration = part;
-                seen.add('DURATION');
-            } else if (!seen.has('DELAY') && TIME.test(part)) {
+                seen.add("DURATION");
+            } else if (!seen.has("DELAY") && TIME.test(part)) {
                 result.delay = part;
-                seen.add('DELAY');
-            } else if (!seen.has('NAME')) {
+                seen.add("DELAY");
+            } else if (!seen.has("NAME")) {
                 result.name = part;
-                seen.add('NAME');
+                seen.add("NAME");
             } else {
                 if (!result.unknown) result.unknown = [];
                 result.unknown.push(part);

package/lib/util/parseBoxShadowValue.js

@@ -2,22 +2,33 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-exports.parseBoxShadowValue = parseBoxShadowValue;
-exports.formatBoxShadowValue = formatBoxShadowValue;
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    parseBoxShadowValue: function() {
+        return parseBoxShadowValue;
+    },
+    formatBoxShadowValue: function() {
+        return formatBoxShadowValue;
+    }
+});
+const _splitAtTopLevelOnly = require("./splitAtTopLevelOnly");
 let KEYWORDS = new Set([
-    'inset',
-    'inherit',
-    'initial',
-    'revert',
-    'unset'
+    "inset",
+    "inherit",
+    "initial",
+    "revert",
+    "unset"
 ]);
-let COMMA = /\,(?![^(]*\))/g // Comma separator that is not located between brackets. E.g.: `cubiz-bezier(a, b, c)` these don't count.
-;
 let SPACE = /\ +(?![^(]*\))/g // Similar to the one above, but with spaces instead.
 ;
-let LENGTH = /^-?(\d+)(.*?)$/g;
+let LENGTH = /^-?(\d+|\.\d+)(.*?)$/g;
 function parseBoxShadowValue(input) {
-    let shadows = input.split(COMMA);
+    let shadows = (0, _splitAtTopLevelOnly.splitAtTopLevelOnly)(input, ",");
     return shadows.map((shadow)=>{
         let value = shadow.trim();
         let result = {
@@ -29,22 +40,22 @@ function parseBoxShadowValue(input) {
             // Reset index, since the regex is stateful.
             LENGTH.lastIndex = 0;
             // Keyword
-            if (!seen.has('KEYWORD') && KEYWORDS.has(part)) {
+            if (!seen.has("KEYWORD") && KEYWORDS.has(part)) {
                 result.keyword = part;
-                seen.add('KEYWORD');
+                seen.add("KEYWORD");
             } else if (LENGTH.test(part)) {
-                if (!seen.has('X')) {
+                if (!seen.has("X")) {
                     result.x = part;
-                    seen.add('X');
-                } else if (!seen.has('Y')) {
+                    seen.add("X");
+                } else if (!seen.has("Y")) {
                     result.y = part;
-                    seen.add('Y');
-                } else if (!seen.has('BLUR')) {
+                    seen.add("Y");
+                } else if (!seen.has("BLUR")) {
                     result.blur = part;
-                    seen.add('BLUR');
-                } else if (!seen.has('SPREAD')) {
+                    seen.add("BLUR");
+                } else if (!seen.has("SPREAD")) {
                     result.spread = part;
-                    seen.add('SPREAD');
+                    seen.add("SPREAD");
                 }
             } else {
                 if (!result.color) {
@@ -72,6 +83,6 @@ function formatBoxShadowValue(shadows) {
             shadow.blur,
             shadow.spread,
             shadow.color
-        ].filter(Boolean).join(' ');
-    }).join(', ');
+        ].filter(Boolean).join(" ");
+    }).join(", ");
 }

package/lib/util/parseDependency.js

@@ -1,63 +1,47 @@
-"use strict";
+// @ts-check
+/**
+ * @typedef {{type: 'dependency', file: string} | {type: 'dir-dependency', dir: string, glob: string}} Dependency
+ */ /**
+ *
+ * @param {import('../lib/content.js').ContentPath} contentPath
+ * @returns {Dependency[]}
+ */ "use strict";
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-exports.default = parseDependency;
-var _isGlob = _interopRequireDefault(require("is-glob"));
-var _globParent = _interopRequireDefault(require("glob-parent"));
-var _path = _interopRequireDefault(require("path"));
-function _interopRequireDefault(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-// Based on `glob-base`
-// https://github.com/micromatch/glob-base/blob/master/index.js
-function parseGlob(pattern) {
-    let glob = pattern;
-    let base = (0, _globParent).default(pattern);
-    if (base !== '.') {
-        glob = pattern.substr(base.length);
-        if (glob.charAt(0) === '/') {
-            glob = glob.substr(1);
-        }
-    }
-    if (glob.substr(0, 2) === './') {
-        glob = glob.substr(2);
-    }
-    if (glob.charAt(0) === '/') {
-        glob = glob.substr(1);
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return parseDependency;
     }
-    return {
-        base,
-        glob
-    };
-}
-function parseDependency(normalizedFileOrGlob) {
-    if (normalizedFileOrGlob.startsWith('!')) {
-        return null;
+});
+function parseDependency(contentPath) {
+    if (contentPath.ignore) {
+        return [];
     }
-    let message;
-    if ((0, _isGlob).default(normalizedFileOrGlob)) {
-        let { base , glob  } = parseGlob(normalizedFileOrGlob);
-        message = {
-            type: 'dir-dependency',
-            dir: _path.default.resolve(base),
-            glob
-        };
-    } else {
-        message = {
-            type: 'dependency',
-            file: _path.default.resolve(normalizedFileOrGlob)
-        };
+    if (!contentPath.glob) {
+        return [
+            {
+                type: "dependency",
+                file: contentPath.base
+            }
+        ];
     }
-    // rollup-plugin-postcss does not support dir-dependency messages
-    // but directories can be watched in the same way as files
-    if (message.type === 'dir-dependency' && process.env.ROLLUP_WATCH === 'true') {
-        message = {
-            type: 'dependency',
-            file: message.dir
-        };
+    if (process.env.ROLLUP_WATCH === "true") {
+        // rollup-plugin-postcss does not support dir-dependency messages
+        // but directories can be watched in the same way as files
+        return [
+            {
+                type: "dependency",
+                file: contentPath.base
+            }
+        ];
     }
-    return message;
+    return [
+        {
+            type: "dir-dependency",
+            dir: contentPath.base,
+            glob: contentPath.glob
+        }
+    ];
 }

package/lib/util/parseGlob.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "parseGlob", {
+    enumerable: true,
+    get: function() {
+        return parseGlob;
+    }
+});
+const _globparent = /*#__PURE__*/ _interop_require_default(require("glob-parent"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function parseGlob(pattern) {
+    let glob = pattern;
+    let base = (0, _globparent.default)(pattern);
+    if (base !== ".") {
+        glob = pattern.substr(base.length);
+        if (glob.charAt(0) === "/") {
+            glob = glob.substr(1);
+        }
+    }
+    if (glob.substr(0, 2) === "./") {
+        glob = glob.substr(2);
+    }
+    if (glob.charAt(0) === "/") {
+        glob = glob.substr(1);
+    }
+    return {
+        base,
+        glob
+    };
+}

package/lib/util/parseObjectStyles.js

@@ -2,11 +2,16 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-exports.default = parseObjectStyles;
-var _postcss = _interopRequireDefault(require("postcss"));
-var _postcssNested = _interopRequireDefault(require("postcss-nested"));
-var _postcssJs = _interopRequireDefault(require("postcss-js"));
-function _interopRequireDefault(obj) {
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return parseObjectStyles;
+    }
+});
+const _postcss = /*#__PURE__*/ _interop_require_default(require("postcss"));
+const _postcssnested = /*#__PURE__*/ _interop_require_default(require("postcss-nested"));
+const _postcssjs = /*#__PURE__*/ _interop_require_default(require("postcss-js"));
+function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
@@ -18,14 +23,14 @@ function parseObjectStyles(styles) {
         ]);
     }
     return styles.flatMap((style)=>{
-        return (0, _postcss).default([
-            (0, _postcssNested).default({
+        return (0, _postcss.default)([
+            (0, _postcssnested.default)({
                 bubble: [
-                    'screen'
+                    "screen"
                 ]
-            }), 
+            })
         ]).process(style, {
-            parser: _postcssJs.default
+            parser: _postcssjs.default
         }).root.nodes;
     });
 }