tailwindcss 3.3.1 → 3.3.3

package/lib/util/parseDependency.js

@@ -11,7 +11,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 Object.defineProperty(exports, "default", {
     enumerable: true,
-    get: ()=>parseDependency
+    get: function() {
+        return parseDependency;
+    }
 });
 function parseDependency(contentPath) {
     if (contentPath.ignore) {

package/lib/util/parseGlob.js

@@ -4,17 +4,19 @@ Object.defineProperty(exports, "__esModule", {
 });
 Object.defineProperty(exports, "parseGlob", {
     enumerable: true,
-    get: ()=>parseGlob
+    get: function() {
+        return parseGlob;
+    }
 });
-const _globParent = /*#__PURE__*/ _interopRequireDefault(require("glob-parent"));
-function _interopRequireDefault(obj) {
+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);
+    let base = (0, _globparent.default)(pattern);
     if (base !== ".") {
         glob = pattern.substr(base.length);
         if (glob.charAt(0) === "/") {

package/lib/util/parseObjectStyles.js

@@ -4,12 +4,14 @@ Object.defineProperty(exports, "__esModule", {
 });
 Object.defineProperty(exports, "default", {
     enumerable: true,
-    get: ()=>parseObjectStyles
+    get: function() {
+        return parseObjectStyles;
+    }
 });
-const _postcss = /*#__PURE__*/ _interopRequireDefault(require("postcss"));
-const _postcssNested = /*#__PURE__*/ _interopRequireDefault(require("postcss-nested"));
-const _postcssJs = /*#__PURE__*/ _interopRequireDefault(require("postcss-js"));
-function _interopRequireDefault(obj) {
+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
     };
@@ -22,13 +24,13 @@ function parseObjectStyles(styles) {
     }
     return styles.flatMap((style)=>{
         return (0, _postcss.default)([
-            (0, _postcssNested.default)({
+            (0, _postcssnested.default)({
                 bubble: [
                     "screen"
                 ]
             })
         ]).process(style, {
-            parser: _postcssJs.default
+            parser: _postcssjs.default
         }).root.nodes;
     });
 }

package/lib/util/pluginUtils.js

@@ -9,22 +9,38 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    updateAllClasses: ()=>updateAllClasses,
-    asValue: ()=>asValue,
-    parseColorFormat: ()=>parseColorFormat,
-    asColor: ()=>asColor,
-    asLookupValue: ()=>asLookupValue,
-    typeMap: ()=>typeMap,
-    coerceValue: ()=>coerceValue,
-    getMatchingTypes: ()=>getMatchingTypes
+    updateAllClasses: function() {
+        return updateAllClasses;
+    },
+    asValue: function() {
+        return asValue;
+    },
+    parseColorFormat: function() {
+        return parseColorFormat;
+    },
+    asColor: function() {
+        return asColor;
+    },
+    asLookupValue: function() {
+        return asLookupValue;
+    },
+    typeMap: function() {
+        return typeMap;
+    },
+    coerceValue: function() {
+        return coerceValue;
+    },
+    getMatchingTypes: function() {
+        return getMatchingTypes;
+    }
 });
-const _escapeCommas = /*#__PURE__*/ _interopRequireDefault(require("./escapeCommas"));
+const _escapeCommas = /*#__PURE__*/ _interop_require_default(require("./escapeCommas"));
 const _withAlphaVariable = require("./withAlphaVariable");
 const _dataTypes = require("./dataTypes");
-const _negateValue = /*#__PURE__*/ _interopRequireDefault(require("./negateValue"));
+const _negateValue = /*#__PURE__*/ _interop_require_default(require("./negateValue"));
 const _validateFormalSyntax = require("./validateFormalSyntax");
-const _featureFlagsJs = require("../featureFlags.js");
-function _interopRequireDefault(obj) {
+const _featureFlags = require("../featureFlags.js");
+function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
@@ -105,11 +121,7 @@ function parseColorFormat(value) {
     return value;
 }
 function unwrapArbitraryModifier(modifier) {
-    modifier = modifier.slice(1, -1);
-    if (modifier.startsWith("--")) {
-        modifier = `var(${modifier})`;
-    }
-    return modifier;
+    return (0, _dataTypes.normalize)(modifier.slice(1, -1));
 }
 function asColor(modifier, options = {}, { tailwindConfig ={}  } = {}) {
     var _options_values;
@@ -224,7 +236,7 @@ function coerceValue(types, modifier, options, tailwindConfig) {
     return [];
 }
 function* getMatchingTypes(types, rawModifier, options, tailwindConfig) {
-    let modifiersEnabled = (0, _featureFlagsJs.flagEnabled)(tailwindConfig, "generalizedModifiers");
+    let modifiersEnabled = (0, _featureFlags.flagEnabled)(tailwindConfig, "generalizedModifiers");
     let [modifier, utilityModifier] = splitUtilityModifier(rawModifier);
     let canUseUtilityModifier = modifiersEnabled && options.modifiers != null && (options.modifiers === "any" || typeof options.modifiers === "object" && (utilityModifier && isArbitraryValue(utilityModifier) || utilityModifier in options.modifiers));
     if (!canUseUtilityModifier) {

package/lib/util/prefixSelector.js

@@ -15,10 +15,12 @@ Object.defineProperty(exports, /**
  * @returns {T}
  */ "default", {
     enumerable: true,
-    get: ()=>_default
+    get: function() {
+        return _default;
+    }
 });
-const _postcssSelectorParser = /*#__PURE__*/ _interopRequireDefault(require("postcss-selector-parser"));
-function _interopRequireDefault(obj) {
+const _postcssselectorparser = /*#__PURE__*/ _interop_require_default(require("postcss-selector-parser"));
+function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
@@ -27,7 +29,7 @@ function _default(prefix, selector, prependNegative = false) {
     if (prefix === "") {
         return selector;
     }
-    let ast = typeof selector === "string" ? (0, _postcssSelectorParser.default)().astSync(selector) : selector;
+    /** @type {import('postcss-selector-parser').Root} */ let ast = typeof selector === "string" ? (0, _postcssselectorparser.default)().astSync(selector) : selector;
     ast.walkClasses((classSelector)=>{
         let baseClass = classSelector.value;
         let shouldPlaceNegativeBeforePrefix = prependNegative && baseClass.startsWith("-");

package/lib/util/pseudoElements.js

@@ -0,0 +1,209 @@
+/** @typedef {import('postcss-selector-parser').Root} Root */ /** @typedef {import('postcss-selector-parser').Selector} Selector */ /** @typedef {import('postcss-selector-parser').Pseudo} Pseudo */ /** @typedef {import('postcss-selector-parser').Node} Node */ // There are some pseudo-elements that may or may not be:
+// **Actionable**
+// Zero or more user-action pseudo-classes may be attached to the pseudo-element itself
+// structural-pseudo-classes are NOT allowed but we don't make
+// The spec is not clear on whether this is allowed or not — but in practice it is.
+// **Terminal**
+// It MUST be placed at the end of a selector
+//
+// This is the required in the spec. However, some pseudo elements are not "terminal" because
+// they represent a "boundary piercing" that is compiled out by a build step.
+// **Jumpable**
+// Any terminal element may "jump" over combinators when moving to the end of the selector
+//
+// This is a backwards-compat quirk of pseudo element variants from earlier versions of Tailwind CSS.
+/** @typedef {'terminal' | 'actionable' | 'jumpable'} PseudoProperty */ /** @type {Record<string, PseudoProperty[]>} */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "movePseudos", {
+    enumerable: true,
+    get: function() {
+        return movePseudos;
+    }
+});
+let elementProperties = {
+    // Pseudo elements from the spec
+    "::after": [
+        "terminal",
+        "jumpable"
+    ],
+    "::backdrop": [
+        "terminal",
+        "jumpable"
+    ],
+    "::before": [
+        "terminal",
+        "jumpable"
+    ],
+    "::cue": [
+        "terminal"
+    ],
+    "::cue-region": [
+        "terminal"
+    ],
+    "::first-letter": [
+        "terminal",
+        "jumpable"
+    ],
+    "::first-line": [
+        "terminal",
+        "jumpable"
+    ],
+    "::grammar-error": [
+        "terminal"
+    ],
+    "::marker": [
+        "terminal",
+        "jumpable"
+    ],
+    "::part": [
+        "terminal",
+        "actionable"
+    ],
+    "::placeholder": [
+        "terminal",
+        "jumpable"
+    ],
+    "::selection": [
+        "terminal",
+        "jumpable"
+    ],
+    "::slotted": [
+        "terminal"
+    ],
+    "::spelling-error": [
+        "terminal"
+    ],
+    "::target-text": [
+        "terminal"
+    ],
+    // Pseudo elements from the spec with special rules
+    "::file-selector-button": [
+        "terminal",
+        "actionable"
+    ],
+    // Library-specific pseudo elements used by component libraries
+    // These are Shadow DOM-like
+    "::deep": [
+        "actionable"
+    ],
+    "::v-deep": [
+        "actionable"
+    ],
+    "::ng-deep": [
+        "actionable"
+    ],
+    // 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.
+    ":after": [
+        "terminal",
+        "jumpable"
+    ],
+    ":before": [
+        "terminal",
+        "jumpable"
+    ],
+    ":first-letter": [
+        "terminal",
+        "jumpable"
+    ],
+    ":first-line": [
+        "terminal",
+        "jumpable"
+    ],
+    // The default value is used when the pseudo-element is not recognized
+    // Because it's not recognized, we don't know if it's terminal or not
+    // So we assume it can be moved AND can have user-action pseudo classes attached to it
+    __default__: [
+        "terminal",
+        "actionable"
+    ]
+};
+function movePseudos(sel) {
+    let [pseudos] = movablePseudos(sel);
+    // Remove all pseudo elements from their respective selectors
+    pseudos.forEach(([sel, pseudo])=>sel.removeChild(pseudo));
+    // Re-add them to the end of the selector in the correct order.
+    // This moves terminal pseudo elements to the end of the
+    // selector otherwise the selector will not be valid.
+    //
+    // Examples:
+    //  - `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`
+    //
+    // The selector `::before:hover` does not work but we
+    // can make it work for you by flipping the order.
+    sel.nodes.push(...pseudos.map(([, pseudo])=>pseudo));
+    return sel;
+}
+/** @typedef {[sel: Selector, pseudo: Pseudo, attachedTo: Pseudo | null]} MovablePseudo */ /** @typedef {[pseudos: MovablePseudo[], lastSeenElement: Pseudo | null]} MovablePseudosResult */ /**
+ * @param {Selector} sel
+ * @returns {MovablePseudosResult}
+ */ function movablePseudos(sel) {
+    /** @type {MovablePseudo[]} */ let buffer = [];
+    /** @type {Pseudo | null} */ let lastSeenElement = null;
+    for (let node of sel.nodes){
+        if (node.type === "combinator") {
+            buffer = buffer.filter(([, node])=>propertiesForPseudo(node).includes("jumpable"));
+            lastSeenElement = null;
+        } else if (node.type === "pseudo") {
+            if (isMovablePseudoElement(node)) {
+                lastSeenElement = node;
+                buffer.push([
+                    sel,
+                    node,
+                    null
+                ]);
+            } else if (lastSeenElement && isAttachablePseudoClass(node, lastSeenElement)) {
+                buffer.push([
+                    sel,
+                    node,
+                    lastSeenElement
+                ]);
+            } else {
+                lastSeenElement = null;
+            }
+            var _node_nodes;
+            for (let sub of (_node_nodes = node.nodes) !== null && _node_nodes !== void 0 ? _node_nodes : []){
+                let [movable, lastSeenElementInSub] = movablePseudos(sub);
+                lastSeenElement = lastSeenElementInSub || lastSeenElement;
+                buffer.push(...movable);
+            }
+        }
+    }
+    return [
+        buffer,
+        lastSeenElement
+    ];
+}
+/**
+ * @param {Node} node
+ * @returns {boolean}
+ */ function isPseudoElement(node) {
+    return node.value.startsWith("::") || elementProperties[node.value] !== undefined;
+}
+/**
+ * @param {Node} node
+ * @returns {boolean}
+ */ function isMovablePseudoElement(node) {
+    return isPseudoElement(node) && propertiesForPseudo(node).includes("terminal");
+}
+/**
+ * @param {Node} node
+ * @param {Pseudo} pseudo
+ * @returns {boolean}
+ */ function isAttachablePseudoClass(node, pseudo) {
+    if (node.type !== "pseudo") return false;
+    if (isPseudoElement(node)) return false;
+    return propertiesForPseudo(pseudo).includes("actionable");
+}
+/**
+ * @param {Pseudo} pseudo
+ * @returns {PseudoProperty[]}
+ */ function propertiesForPseudo(pseudo) {
+    var _elementProperties_pseudo_value;
+    return (_elementProperties_pseudo_value = elementProperties[pseudo.value]) !== null && _elementProperties_pseudo_value !== void 0 ? _elementProperties_pseudo_value : elementProperties.__default__;
+}

package/lib/util/removeAlphaVariables.js

@@ -12,7 +12,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 Object.defineProperty(exports, "removeAlphaVariables", {
     enumerable: true,
-    get: ()=>removeAlphaVariables
+    get: function() {
+        return removeAlphaVariables;
+    }
 });
 function removeAlphaVariables(container, toRemove) {
     container.walkDecls((decl)=>{

package/lib/util/resolveConfig.js

@@ -4,21 +4,23 @@ Object.defineProperty(exports, "__esModule", {
 });
 Object.defineProperty(exports, "default", {
     enumerable: true,
-    get: ()=>resolveConfig
+    get: function() {
+        return resolveConfig;
+    }
 });
-const _negateValue = /*#__PURE__*/ _interopRequireDefault(require("./negateValue"));
-const _corePluginList = /*#__PURE__*/ _interopRequireDefault(require("../corePluginList"));
-const _configurePlugins = /*#__PURE__*/ _interopRequireDefault(require("./configurePlugins"));
-const _colors = /*#__PURE__*/ _interopRequireDefault(require("../public/colors"));
+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__*/ _interopRequireDefault(require("./isPlainObject"));
+const _isPlainObject = /*#__PURE__*/ _interop_require_default(require("./isPlainObject"));
 const _cloneDeep = require("./cloneDeep");
 const _pluginUtils = require("./pluginUtils");
 const _withAlphaVariable = require("./withAlphaVariable");
-const _toColorValue = /*#__PURE__*/ _interopRequireDefault(require("./toColorValue"));
-function _interopRequireDefault(obj) {
+const _toColorValue = /*#__PURE__*/ _interop_require_default(require("./toColorValue"));
+function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };

package/lib/util/resolveConfigPath.js

@@ -9,12 +9,16 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    default: ()=>resolveConfigPath,
-    resolveDefaultConfigPath: ()=>resolveDefaultConfigPath
+    default: function() {
+        return resolveConfigPath;
+    },
+    resolveDefaultConfigPath: function() {
+        return resolveDefaultConfigPath;
+    }
 });
-const _fs = /*#__PURE__*/ _interopRequireDefault(require("fs"));
-const _path = /*#__PURE__*/ _interopRequireDefault(require("path"));
-function _interopRequireDefault(obj) {
+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
     };

package/lib/util/responsive.js

@@ -4,11 +4,13 @@ Object.defineProperty(exports, "__esModule", {
 });
 Object.defineProperty(exports, "default", {
     enumerable: true,
-    get: ()=>responsive
+    get: function() {
+        return responsive;
+    }
 });
-const _postcss = /*#__PURE__*/ _interopRequireDefault(require("postcss"));
-const _cloneNodes = /*#__PURE__*/ _interopRequireDefault(require("./cloneNodes"));
-function _interopRequireDefault(obj) {
+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
     };

package/lib/util/splitAtTopLevelOnly.js

@@ -18,7 +18,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 Object.defineProperty(exports, "splitAtTopLevelOnly", {
     enumerable: true,
-    get: ()=>splitAtTopLevelOnly
+    get: function() {
+        return splitAtTopLevelOnly;
+    }
 });
 function splitAtTopLevelOnly(input, separator) {
     let stack = [];

package/lib/util/tap.js

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

package/lib/util/toColorValue.js

@@ -4,7 +4,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 Object.defineProperty(exports, "default", {
     enumerable: true,
-    get: ()=>toColorValue
+    get: function() {
+        return toColorValue;
+    }
 });
 function toColorValue(maybeFunction) {
     return typeof maybeFunction === "function" ? maybeFunction({}) : maybeFunction;

package/lib/util/toPath.js

@@ -17,7 +17,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 Object.defineProperty(exports, "toPath", {
     enumerable: true,
-    get: ()=>toPath
+    get: function() {
+        return toPath;
+    }
 });
 function toPath(path) {
     if (Array.isArray(path)) return path;

package/lib/util/transformThemeValue.js

@@ -4,11 +4,13 @@ Object.defineProperty(exports, "__esModule", {
 });
 Object.defineProperty(exports, "default", {
     enumerable: true,
-    get: ()=>transformThemeValue
+    get: function() {
+        return transformThemeValue;
+    }
 });
-const _postcss = /*#__PURE__*/ _interopRequireDefault(require("postcss"));
-const _isPlainObject = /*#__PURE__*/ _interopRequireDefault(require("./isPlainObject"));
-function _interopRequireDefault(obj) {
+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
     };

package/lib/util/validateConfig.js

@@ -4,10 +4,12 @@ Object.defineProperty(exports, "__esModule", {
 });
 Object.defineProperty(exports, "validateConfig", {
     enumerable: true,
-    get: ()=>validateConfig
+    get: function() {
+        return validateConfig;
+    }
 });
-const _log = /*#__PURE__*/ _interopRequireDefault(require("./log"));
-function _interopRequireDefault(obj) {
+const _log = /*#__PURE__*/ _interop_require_default(require("./log"));
+function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };

package/lib/util/validateFormalSyntax.js

@@ -4,7 +4,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 Object.defineProperty(exports, "backgroundSize", {
     enumerable: true,
-    get: ()=>backgroundSize
+    get: function() {
+        return backgroundSize;
+    }
 });
 const _dataTypes = require("./dataTypes");
 const _splitAtTopLevelOnly = require("./splitAtTopLevelOnly");

package/lib/util/withAlphaVariable.js

@@ -9,8 +9,12 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    withAlphaValue: ()=>withAlphaValue,
-    default: ()=>withAlphaVariable
+    withAlphaValue: function() {
+        return withAlphaValue;
+    },
+    default: function() {
+        return withAlphaVariable;
+    }
 });
 const _color = require("./color");
 function withAlphaValue(color, alphaValue, defaultValue) {

package/lib/value-parser/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) Bogdan Chadkin <trysound@yandex.ru>
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

package/lib/value-parser/README.md

@@ -0,0 +1,3 @@
+# postcss-value-parser (forked + inlined)
+
+This is a customized version of of [PostCSS Value Parser](https://github.com/TrySound/postcss-value-parser) to fix some bugs around parsing CSS functions.

package/lib/value-parser/index.d.js

@@ -0,0 +1,2 @@
+"use strict";
+module.exports = postcssValueParser;

package/lib/value-parser/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var parse = require("./parse");
+var walk = require("./walk");
+var stringify = require("./stringify");
+function ValueParser(value) {
+    if (this instanceof ValueParser) {
+        this.nodes = parse(value);
+        return this;
+    }
+    return new ValueParser(value);
+}
+ValueParser.prototype.toString = function() {
+    return Array.isArray(this.nodes) ? stringify(this.nodes) : "";
+};
+ValueParser.prototype.walk = function(cb, bubble) {
+    walk(this.nodes, cb, bubble);
+    return this;
+};
+ValueParser.unit = require("./unit");
+ValueParser.walk = walk;
+ValueParser.stringify = stringify;
+module.exports = ValueParser;