tailwindcss 0.0.0-insiders.df011dc → 0.0.0-insiders.e2d5f21

package/lib/util/formatVariantSelector.js

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+exports.formatVariantSelector = formatVariantSelector;
+exports.finalizeSelector = finalizeSelector;
+exports.selectorFunctions = void 0;
+var _postcssSelectorParser = _interopRequireDefault(require("postcss-selector-parser"));
+var _unesc = _interopRequireDefault(require("postcss-selector-parser/dist/util/unesc"));
+var _escapeClassName = _interopRequireDefault(require("../util/escapeClassName"));
+var _prefixSelector = _interopRequireDefault(require("../util/prefixSelector"));
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+let MERGE = ':merge';
+let PARENT = '&';
+let selectorFunctions = new Set([
+    MERGE
+]);
+exports.selectorFunctions = selectorFunctions;
+function formatVariantSelector(current, ...others) {
+    for (let other of others){
+        let incomingValue = resolveFunctionArgument(other, MERGE);
+        if (incomingValue !== null) {
+            let existingValue = resolveFunctionArgument(current, MERGE, incomingValue);
+            if (existingValue !== null) {
+                let existingTarget = `${MERGE}(${incomingValue})`;
+                let splitIdx = other.indexOf(existingTarget);
+                let addition = other.slice(splitIdx + existingTarget.length).split(' ')[0];
+                current = current.replace(existingTarget, existingTarget + addition);
+                continue;
+            }
+        }
+        current = other.replace(PARENT, current);
+    }
+    return current;
+}
+function finalizeSelector(format, { selector: selector1 , candidate , context  }) {
+    var ref, ref1;
+    var ref2;
+    let separator = (ref2 = context === null || context === void 0 ? void 0 : (ref = context.tailwindConfig) === null || ref === void 0 ? void 0 : ref.separator) !== null && ref2 !== void 0 ? ref2 : ':';
+    // Split by the separator, but ignore the separator inside square brackets:
+    //
+    // E.g.: dark:lg:hover:[paint-order:markers]
+    //           ┬  ┬     ┬            ┬
+    //           │  │     │            ╰── We will not split here
+    //           ╰──┴─────┴─────────────── We will split here
+    //
+    let splitter = new RegExp(`\\${separator}(?![^[]*\\])`);
+    let base = candidate.split(splitter).pop();
+    if (context === null || context === void 0 ? void 0 : (ref1 = context.tailwindConfig) === null || ref1 === void 0 ? void 0 : ref1.prefix) {
+        format = (0, _prefixSelector).default(context.tailwindConfig.prefix, format);
+    }
+    format = format.replace(PARENT, `.${(0, _escapeClassName).default(candidate)}`);
+    // Normalize escaped classes, e.g.:
+    //
+    // The idea would be to replace the escaped `base` in the selector with the
+    // `format`. However, in css you can escape the same selector in a few
+    // different ways. This would result in different strings and therefore we
+    // can't replace it properly.
+    //
+    //               base: bg-[rgb(255,0,0)]
+    //   base in selector: bg-\\[rgb\\(255\\,0\\,0\\)\\]
+    //       escaped base: bg-\\[rgb\\(255\\2c 0\\2c 0\\)\\]
+    //
+    selector1 = (0, _postcssSelectorParser).default((selectors)=>{
+        return selectors.walkClasses((node)=>{
+            if (node.raws && node.value.includes(base)) {
+                node.raws.value = (0, _escapeClassName).default((0, _unesc).default(node.raws.value));
+            }
+            return node;
+        });
+    }).processSync(selector1);
+    // We can safely replace the escaped base now, since the `base` section is
+    // now in a normalized escaped value.
+    selector1 = selector1.replace(`.${(0, _escapeClassName).default(base)}`, format);
+    // Remove unnecessary pseudo selectors that we used as placeholders
+    return (0, _postcssSelectorParser).default((selectors)=>{
+        return selectors.map((selector2)=>{
+            selector2.walkPseudos((p)=>{
+                if (selectorFunctions.has(p.value)) {
+                    p.replaceWith(p.nodes);
+                }
+                return p;
+            });
+            // This will make sure to move pseudo's to the correct spot (the end for
+            // pseudo elements) because otherwise the selector will never work
+            // anyway.
+            //
+            // E.g.:
+            //  - `before:hover:text-center` would result in `.before\:hover\:text-center:hover::before`
+            //  - `hover:before:text-center` would result in `.hover\:before\:text-center:hover::before`
+            //
+            // `::before:hover` doesn't work, which means that we can make it work for you by flipping the order.
+            function collectPseudoElements(selector) {
+                let nodes = [];
+                for (let node of selector.nodes){
+                    if (isPseudoElement(node)) {
+                        nodes.push(node);
+                        selector.removeChild(node);
+                    }
+                    if (node === null || node === void 0 ? void 0 : node.nodes) {
+                        nodes.push(...collectPseudoElements(node));
+                    }
+                }
+                return nodes;
+            }
+            let pseudoElements = collectPseudoElements(selector2);
+            if (pseudoElements.length > 0) {
+                selector2.nodes.push(pseudoElements.sort(sortSelector));
+            }
+            return selector2;
+        });
+    }).processSync(selector1);
+}
+// Note: As a rule, double colons (::) should be used instead of a single colon
+// (:). This distinguishes pseudo-classes from pseudo-elements. However, since
+// this distinction was not present in older versions of the W3C spec, most
+// browsers support both syntaxes for the original pseudo-elements.
+let pseudoElementsBC = [
+    ':before',
+    ':after',
+    ':first-line',
+    ':first-letter'
+];
+// These pseudo-elements _can_ be combined with other pseudo selectors AND the order does matter.
+let pseudoElementExceptions = [
+    '::file-selector-button'
+];
+// This will make sure to move pseudo's to the correct spot (the end for
+// pseudo elements) because otherwise the selector will never work
+// anyway.
+//
+// E.g.:
+//  - `before:hover:text-center` would result in `.before\:hover\:text-center:hover::before`
+//  - `hover:before:text-center` would result in `.hover\:before\:text-center:hover::before`
+//
+// `::before:hover` doesn't work, which means that we can make it work
+// for you by flipping the order.
+function sortSelector(a, z) {
+    // Both nodes are non-pseudo's so we can safely ignore them and keep
+    // them in the same order.
+    if (a.type !== 'pseudo' && z.type !== 'pseudo') {
+        return 0;
+    }
+    // If one of them is a combinator, we need to keep it in the same order
+    // because that means it will start a new "section" in the selector.
+    if (a.type === 'combinator' ^ z.type === 'combinator') {
+        return 0;
+    }
+    // One of the items is a pseudo and the other one isn't. Let's move
+    // the pseudo to the right.
+    if (a.type === 'pseudo' ^ z.type === 'pseudo') {
+        return (a.type === 'pseudo') - (z.type === 'pseudo');
+    }
+    // Both are pseudo's, move the pseudo elements (except for
+    // ::file-selector-button) to the right.
+    return isPseudoElement(a) - isPseudoElement(z);
+}
+function isPseudoElement(node) {
+    if (node.type !== 'pseudo') return false;
+    if (pseudoElementExceptions.includes(node.value)) return false;
+    return node.value.startsWith('::') || pseudoElementsBC.includes(node.value);
+}
+function resolveFunctionArgument(haystack, needle, arg) {
+    let startIdx = haystack.indexOf(arg ? `${needle}(${arg})` : needle);
+    if (startIdx === -1) return null;
+    // Start inside the `(`
+    startIdx += needle.length + 1;
+    let target = '';
+    let count = 0;
+    for (let char of haystack.slice(startIdx)){
+        if (char !== '(' && char !== ')') {
+            target += char;
+        } else if (char === '(') {
+            target += char;
+            count++;
+        } else if (char === ')') {
+            if (--count < 0) break; // unbalanced
+            target += char;
+        }
+    }
+    return target;
+}

package/lib/util/getAllConfigs.js

@@ -1,22 +1,29 @@
 "use strict";
-
 Object.defineProperty(exports, "__esModule", {
-  value: true
+    value: true
 });
 exports.default = getAllConfigs;
-
-var _defaultConfigStub = _interopRequireDefault(require("../../stubs/defaultConfig.stub.js"));
-
+var _defaultConfigStubJs = _interopRequireDefault(require("../../stubs/defaultConfig.stub.js"));
 var _featureFlags = require("../featureFlags");
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
 function getAllConfigs(config) {
-  var _config$presets;
-
-  const configs = ((_config$presets = config === null || config === void 0 ? void 0 : config.presets) !== null && _config$presets !== void 0 ? _config$presets : [_defaultConfigStub.default]).slice().reverse().flatMap(preset => getAllConfigs(preset instanceof Function ? preset() : preset));
-  const features = {// Add experimental configs here...
-  };
-  const experimentals = Object.keys(features).filter(feature => (0, _featureFlags.flagEnabled)(config, feature)).map(feature => features[feature]);
-  return [config, ...experimentals, ...configs];
-}
+    var ref;
+    const configs = ((ref = config === null || config === void 0 ? void 0 : config.presets) !== null && ref !== void 0 ? ref : [
+        _defaultConfigStubJs.default
+    ]).slice().reverse().flatMap((preset)=>getAllConfigs(preset instanceof Function ? preset() : preset)
+    );
+    const features = {
+    };
+    const experimentals = Object.keys(features).filter((feature)=>(0, _featureFlags).flagEnabled(config, feature)
+    ).map((feature)=>features[feature]
+    );
+    return [
+        config,
+        ...experimentals,
+        ...configs
+    ];
+}

package/lib/util/hashConfig.js

@@ -1,16 +1,16 @@
 "use strict";
-
 Object.defineProperty(exports, "__esModule", {
-  value: true
+    value: true
 });
 exports.default = hashConfig;
-
 var _objectHash = _interopRequireDefault(require("object-hash"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
 function hashConfig(config) {
-  return (0, _objectHash.default)(config, {
-    ignoreUnknown: true
-  });
-}
+    return (0, _objectHash).default(config, {
+        ignoreUnknown: true
+    });
+}

package/lib/util/isKeyframeRule.js

@@ -1,10 +1,8 @@
 "use strict";
-
 Object.defineProperty(exports, "__esModule", {
-  value: true
+    value: true
 });
 exports.default = isKeyframeRule;
-
 function isKeyframeRule(rule) {
-  return rule.parent && rule.parent.type === 'atrule' && /keyframes$/.test(rule.parent.name);
-}
+    return rule.parent && rule.parent.type === 'atrule' && /keyframes$/.test(rule.parent.name);
+}

package/lib/util/isPlainObject.js

@@ -1,15 +1,12 @@
 "use strict";
-
 Object.defineProperty(exports, "__esModule", {
-  value: true
+    value: true
 });
 exports.default = isPlainObject;
-
 function isPlainObject(value) {
-  if (Object.prototype.toString.call(value) !== '[object Object]') {
-    return false;
-  }
-
-  const prototype = Object.getPrototypeOf(value);
-  return prototype === null || prototype === Object.prototype;
-}
+    if (Object.prototype.toString.call(value) !== '[object Object]') {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === null || prototype === Object.prototype;
+}

package/lib/util/isValidArbitraryValue.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+exports.default = isValidArbitraryValue;
+let matchingBrackets = new Map([
+    [
+        '{',
+        '}'
+    ],
+    [
+        '[',
+        ']'
+    ],
+    [
+        '(',
+        ')'
+    ], 
+]);
+let inverseMatchingBrackets = new Map(Array.from(matchingBrackets.entries()).map(([k, v])=>[
+        v,
+        k
+    ]
+));
+let quotes = new Set([
+    '"',
+    "'",
+    '`'
+]);
+function isValidArbitraryValue(value) {
+    let stack = [];
+    let inQuotes = false;
+    for(let i = 0; i < value.length; i++){
+        let char = value[i];
+        if (char === ':' && !inQuotes && stack.length === 0) {
+            return false;
+        }
+        // Non-escaped quotes allow us to "allow" anything in between
+        if (quotes.has(char) && value[i - 1] !== '\\') {
+            inQuotes = !inQuotes;
+        }
+        if (inQuotes) continue;
+        if (value[i - 1] === '\\') continue; // Escaped
+        if (matchingBrackets.has(char)) {
+            stack.push(char);
+        } else if (inverseMatchingBrackets.has(char)) {
+            let inverse = inverseMatchingBrackets.get(char);
+            // Nothing to pop from, therefore it is unbalanced
+            if (stack.length <= 0) {
+                return false;
+            }
+            // Popped value must match the inverse value, otherwise it is unbalanced
+            if (stack.pop() !== inverse) {
+                return false;
+            }
+        }
+    }
+    // If there is still something on the stack, it is also unbalanced
+    if (stack.length > 0) {
+        return false;
+    }
+    // All good, totally balanced!
+    return true;
+}

package/lib/util/log.js

@@ -1,38 +1,47 @@
 "use strict";
-
 Object.defineProperty(exports, "__esModule", {
-  value: true
+    value: true
 });
 exports.default = void 0;
-
 var _chalk = _interopRequireDefault(require("chalk"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-var _default = {
-  info(messages) {
-    if (process.env.JEST_WORKER_ID !== undefined) return;
-    console.warn('');
-    messages.forEach(message => {
-      console.warn(_chalk.default.bold.cyan('info'), '-', message);
-    });
-  },
-
-  warn(messages) {
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+let alreadyShown = new Set();
+function log(chalk, messages, key) {
     if (process.env.JEST_WORKER_ID !== undefined) return;
+    if (key && alreadyShown.has(key)) return;
+    if (key) alreadyShown.add(key);
     console.warn('');
-    messages.forEach(message => {
-      console.warn(_chalk.default.bold.yellow('warn'), '-', message);
-    });
-  },
-
-  risk(messages) {
-    if (process.env.JEST_WORKER_ID !== undefined) return;
-    console.warn('');
-    messages.forEach(message => {
-      console.warn(_chalk.default.bold.magenta('risk'), '-', message);
-    });
-  }
-
+    messages.forEach((message)=>console.warn(chalk, '-', message)
+    );
+}
+var _default = {
+    info (key, messages) {
+        log(_chalk.default.bold.cyan('info'), ...Array.isArray(key) ? [
+            key
+        ] : [
+            messages,
+            key
+        ]);
+    },
+    warn (key, messages) {
+        log(_chalk.default.bold.yellow('warn'), ...Array.isArray(key) ? [
+            key
+        ] : [
+            messages,
+            key
+        ]);
+    },
+    risk (key, messages) {
+        log(_chalk.default.bold.magenta('risk'), ...Array.isArray(key) ? [
+            key
+        ] : [
+            messages,
+            key
+        ]);
+    }
 };
-exports.default = _default;
+exports.default = _default;

package/lib/util/nameClass.js

@@ -1,32 +1,32 @@
 "use strict";
-
 Object.defineProperty(exports, "__esModule", {
-  value: true
+    value: true
 });
+exports.asClass = asClass;
 exports.default = nameClass;
-
+exports.formatClass = formatClass;
 var _escapeClassName = _interopRequireDefault(require("./escapeClassName"));
-
 var _escapeCommas = _interopRequireDefault(require("./escapeCommas"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
+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}`;
+    }
+    return `${classPrefix}-${key}`;
+}

package/lib/util/negateValue.js

@@ -1,20 +1,19 @@
 "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;
-}
+    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 === '-' ? '' : '-'
+        );
+    }
+    if (value.includes('var(') || value.includes('calc(')) {
+        return `calc(${value} * -1)`;
+    }
+}