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

package/lib/util/resolveConfig.js

@@ -2,25 +2,31 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-exports.default = resolveConfig;
-var _negateValue = _interopRequireDefault(require("./negateValue"));
-var _corePluginList = _interopRequireDefault(require("../corePluginList"));
-var _configurePlugins = _interopRequireDefault(require("./configurePlugins"));
-var _defaultConfigStub = _interopRequireDefault(require("../../stubs/defaultConfig.stub"));
-var _colors = _interopRequireDefault(require("../public/colors"));
-var _defaults = require("./defaults");
-var _toPath = require("./toPath");
-var _normalizeConfig = require("./normalizeConfig");
-function _interopRequireDefault(obj) {
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return resolveConfig;
+    }
+});
+const _negateValue = /*#__PURE__*/ _interop_require_default(require("./negateValue"));
+const _corePluginList = /*#__PURE__*/ _interop_require_default(require("../corePluginList"));
+const _configurePlugins = /*#__PURE__*/ _interop_require_default(require("./configurePlugins"));
+const _colors = /*#__PURE__*/ _interop_require_default(require("../public/colors"));
+const _defaults = require("./defaults");
+const _toPath = require("./toPath");
+const _normalizeConfig = require("./normalizeConfig");
+const _isPlainObject = /*#__PURE__*/ _interop_require_default(require("./isPlainObject"));
+const _cloneDeep = require("./cloneDeep");
+const _pluginUtils = require("./pluginUtils");
+const _withAlphaVariable = require("./withAlphaVariable");
+const _toColorValue = /*#__PURE__*/ _interop_require_default(require("./toColorValue"));
+function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
 }
 function isFunction(input) {
-    return typeof input === 'function';
-}
-function isObject(input) {
-    return typeof input === 'object' && input !== null;
+    return typeof input === "function";
 }
 function mergeWith(target, ...sources) {
     let customizer = sources.pop();
@@ -28,8 +34,8 @@ function mergeWith(target, ...sources) {
         for(let k in source){
             let merged = customizer(target[k], source[k]);
             if (merged === undefined) {
-                if (isObject(target[k]) && isObject(source[k])) {
-                    target[k] = mergeWith(target[k], source[k], customizer);
+                if ((0, _isPlainObject.default)(target[k]) && (0, _isPlainObject.default)(source[k])) {
+                    target[k] = mergeWith({}, target[k], source[k], customizer);
                 } else {
                     target[k] = source[k];
                 }
@@ -44,27 +50,22 @@ const configUtils = {
     colors: _colors.default,
     negative (scale) {
         // TODO: Log that this function isn't really needed anymore?
-        return Object.keys(scale).filter((key)=>scale[key] !== '0'
-        ).reduce((negativeScale, key)=>{
-            let negativeValue = (0, _negateValue).default(scale[key]);
+        return Object.keys(scale).filter((key)=>scale[key] !== "0").reduce((negativeScale, key)=>{
+            let negativeValue = (0, _negateValue.default)(scale[key]);
             if (negativeValue !== undefined) {
                 negativeScale[`-${key}`] = negativeValue;
             }
             return negativeScale;
-        }, {
-        });
+        }, {});
     },
     breakpoints (screens) {
-        return Object.keys(screens).filter((key)=>typeof screens[key] === 'string'
-        ).reduce((breakpoints, key)=>({
+        return Object.keys(screens).filter((key)=>typeof screens[key] === "string").reduce((breakpoints, key)=>({
                 ...breakpoints,
                 [`screen-${key}`]: screens[key]
-            })
-        , {
-        });
+            }), {});
     }
 };
-function value1(valueToResolve, ...args) {
+function value(valueToResolve, ...args) {
     return isFunction(valueToResolve) ? valueToResolve(...args) : valueToResolve;
 }
 function collectExtends(items) {
@@ -86,14 +87,11 @@ function collectExtends(items) {
                 mergedValue
             ];
         });
-    }, {
-    });
+    }, {});
 }
 function mergeThemes(themes) {
     return {
-        ...themes.reduce((merged, theme)=>(0, _defaults).defaults(merged, theme)
-        , {
-        }),
+        ...themes.reduce((merged, theme)=>(0, _defaults.defaults)(merged, theme), {}),
         // In order to resolve n config objects, we combine all of their `extend` properties
         // into arrays instead of objects so they aren't overridden.
         extend: collectExtends(themes)
@@ -101,11 +99,11 @@ function mergeThemes(themes) {
 }
 function mergeExtensionCustomizer(merged, value) {
     // When we have an array of objects, we do want to merge it
-    if (Array.isArray(merged) && isObject(merged[0])) {
+    if (Array.isArray(merged) && (0, _isPlainObject.default)(merged[0])) {
         return merged.concat(value);
     }
     // When the incoming value is an array, and the existing config is an object, prepend the existing object
-    if (Array.isArray(value) && isObject(value[0]) && isObject(merged)) {
+    if (Array.isArray(value) && (0, _isPlainObject.default)(value[0]) && (0, _isPlainObject.default)(merged)) {
         return [
             merged,
             ...value
@@ -122,40 +120,68 @@ function mergeExtensions({ extend , ...theme }) {
     return mergeWith(theme, extend, (themeValue, extensions)=>{
         // The `extend` property is an array, so we need to check if it contains any functions
         if (!isFunction(themeValue) && !extensions.some(isFunction)) {
-            return mergeWith({
-            }, themeValue, ...extensions, mergeExtensionCustomizer);
+            return mergeWith({}, themeValue, ...extensions, mergeExtensionCustomizer);
         }
-        return (resolveThemePath, utils)=>mergeWith({
-            }, ...[
+        return (resolveThemePath, utils)=>mergeWith({}, ...[
                 themeValue,
                 ...extensions
-            ].map((e)=>value1(e, resolveThemePath, utils)
-            ), mergeExtensionCustomizer)
-        ;
+            ].map((e)=>value(e, resolveThemePath, utils)), mergeExtensionCustomizer);
     });
 }
+/**
+ *
+ * @param {string} key
+ * @return {Iterable<string[] & {alpha: string | undefined}>}
+ */ function* toPaths(key) {
+    let path = (0, _toPath.toPath)(key);
+    if (path.length === 0) {
+        return;
+    }
+    yield path;
+    if (Array.isArray(key)) {
+        return;
+    }
+    let pattern = /^(.*?)\s*\/\s*([^/]+)$/;
+    let matches = key.match(pattern);
+    if (matches !== null) {
+        let [, prefix, alpha] = matches;
+        let newPath = (0, _toPath.toPath)(prefix);
+        newPath.alpha = alpha;
+        yield newPath;
+    }
+}
 function resolveFunctionKeys(object) {
+    // theme('colors.red.500 / 0.5') -> ['colors', 'red', '500 / 0', '5]
     const resolvePath = (key, defaultValue)=>{
-        const path = (0, _toPath).toPath(key);
-        let index = 0;
-        let val = object;
-        while(val !== undefined && val !== null && index < path.length){
-            val = val[path[index++]];
-            val = isFunction(val) ? val(resolvePath, configUtils) : val;
+        for (const path of toPaths(key)){
+            let index = 0;
+            let val = object;
+            while(val !== undefined && val !== null && index < path.length){
+                val = val[path[index++]];
+                let shouldResolveAsFn = isFunction(val) && (path.alpha === undefined || index <= path.length - 1);
+                val = shouldResolveAsFn ? val(resolvePath, configUtils) : val;
+            }
+            if (val !== undefined) {
+                if (path.alpha !== undefined) {
+                    let normalized = (0, _pluginUtils.parseColorFormat)(val);
+                    return (0, _withAlphaVariable.withAlphaValue)(normalized, path.alpha, (0, _toColorValue.default)(normalized));
+                }
+                if ((0, _isPlainObject.default)(val)) {
+                    return (0, _cloneDeep.cloneDeep)(val);
+                }
+                return val;
+            }
         }
-        return val === undefined ? defaultValue : val;
+        return defaultValue;
     };
-    resolvePath.theme = resolvePath;
-    for(let key1 in configUtils){
-        resolvePath[key1] = configUtils[key1];
-    }
-    return Object.keys(object).reduce((resolved, key)=>{
-        return {
-            ...resolved,
-            [key]: isFunction(object[key]) ? object[key](resolvePath, configUtils) : object[key]
-        };
-    }, {
+    Object.assign(resolvePath, {
+        theme: resolvePath,
+        ...configUtils
     });
+    return Object.keys(object).reduce((resolved, key)=>{
+        resolved[key] = isFunction(object[key]) ? object[key](resolvePath, configUtils) : object[key];
+        return resolved;
+    }, {});
 }
 function extractPluginConfigs(configs) {
     let allConfigs = [];
@@ -164,8 +190,8 @@ function extractPluginConfigs(configs) {
             ...allConfigs,
             config
         ];
-        var ref1;
-        const plugins = (ref1 = config === null || config === void 0 ? void 0 : config.plugins) !== null && ref1 !== void 0 ? ref1 : [];
+        var _config_plugins;
+        const plugins = (_config_plugins = config === null || config === void 0 ? void 0 : config.plugins) !== null && _config_plugins !== void 0 ? _config_plugins : [];
         if (plugins.length === 0) {
             return;
         }
@@ -173,12 +199,11 @@ function extractPluginConfigs(configs) {
             if (plugin.__isOptionsFunction) {
                 plugin = plugin();
             }
-            var ref;
+            var _plugin_config;
             allConfigs = [
                 ...allConfigs,
                 ...extractPluginConfigs([
-                    (ref = plugin === null || plugin === void 0 ? void 0 : plugin.config) !== null && ref !== void 0 ? ref : {
-                    }
+                    (_plugin_config = plugin === null || plugin === void 0 ? void 0 : plugin.config) !== null && _plugin_config !== void 0 ? _plugin_config : {}
                 ])
             ];
         });
@@ -194,7 +219,7 @@ function resolveCorePlugins(corePluginConfigs) {
                 corePlugins: resolved
             });
         }
-        return (0, _configurePlugins).default(corePluginConfig, resolved);
+        return (0, _configurePlugins.default)(corePluginConfig, resolved);
     }, _corePluginList.default);
     return result;
 }
@@ -213,22 +238,19 @@ function resolveConfig(configs) {
     let allConfigs = [
         ...extractPluginConfigs(configs),
         {
-            prefix: '',
+            prefix: "",
             important: false,
-            separator: ':',
-            variantOrder: _defaultConfigStub.default.variantOrder
-        }, 
+            separator: ":"
+        }
     ];
-    var ref, ref2;
-    return (0, _normalizeConfig).normalizeConfig((0, _defaults).defaults({
+    var _t_theme, _c_plugins;
+    return (0, _normalizeConfig.normalizeConfig)((0, _defaults.defaults)({
         theme: resolveFunctionKeys(mergeExtensions(mergeThemes(allConfigs.map((t)=>{
-            return (ref = t === null || t === void 0 ? void 0 : t.theme) !== null && ref !== void 0 ? ref : {
-            };
+            return (_t_theme = t === null || t === void 0 ? void 0 : t.theme) !== null && _t_theme !== void 0 ? _t_theme : {};
         })))),
-        corePlugins: resolveCorePlugins(allConfigs.map((c)=>c.corePlugins
-        )),
+        corePlugins: resolveCorePlugins(allConfigs.map((c)=>c.corePlugins)),
         plugins: resolvePluginLists(configs.map((c)=>{
-            return (ref2 = c === null || c === void 0 ? void 0 : c.plugins) !== null && ref2 !== void 0 ? ref2 : [];
+            return (_c_plugins = c === null || c === void 0 ? void 0 : c.plugins) !== null && _c_plugins !== void 0 ? _c_plugins : [];
         }))
     }, ...allConfigs));
 }

package/lib/util/resolveConfigPath.js

@@ -2,22 +2,41 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-exports.default = resolveConfigPath;
-var _fs = _interopRequireDefault(require("fs"));
-var _path = _interopRequireDefault(require("path"));
-function _interopRequireDefault(obj) {
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    default: function() {
+        return resolveConfigPath;
+    },
+    resolveDefaultConfigPath: function() {
+        return resolveDefaultConfigPath;
+    }
+});
+const _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
 }
+const defaultConfigFiles = [
+    "./tailwind.config.js",
+    "./tailwind.config.cjs",
+    "./tailwind.config.mjs",
+    "./tailwind.config.ts"
+];
 function isObject(value) {
-    return typeof value === 'object' && value !== null;
+    return typeof value === "object" && value !== null;
 }
 function isEmpty(obj) {
     return Object.keys(obj).length === 0;
 }
 function isString(value) {
-    return typeof value === 'string' || value instanceof String;
+    return typeof value === "string" || value instanceof String;
 }
 function resolveConfigPath(pathOrConfig) {
     // require('tailwindcss')({ theme: ..., variants: ... })
@@ -37,16 +56,15 @@ function resolveConfigPath(pathOrConfig) {
         return _path.default.resolve(pathOrConfig);
     }
     // require('tailwindcss')
-    for (const configFile of [
-        './tailwind.config.js',
-        './tailwind.config.cjs'
-    ]){
+    return resolveDefaultConfigPath();
+}
+function resolveDefaultConfigPath() {
+    for (const configFile of defaultConfigFiles){
         try {
             const configPath = _path.default.resolve(configFile);
             _fs.default.accessSync(configPath);
             return configPath;
-        } catch (err) {
-        }
+        } catch (err) {}
     }
     return null;
 }

package/lib/util/responsive.js

@@ -2,18 +2,23 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-exports.default = responsive;
-var _postcss = _interopRequireDefault(require("postcss"));
-var _cloneNodes = _interopRequireDefault(require("./cloneNodes"));
-function _interopRequireDefault(obj) {
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return responsive;
+    }
+});
+const _postcss = /*#__PURE__*/ _interop_require_default(require("postcss"));
+const _cloneNodes = /*#__PURE__*/ _interop_require_default(require("./cloneNodes"));
+function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
 }
 function responsive(rules) {
     return _postcss.default.atRule({
-        name: 'responsive'
-    }).append((0, _cloneNodes).default(Array.isArray(rules) ? rules : [
+        name: "responsive"
+    }).append((0, _cloneNodes.default)(Array.isArray(rules) ? rules : [
         rules
     ]));
 }

package/lib/util/splitAtTopLevelOnly.js

@@ -0,0 +1,51 @@
+/**
+ * This splits a string on a top-level character.
+ *
+ * Regex doesn't support recursion (at least not the JS-flavored version).
+ * So we have to use a tiny state machine to keep track of paren placement.
+ *
+ * Expected behavior using commas:
+ * var(--a, 0 0 1px rgb(0, 0, 0)), 0 0 1px rgb(0, 0, 0)
+ *       ─┬─             ┬  ┬    ┬
+ *        x              x  x    ╰──────── Split because top-level
+ *        ╰──────────────┴──┴───────────── Ignored b/c inside >= 1 levels of parens
+ *
+ * @param {string} input
+ * @param {string} separator
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "splitAtTopLevelOnly", {
+    enumerable: true,
+    get: function() {
+        return splitAtTopLevelOnly;
+    }
+});
+function splitAtTopLevelOnly(input, separator) {
+    let stack = [];
+    let parts = [];
+    let lastPos = 0;
+    let isEscaped = false;
+    for(let idx = 0; idx < input.length; idx++){
+        let char = input[idx];
+        if (stack.length === 0 && char === separator[0] && !isEscaped) {
+            if (separator.length === 1 || input.slice(idx, idx + separator.length) === separator) {
+                parts.push(input.slice(lastPos, idx));
+                lastPos = idx + separator.length;
+            }
+        }
+        if (isEscaped) {
+            isEscaped = false;
+        } else if (char === "\\") {
+            isEscaped = true;
+        }
+        if (char === "(" || char === "[" || char === "{") {
+            stack.push(char);
+        } else if (char === ")" && stack[stack.length - 1] === "(" || char === "]" && stack[stack.length - 1] === "[" || char === "}" && stack[stack.length - 1] === "{") {
+            stack.pop();
+        }
+    }
+    parts.push(input.slice(lastPos));
+    return parts;
+}

package/lib/util/tap.js

@@ -2,7 +2,12 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-exports.tap = tap;
+Object.defineProperty(exports, "tap", {
+    enumerable: true,
+    get: function() {
+        return tap;
+    }
+});
 function tap(value, mutator) {
     mutator(value);
     return value;

package/lib/util/toColorValue.js

@@ -2,8 +2,12 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-exports.default = toColorValue;
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return toColorValue;
+    }
+});
 function toColorValue(maybeFunction) {
-    return typeof maybeFunction === 'function' ? maybeFunction({
-    }) : maybeFunction;
+    return typeof maybeFunction === "function" ? maybeFunction({}) : maybeFunction;
 }

package/lib/util/toPath.js

@@ -1,9 +1,32 @@
-"use strict";
+/**
+ * Parse a path string into an array of path segments.
+ *
+ * Square bracket notation `a[b]` may be used to "escape" dots that would otherwise be interpreted as path separators.
+ *
+ * Example:
+ * a -> ['a']
+ * a.b.c -> ['a', 'b', 'c']
+ * a[b].c -> ['a', 'b', 'c']
+ * a[b.c].e.f -> ['a', 'b.c', 'e', 'f']
+ * a[b][c][d] -> ['a', 'b', 'c', 'd']
+ *
+ * @param {string|string[]} path
+ **/ "use strict";
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-exports.toPath = toPath;
+Object.defineProperty(exports, "toPath", {
+    enumerable: true,
+    get: function() {
+        return toPath;
+    }
+});
 function toPath(path) {
     if (Array.isArray(path)) return path;
-    return path.split(/[\.\]\[]+/g);
+    let openBrackets = path.split("[").length - 1;
+    let closedBrackets = path.split("]").length - 1;
+    if (openBrackets !== closedBrackets) {
+        throw new Error(`Path is invalid. Has unbalanced brackets: ${path}`);
+    }
+    return path.split(/\.(?![^\[]*\])|[\[\]]/g).filter(Boolean);
 }

package/lib/util/transformThemeValue.js

@@ -2,62 +2,72 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-exports.default = transformThemeValue;
-var _postcss = _interopRequireDefault(require("postcss"));
-function _interopRequireDefault(obj) {
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return transformThemeValue;
+    }
+});
+const _postcss = /*#__PURE__*/ _interop_require_default(require("postcss"));
+const _isPlainObject = /*#__PURE__*/ _interop_require_default(require("./isPlainObject"));
+function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
 }
 function transformThemeValue(themeSection) {
     if ([
-        'fontSize',
-        'outline'
+        "fontSize",
+        "outline"
     ].includes(themeSection)) {
         return (value)=>{
-            if (typeof value === 'function') value = value({
-            });
+            if (typeof value === "function") value = value({});
             if (Array.isArray(value)) value = value[0];
             return value;
         };
     }
+    if (themeSection === "fontFamily") {
+        return (value)=>{
+            if (typeof value === "function") value = value({});
+            let families = Array.isArray(value) && (0, _isPlainObject.default)(value[1]) ? value[0] : value;
+            return Array.isArray(families) ? families.join(", ") : families;
+        };
+    }
     if ([
-        'fontFamily',
-        'boxShadow',
-        'transitionProperty',
-        'transitionDuration',
-        'transitionDelay',
-        'transitionTimingFunction',
-        'backgroundImage',
-        'backgroundSize',
-        'backgroundColor',
-        'cursor',
-        'animation', 
+        "boxShadow",
+        "transitionProperty",
+        "transitionDuration",
+        "transitionDelay",
+        "transitionTimingFunction",
+        "backgroundImage",
+        "backgroundSize",
+        "backgroundColor",
+        "cursor",
+        "animation"
     ].includes(themeSection)) {
         return (value)=>{
-            if (typeof value === 'function') value = value({
-            });
-            if (Array.isArray(value)) value = value.join(', ');
+            if (typeof value === "function") value = value({});
+            if (Array.isArray(value)) value = value.join(", ");
             return value;
         };
     }
     // For backwards compatibility reasons, before we switched to underscores
     // instead of commas for arbitrary values.
     if ([
-        'gridTemplateColumns',
-        'gridTemplateRows',
-        'objectPosition'
+        "gridTemplateColumns",
+        "gridTemplateRows",
+        "objectPosition"
     ].includes(themeSection)) {
         return (value)=>{
-            if (typeof value === 'function') value = value({
-            });
-            if (typeof value === 'string') value = _postcss.default.list.comma(value).join(' ');
+            if (typeof value === "function") value = value({});
+            if (typeof value === "string") value = _postcss.default.list.comma(value).join(" ");
             return value;
         };
     }
-    return (value)=>{
-        if (typeof value === 'function') value = value({
-        });
+    return (value, opts = {})=>{
+        if (typeof value === "function") {
+            value = value(opts);
+        }
         return value;
     };
 }

package/lib/util/validateConfig.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "validateConfig", {
+    enumerable: true,
+    get: function() {
+        return validateConfig;
+    }
+});
+const _log = /*#__PURE__*/ _interop_require_default(require("./log"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function validateConfig(config) {
+    if (config.content.files.length === 0) {
+        _log.default.warn("content-problems", [
+            "The `content` option in your Tailwind CSS configuration is missing or empty.",
+            "Configure your content sources or your generated CSS will be missing styles.",
+            "https://tailwindcss.com/docs/content-configuration"
+        ]);
+    }
+    // Warn if the line-clamp plugin is installed
+    try {
+        let plugin = require("@tailwindcss/line-clamp");
+        if (config.plugins.includes(plugin)) {
+            _log.default.warn("line-clamp-in-core", [
+                "As of Tailwind CSS v3.3, the `@tailwindcss/line-clamp` plugin is now included by default.",
+                "Remove it from the `plugins` array in your configuration to eliminate this warning."
+            ]);
+            config.plugins = config.plugins.filter((p)=>p !== plugin);
+        }
+    } catch  {}
+    return config;
+}

package/lib/util/validateFormalSyntax.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "backgroundSize", {
+    enumerable: true,
+    get: function() {
+        return backgroundSize;
+    }
+});
+const _dataTypes = require("./dataTypes");
+const _splitAtTopLevelOnly = require("./splitAtTopLevelOnly");
+function backgroundSize(value) {
+    let keywordValues = [
+        "cover",
+        "contain"
+    ];
+    // the <length-percentage> type will probably be a css function
+    // so we have to use `splitAtTopLevelOnly`
+    return (0, _splitAtTopLevelOnly.splitAtTopLevelOnly)(value, ",").every((part)=>{
+        let sizes = (0, _splitAtTopLevelOnly.splitAtTopLevelOnly)(part, "_").filter(Boolean);
+        if (sizes.length === 1 && keywordValues.includes(sizes[0])) return true;
+        if (sizes.length !== 1 && sizes.length !== 2) return false;
+        return sizes.every((size)=>(0, _dataTypes.length)(size) || (0, _dataTypes.percentage)(size) || size === "auto");
+    });
+}