tailwindcss 0.0.0-oxide-insiders.a7fe2fe → 0.0.0-oxide-insiders.7f555c4

package/lib/util/normalizeScreens.js

@@ -1,33 +1,153 @@
-"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
+});
+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 (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,
+                            max: undefined
+                        }
+                    ]
+                };
+            }
+            let [name, options] = screen;
+            name = name.toString();
+            if (typeof options === "string") {
+                return {
+                    name,
+                    not: false,
+                    values: [
+                        {
+                            min: options,
+                            max: undefined
+                        }
+                    ]
+                };
+            }
+            if (Array.isArray(options)) {
+                return {
+                    name,
+                    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 : {}), false);
+}
 function isScreenSortable(screen) {
-    return 1 !== screen.values.length ? {
-        result: !1,
-        reason: "multiple-values"
-    } : void 0 !== screen.values[0].raw ? {
-        result: !1,
-        reason: "raw-values"
-    } : void 0 !== screen.values[0].min && void 0 !== screen.values[0].max ? {
-        result: !1,
-        reason: "min-and-max"
-    } : {
-        result: !0,
+    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), zScreen = toScreen(z, type), aSorting = isScreenSortable(aScreen), bSorting = isScreenSortable(zScreen);
-    if ("multiple-values" === aSorting.reason || "multiple-values" === bSorting.reason) throw Error("Attempted to sort a screen with multiple values. This should never happen. Please open a bug report.");
-    if ("raw-values" === aSorting.reason || "raw-values" === bSorting.reason) throw Error("Attempted to sort a screen with raw values. This should never happen. Please open a bug report.");
-    if ("min-and-max" === aSorting.reason || "min-and-max" === bSorting.reason) throw Error("Attempted to sort a screen with both min and max values. This should never happen. Please open a bug report.");
-    let { min: aMin , max: aMax  } = aScreen.values[0], { min: zMin , max: zMax  } = zScreen.values[0];
-    a.not && ([aMin, aMax] = [
+    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
-    ]), z.not && ([zMin, zMax] = [
+    ];
+    if (z.not) [zMin, zMax] = [
         zMax,
         zMin
-    ]), aMin = void 0 === aMin ? aMin : parseFloat(aMin), aMax = void 0 === aMax ? aMax : parseFloat(aMax), zMin = void 0 === zMin ? zMin : parseFloat(zMin), zMax = void 0 === zMax ? zMax : parseFloat(zMax);
-    let [aValue, zValue] = "min" === type ? [
+    ];
+    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
     ] : [
@@ -37,7 +157,10 @@ function compareScreens(type, a, z) {
     return aValue - zValue;
 }
 function toScreen(value, type) {
-    return "object" == typeof value ? value : {
+    if (typeof value === "object") {
+        return value;
+    }
+    return {
         name: "arbitrary-screen",
         values: [
             {
@@ -53,51 +176,3 @@ function resolveValue({ "min-width": _minWidth , min =_minWidth , max , raw  } =
         raw
     };
 }
-Object.defineProperty(exports, "__esModule", {
-    value: !0
-}), function(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: !0,
-        get: all[name]
-    });
-}(exports, {
-    normalizeScreens: ()=>function normalizeScreens(screens, root = !0) {
-            return Array.isArray(screens) ? screens.map((screen)=>{
-                if (root && Array.isArray(screen)) throw Error("The tuple syntax is not supported for `screens`.");
-                if ("string" == typeof screen) return {
-                    name: screen.toString(),
-                    not: !1,
-                    values: [
-                        {
-                            min: screen,
-                            max: void 0
-                        }
-                    ]
-                };
-                let [name, options] = screen;
-                return (name = name.toString(), "string" == typeof options) ? {
-                    name,
-                    not: !1,
-                    values: [
-                        {
-                            min: options,
-                            max: void 0
-                        }
-                    ]
-                } : Array.isArray(options) ? {
-                    name,
-                    not: !1,
-                    values: options.map((option)=>resolveValue(option))
-                } : {
-                    name,
-                    not: !1,
-                    values: [
-                        resolveValue(options)
-                    ]
-                };
-            }) : normalizeScreens(Object.entries(null != screens ? screens : {}), !1);
-        },
-    isScreenSortable: ()=>isScreenSortable,
-    compareScreens: ()=>compareScreens,
-    toScreen: ()=>toScreen
-});

package/lib/util/parseAnimationValue.js

@@ -1,26 +1,33 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", {
-    value: !0
-}), Object.defineProperty(exports, "default", {
-    enumerable: !0,
-    get: ()=>parseAnimationValue
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return parseAnimationValue;
+    }
 });
 const DIRECTIONS = new Set([
     "normal",
     "reverse",
     "alternate",
     "alternate-reverse"
-]), PLAY_STATES = new Set([
+]);
+const PLAY_STATES = new Set([
     "running",
     "paused"
-]), FILL_MODES = new Set([
+]);
+const FILL_MODES = new Set([
     "none",
     "forwards",
     "backwards",
     "both"
-]), ITERATION_COUNTS = new Set([
+]);
+const ITERATION_COUNTS = new Set([
     "infinite"
-]), TIMINGS = new Set([
+]);
+const TIMINGS = new Set([
     "linear",
     "ease",
     "ease-in",
@@ -28,16 +35,59 @@ const DIRECTIONS = new Set([
     "ease-in-out",
     "step-start",
     "step-end"
-]), TIMING_FNS = [
+]);
+const TIMING_FNS = [
     "cubic-bezier",
     "steps"
-], COMMA = /\,(?![^(]*\))/g, SPACE = /\ +(?![^(]*\))/g, TIME = /^(-?[\d.]+m?s)$/, DIGIT = /^(\d+)$/;
+];
+const COMMA = /\,(?![^(]*\))/g // Comma separator that is not located between brackets. E.g.: `cubiz-bezier(a, b, c)` these don't count.
+;
+const SPACE = /\ +(?![^(]*\))/g // Similar to the one above, but with spaces instead.
+;
+const TIME = /^(-?[\d.]+m?s)$/;
+const DIGIT = /^(\d+)$/;
 function parseAnimationValue(input) {
-    return input.split(COMMA).map((animation)=>{
-        let value = animation.trim(), result = {
+    let animations = input.split(COMMA);
+    return animations.map((animation)=>{
+        let value = animation.trim();
+        let result = {
             value
-        }, parts = value.split(SPACE), seen = new Set();
-        for (let part of parts)!seen.has("DIRECTIONS") && DIRECTIONS.has(part) ? (result.direction = part, seen.add("DIRECTIONS")) : !seen.has("PLAY_STATES") && PLAY_STATES.has(part) ? (result.playState = part, seen.add("PLAY_STATES")) : !seen.has("FILL_MODES") && FILL_MODES.has(part) ? (result.fillMode = part, seen.add("FILL_MODES")) : !seen.has("ITERATION_COUNTS") && (ITERATION_COUNTS.has(part) || DIGIT.test(part)) ? (result.iterationCount = part, seen.add("ITERATION_COUNTS")) : !seen.has("TIMING_FUNCTION") && TIMINGS.has(part) ? (result.timingFunction = part, seen.add("TIMING_FUNCTION")) : !seen.has("TIMING_FUNCTION") && TIMING_FNS.some((f)=>part.startsWith(`${f}(`)) ? (result.timingFunction = part, seen.add("TIMING_FUNCTION")) : !seen.has("DURATION") && TIME.test(part) ? (result.duration = part, seen.add("DURATION")) : !seen.has("DELAY") && TIME.test(part) ? (result.delay = part, seen.add("DELAY")) : seen.has("NAME") ? (result.unknown || (result.unknown = []), result.unknown.push(part)) : (result.name = part, seen.add("NAME"));
+        };
+        let parts = value.split(SPACE);
+        let seen = new Set();
+        for (let part of parts){
+            if (!seen.has("DIRECTIONS") && DIRECTIONS.has(part)) {
+                result.direction = 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)) {
+                result.fillMode = 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)) {
+                result.timingFunction = part;
+                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)) {
+                result.duration = part;
+                seen.add("DURATION");
+            } else if (!seen.has("DELAY") && TIME.test(part)) {
+                result.delay = part;
+                seen.add("DELAY");
+            } else if (!seen.has("NAME")) {
+                result.name = part;
+                seen.add("NAME");
+            } else {
+                if (!result.unknown) result.unknown = [];
+                result.unknown.push(part);
+            }
+        }
         return result;
     });
 }

package/lib/util/parseBoxShadowValue.js

@@ -1,14 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", {
-    value: !0
-}), function(target, all) {
+    value: true
+});
+function _export(target, all) {
     for(var name in all)Object.defineProperty(target, name, {
-        enumerable: !0,
+        enumerable: true,
         get: all[name]
     });
-}(exports, {
-    parseBoxShadowValue: ()=>parseBoxShadowValue,
-    formatBoxShadowValue: ()=>formatBoxShadowValue
+}
+_export(exports, {
+    parseBoxShadowValue: function() {
+        return parseBoxShadowValue;
+    },
+    formatBoxShadowValue: function() {
+        return formatBoxShadowValue;
+    }
 });
 const _splitAtTopLevelOnly = require("./splitAtTopLevelOnly");
 let KEYWORDS = new Set([
@@ -17,23 +23,66 @@ let KEYWORDS = new Set([
     "initial",
     "revert",
     "unset"
-]), SPACE = /\ +(?![^(]*\))/g, LENGTH = /^-?(\d+|\.\d+)(.*?)$/g;
+]);
+let SPACE = /\ +(?![^(]*\))/g // Similar to the one above, but with spaces instead.
+;
+let LENGTH = /^-?(\d+|\.\d+)(.*?)$/g;
 function parseBoxShadowValue(input) {
-    return (0, _splitAtTopLevelOnly.splitAtTopLevelOnly)(input, ",").map((shadow)=>{
-        let value = shadow.trim(), result = {
+    let shadows = (0, _splitAtTopLevelOnly.splitAtTopLevelOnly)(input, ",");
+    return shadows.map((shadow)=>{
+        let value = shadow.trim();
+        let result = {
             raw: value
-        }, parts = value.split(SPACE), seen = new Set();
-        for (let part of parts)LENGTH.lastIndex = 0, !seen.has("KEYWORD") && KEYWORDS.has(part) ? (result.keyword = part, seen.add("KEYWORD")) : LENGTH.test(part) ? seen.has("X") ? seen.has("Y") ? seen.has("BLUR") ? seen.has("SPREAD") || (result.spread = part, seen.add("SPREAD")) : (result.blur = part, seen.add("BLUR")) : (result.y = part, seen.add("Y")) : (result.x = part, seen.add("X")) : result.color ? (result.unknown || (result.unknown = []), result.unknown.push(part)) : result.color = part;
-        return result.valid = void 0 !== result.x && void 0 !== result.y, result;
+        };
+        let parts = value.split(SPACE);
+        let seen = new Set();
+        for (let part of parts){
+            // Reset index, since the regex is stateful.
+            LENGTH.lastIndex = 0;
+            // Keyword
+            if (!seen.has("KEYWORD") && KEYWORDS.has(part)) {
+                result.keyword = part;
+                seen.add("KEYWORD");
+            } else if (LENGTH.test(part)) {
+                if (!seen.has("X")) {
+                    result.x = part;
+                    seen.add("X");
+                } else if (!seen.has("Y")) {
+                    result.y = part;
+                    seen.add("Y");
+                } else if (!seen.has("BLUR")) {
+                    result.blur = part;
+                    seen.add("BLUR");
+                } else if (!seen.has("SPREAD")) {
+                    result.spread = part;
+                    seen.add("SPREAD");
+                }
+            } else {
+                if (!result.color) {
+                    result.color = part;
+                } else {
+                    if (!result.unknown) result.unknown = [];
+                    result.unknown.push(part);
+                }
+            }
+        }
+        // Check if valid
+        result.valid = result.x !== undefined && result.y !== undefined;
+        return result;
     });
 }
 function formatBoxShadowValue(shadows) {
-    return shadows.map((shadow)=>shadow.valid ? [
+    return shadows.map((shadow)=>{
+        if (!shadow.valid) {
+            return shadow.raw;
+        }
+        return [
             shadow.keyword,
             shadow.x,
             shadow.y,
             shadow.blur,
             shadow.spread,
             shadow.color
-        ].filter(Boolean).join(" ") : shadow.raw).join(", ");
+        ].filter(Boolean).join(" ");
+    }).join(", ");
 }

package/lib/util/parseDependency.js

@@ -1,21 +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
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return parseDependency;
+    }
+});
 function parseDependency(contentPath) {
-    return contentPath.ignore ? [] : contentPath.glob && "true" !== process.env.ROLLUP_WATCH ? [
+    if (contentPath.ignore) {
+        return [];
+    }
+    if (!contentPath.glob) {
+        return [
+            {
+                type: "dependency",
+                file: contentPath.base
+            }
+        ];
+    }
+    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 [
         {
             type: "dir-dependency",
             dir: contentPath.base,
             glob: contentPath.glob
         }
-    ] : [
-        {
-            type: "dependency",
-            file: contentPath.base
-        }
     ];
 }
-Object.defineProperty(exports, "__esModule", {
-    value: !0
-}), Object.defineProperty(exports, "default", {
-    enumerable: !0,
-    get: ()=>parseDependency
-});

package/lib/util/parseGlob.js

@@ -1,18 +1,35 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", {
-    value: !0
-}), Object.defineProperty(exports, "parseGlob", {
-    enumerable: !0,
-    get: ()=>parseGlob
+    value: true
 });
-const _globParent = function(obj) {
+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
     };
-}(require("glob-parent"));
+}
 function parseGlob(pattern) {
-    let glob = pattern, base = (0, _globParent.default)(pattern);
-    return "." !== base && "/" === (glob = pattern.substr(base.length)).charAt(0) && (glob = glob.substr(1)), "./" === glob.substr(0, 2) && (glob = glob.substr(2)), "/" === glob.charAt(0) && (glob = glob.substr(1)), {
+    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

@@ -1,25 +1,36 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", {
-    value: !0
-}), Object.defineProperty(exports, "default", {
-    enumerable: !0,
-    get: ()=>function parseObjectStyles(styles) {
-            return Array.isArray(styles) ? styles.flatMap((style)=>(0, _postcss.default)([
-                    (0, _postcssNested.default)({
-                        bubble: [
-                            "screen"
-                        ]
-                    })
-                ]).process(style, {
-                    parser: _postcssJs.default
-                }).root.nodes) : parseObjectStyles([
-                styles
-            ]);
-        }
+    value: true
 });
-const _postcss = _interopRequireDefault(require("postcss")), _postcssNested = _interopRequireDefault(require("postcss-nested")), _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
     };
 }
+function parseObjectStyles(styles) {
+    if (!Array.isArray(styles)) {
+        return parseObjectStyles([
+            styles
+        ]);
+    }
+    return styles.flatMap((style)=>{
+        return (0, _postcss.default)([
+            (0, _postcssnested.default)({
+                bubble: [
+                    "screen"
+                ]
+            })
+        ]).process(style, {
+            parser: _postcssjs.default
+        }).root.nodes;
+    });
+}