tailwindcss 0.0.0-insiders.fda68f7 → 0.0.0-oxide.6bf5e56

package/lib/util/nameClass.js

@@ -1,32 +1,43 @@
 "use strict";
-
 Object.defineProperty(exports, "__esModule", {
-  value: true
+    value: true
 });
-exports.default = nameClass;
-
-var _escapeClassName = _interopRequireDefault(require("./escapeClassName"));
-
-var _escapeCommas = _interopRequireDefault(require("./escapeCommas"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    asClass: ()=>asClass,
+    default: ()=>nameClass,
+    formatClass: ()=>formatClass
+});
+const _escapeClassName = /*#__PURE__*/ _interopRequireDefault(require("./escapeClassName"));
+const _escapeCommas = /*#__PURE__*/ _interopRequireDefault(require("./escapeCommas"));
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
 function asClass(name) {
-  return (0, _escapeCommas.default)(`.${(0, _escapeClassName.default)(name)}`);
+    return (0, _escapeCommas.default)(`.${(0, _escapeClassName.default)(name)}`);
 }
-
 function nameClass(classPrefix, key) {
-  if (key === 'DEFAULT') {
-    return asClass(classPrefix);
-  }
-
-  if (key === '-') {
-    return asClass(`-${classPrefix}`);
-  }
-
-  if (key.startsWith('-')) {
-    return asClass(`-${classPrefix}${key}`);
-  }
-
-  return asClass(`${classPrefix}-${key}`);
-}
+    return asClass(formatClass(classPrefix, key));
+}
+function formatClass(classPrefix, key) {
+    if (key === "DEFAULT") {
+        return classPrefix;
+    }
+    if (key === "-" || key === "-DEFAULT") {
+        return `-${classPrefix}`;
+    }
+    if (key.startsWith("-")) {
+        return `-${classPrefix}${key}`;
+    }
+    if (key.startsWith("/")) {
+        return `${classPrefix}${key}`;
+    }
+    return `${classPrefix}-${key}`;
+}

package/lib/util/negateValue.js

@@ -1,20 +1,34 @@
 "use strict";
-
 Object.defineProperty(exports, "__esModule", {
-  value: true
+    value: true
 });
-exports.default = _default;
-
-function _default(value) {
-  value = `${value}`; // Flip sign of numbers
-
-  if (/^[+-]?(\d+|\d*\.\d+)(e[+-]?\d+)?(%|\w+)?$/.test(value)) {
-    return value.replace(/^[+-]?/, sign => sign === '-' ? '' : '-');
-  }
-
-  if (value.includes('var(') || value.includes('calc(')) {
-    return `calc(${value} * -1)`;
-  }
-
-  return value;
-}
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: ()=>negateValue
+});
+function negateValue(value) {
+    value = `${value}`;
+    if (value === "0") {
+        return "0";
+    }
+    // Flip sign of numbers
+    if (/^[+-]?(\d+|\d*\.\d+)(e[+-]?\d+)?(%|\w+)?$/.test(value)) {
+        return value.replace(/^[+-]?/, (sign)=>sign === "-" ? "" : "-");
+    }
+    // What functions we support negating numeric values for
+    // var() isn't inherently a numeric function but we support it anyway
+    // The trigonometric functions are omitted because you'll need to use calc(…) with them _anyway_
+    // to produce generally useful results and that will be covered already
+    let numericFunctions = [
+        "var",
+        "calc",
+        "min",
+        "max",
+        "clamp"
+    ];
+    for (const fn of numericFunctions){
+        if (value.includes(`${fn}(`)) {
+            return `calc(${value} * -1)`;
+        }
+    }
+}

package/lib/util/normalizeConfig.js

@@ -0,0 +1,281 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "normalizeConfig", {
+    enumerable: true,
+    get: ()=>normalizeConfig
+});
+const _log = /*#__PURE__*/ _interopRequireWildcard(require("./log"));
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interopRequireWildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+function normalizeConfig(config) {
+    // Quick structure validation
+    /**
+   * type FilePath = string
+   * type RawFile = { raw: string, extension?: string }
+   * type ExtractorFn = (content: string) => Array<string>
+   * type TransformerFn = (content: string) => string
+   *
+   * type Content =
+   *   | Array<FilePath | RawFile>
+   *   | {
+   *       files: Array<FilePath | RawFile>,
+   *       extract?: ExtractorFn | { [extension: string]: ExtractorFn }
+   *       transform?: TransformerFn | { [extension: string]: TransformerFn }
+   *   }
+   */ let valid = (()=>{
+        // `config.purge` should not exist anymore
+        if (config.purge) {
+            return false;
+        }
+        // `config.content` should exist
+        if (!config.content) {
+            return false;
+        }
+        // `config.content` should be an object or an array
+        if (!Array.isArray(config.content) && !(typeof config.content === "object" && config.content !== null)) {
+            return false;
+        }
+        // When `config.content` is an array, it should consist of FilePaths or RawFiles
+        if (Array.isArray(config.content)) {
+            return config.content.every((path)=>{
+                // `path` can be a string
+                if (typeof path === "string") return true;
+                // `path` can be an object { raw: string, extension?: string }
+                // `raw` must be a string
+                if (typeof (path === null || path === void 0 ? void 0 : path.raw) !== "string") return false;
+                // `extension` (if provided) should also be a string
+                if ((path === null || path === void 0 ? void 0 : path.extension) && typeof (path === null || path === void 0 ? void 0 : path.extension) !== "string") {
+                    return false;
+                }
+                return true;
+            });
+        }
+        // When `config.content` is an object
+        if (typeof config.content === "object" && config.content !== null) {
+            // Only `files`, `relative`, `extract`, and `transform` can exist in `config.content`
+            if (Object.keys(config.content).some((key)=>![
+                    "files",
+                    "relative",
+                    "extract",
+                    "transform"
+                ].includes(key))) {
+                return false;
+            }
+            // `config.content.files` should exist of FilePaths or RawFiles
+            if (Array.isArray(config.content.files)) {
+                if (!config.content.files.every((path)=>{
+                    // `path` can be a string
+                    if (typeof path === "string") return true;
+                    // `path` can be an object { raw: string, extension?: string }
+                    // `raw` must be a string
+                    if (typeof (path === null || path === void 0 ? void 0 : path.raw) !== "string") return false;
+                    // `extension` (if provided) should also be a string
+                    if ((path === null || path === void 0 ? void 0 : path.extension) && typeof (path === null || path === void 0 ? void 0 : path.extension) !== "string") {
+                        return false;
+                    }
+                    return true;
+                })) {
+                    return false;
+                }
+                // `config.content.extract` is optional, and can be a Function or a Record<String, Function>
+                if (typeof config.content.extract === "object") {
+                    for (let value of Object.values(config.content.extract)){
+                        if (typeof value !== "function") {
+                            return false;
+                        }
+                    }
+                } else if (!(config.content.extract === undefined || typeof config.content.extract === "function")) {
+                    return false;
+                }
+                // `config.content.transform` is optional, and can be a Function or a Record<String, Function>
+                if (typeof config.content.transform === "object") {
+                    for (let value1 of Object.values(config.content.transform)){
+                        if (typeof value1 !== "function") {
+                            return false;
+                        }
+                    }
+                } else if (!(config.content.transform === undefined || typeof config.content.transform === "function")) {
+                    return false;
+                }
+                // `config.content.relative` is optional and can be a boolean
+                if (typeof config.content.relative !== "boolean" && typeof config.content.relative !== "undefined") {
+                    return false;
+                }
+            }
+            return true;
+        }
+        return false;
+    })();
+    if (!valid) {
+        _log.default.warn("purge-deprecation", [
+            "The `purge`/`content` options have changed in Tailwind CSS v3.0.",
+            "Update your configuration file to eliminate this warning.",
+            "https://tailwindcss.com/docs/upgrade-guide#configure-content-sources"
+        ]);
+    }
+    // Normalize the `safelist`
+    config.safelist = (()=>{
+        var ref;
+        let { content , purge , safelist  } = config;
+        if (Array.isArray(safelist)) return safelist;
+        if (Array.isArray(content === null || content === void 0 ? void 0 : content.safelist)) return content.safelist;
+        if (Array.isArray(purge === null || purge === void 0 ? void 0 : purge.safelist)) return purge.safelist;
+        if (Array.isArray(purge === null || purge === void 0 ? void 0 : (ref = purge.options) === null || ref === void 0 ? void 0 : ref.safelist)) return purge.options.safelist;
+        return [];
+    })();
+    // Normalize the `blocklist`
+    config.blocklist = (()=>{
+        let { blocklist  } = config;
+        if (Array.isArray(blocklist)) {
+            if (blocklist.every((item)=>typeof item === "string")) {
+                return blocklist;
+            }
+            _log.default.warn("blocklist-invalid", [
+                "The `blocklist` option must be an array of strings.",
+                "https://tailwindcss.com/docs/content-configuration#discarding-classes"
+            ]);
+        }
+        return [];
+    })();
+    // Normalize prefix option
+    if (typeof config.prefix === "function") {
+        _log.default.warn("prefix-function", [
+            "As of Tailwind CSS v3.0, `prefix` cannot be a function.",
+            "Update `prefix` in your configuration to be a string to eliminate this warning.",
+            "https://tailwindcss.com/docs/upgrade-guide#prefix-cannot-be-a-function"
+        ]);
+        config.prefix = "";
+    } else {
+        var _prefix;
+        config.prefix = (_prefix = config.prefix) !== null && _prefix !== void 0 ? _prefix : "";
+    }
+    // Normalize the `content`
+    config.content = {
+        relative: (()=>{
+            var ref;
+            let { content  } = config;
+            if (content === null || content === void 0 ? void 0 : content.relative) {
+                return content.relative;
+            }
+            var ref1;
+            return (ref1 = (ref = config.future) === null || ref === void 0 ? void 0 : ref.relativeContentPathsByDefault) !== null && ref1 !== void 0 ? ref1 : false;
+        })(),
+        files: (()=>{
+            let { content , purge  } = config;
+            if (Array.isArray(purge)) return purge;
+            if (Array.isArray(purge === null || purge === void 0 ? void 0 : purge.content)) return purge.content;
+            if (Array.isArray(content)) return content;
+            if (Array.isArray(content === null || content === void 0 ? void 0 : content.content)) return content.content;
+            if (Array.isArray(content === null || content === void 0 ? void 0 : content.files)) return content.files;
+            return [];
+        })(),
+        extract: (()=>{
+            let extract = (()=>{
+                var ref, ref1, ref2, ref3, ref4, ref5, ref6, ref7, ref8, ref9;
+                if ((ref = config.purge) === null || ref === void 0 ? void 0 : ref.extract) return config.purge.extract;
+                if ((ref1 = config.content) === null || ref1 === void 0 ? void 0 : ref1.extract) return config.content.extract;
+                if ((ref2 = config.purge) === null || ref2 === void 0 ? void 0 : (ref3 = ref2.extract) === null || ref3 === void 0 ? void 0 : ref3.DEFAULT) return config.purge.extract.DEFAULT;
+                if ((ref4 = config.content) === null || ref4 === void 0 ? void 0 : (ref5 = ref4.extract) === null || ref5 === void 0 ? void 0 : ref5.DEFAULT) return config.content.extract.DEFAULT;
+                if ((ref6 = config.purge) === null || ref6 === void 0 ? void 0 : (ref7 = ref6.options) === null || ref7 === void 0 ? void 0 : ref7.extractors) return config.purge.options.extractors;
+                if ((ref8 = config.content) === null || ref8 === void 0 ? void 0 : (ref9 = ref8.options) === null || ref9 === void 0 ? void 0 : ref9.extractors) return config.content.options.extractors;
+                return {};
+            })();
+            let extractors = {};
+            let defaultExtractor = (()=>{
+                var ref, ref1, ref2, ref3;
+                if ((ref = config.purge) === null || ref === void 0 ? void 0 : (ref1 = ref.options) === null || ref1 === void 0 ? void 0 : ref1.defaultExtractor) {
+                    return config.purge.options.defaultExtractor;
+                }
+                if ((ref2 = config.content) === null || ref2 === void 0 ? void 0 : (ref3 = ref2.options) === null || ref3 === void 0 ? void 0 : ref3.defaultExtractor) {
+                    return config.content.options.defaultExtractor;
+                }
+                return undefined;
+            })();
+            if (defaultExtractor !== undefined) {
+                extractors.DEFAULT = defaultExtractor;
+            }
+            // Functions
+            if (typeof extract === "function") {
+                extractors.DEFAULT = extract;
+            } else if (Array.isArray(extract)) {
+                for (let { extensions , extractor  } of extract !== null && extract !== void 0 ? extract : []){
+                    for (let extension of extensions){
+                        extractors[extension] = extractor;
+                    }
+                }
+            } else if (typeof extract === "object" && extract !== null) {
+                Object.assign(extractors, extract);
+            }
+            return extractors;
+        })(),
+        transform: (()=>{
+            let transform = (()=>{
+                var ref, ref1, ref2, ref3, ref4, ref5;
+                if ((ref = config.purge) === null || ref === void 0 ? void 0 : ref.transform) return config.purge.transform;
+                if ((ref1 = config.content) === null || ref1 === void 0 ? void 0 : ref1.transform) return config.content.transform;
+                if ((ref2 = config.purge) === null || ref2 === void 0 ? void 0 : (ref3 = ref2.transform) === null || ref3 === void 0 ? void 0 : ref3.DEFAULT) return config.purge.transform.DEFAULT;
+                if ((ref4 = config.content) === null || ref4 === void 0 ? void 0 : (ref5 = ref4.transform) === null || ref5 === void 0 ? void 0 : ref5.DEFAULT) return config.content.transform.DEFAULT;
+                return {};
+            })();
+            let transformers = {};
+            if (typeof transform === "function") {
+                transformers.DEFAULT = transform;
+            }
+            if (typeof transform === "object" && transform !== null) {
+                Object.assign(transformers, transform);
+            }
+            return transformers;
+        })()
+    };
+    // Validate globs to prevent bogus globs.
+    // E.g.: `./src/*.{html}` is invalid, the `{html}` should just be `html`
+    for (let file of config.content.files){
+        if (typeof file === "string" && /{([^,]*?)}/g.test(file)) {
+            _log.default.warn("invalid-glob-braces", [
+                `The glob pattern ${(0, _log.dim)(file)} in your Tailwind CSS configuration is invalid.`,
+                `Update it to ${(0, _log.dim)(file.replace(/{([^,]*?)}/g, "$1"))} to silence this warning.`
+            ]);
+            break;
+        }
+    }
+    return config;
+}

package/lib/util/normalizeScreens.js

@@ -0,0 +1,170 @@
+/**
+ * @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: ()=>normalizeScreens,
+    isScreenSortable: ()=>isScreenSortable,
+    compareScreens: ()=>compareScreens,
+    toScreen: ()=>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) {
+    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  } = {}) {
+    return {
+        min,
+        max,
+        raw
+    };
+}