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

package/lib/lib/getModuleDependencies.js

@@ -2,19 +2,22 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-exports.default = getModuleDependencies;
-var _fs = _interopRequireDefault(require("fs"));
-var _path = _interopRequireDefault(require("path"));
-var _resolve = _interopRequireDefault(require("resolve"));
-var _detective = _interopRequireDefault(require("detective"));
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: ()=>getModuleDependencies
+});
+const _fs = /*#__PURE__*/ _interopRequireDefault(require("fs"));
+const _path = /*#__PURE__*/ _interopRequireDefault(require("path"));
+const _resolve = /*#__PURE__*/ _interopRequireDefault(require("resolve"));
+const _detective = /*#__PURE__*/ _interopRequireDefault(require("detective"));
 function _interopRequireDefault(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
 }
 function createModule(file) {
-    const source = _fs.default.readFileSync(file, 'utf-8');
-    const requires = (0, _detective).default(source);
+    const source = _fs.default.readFileSync(file, "utf-8");
+    const requires = (0, _detective.default)(source);
     return {
         file,
         requires
@@ -30,7 +33,7 @@ function getModuleDependencies(entryFile) {
     for (const mdl of modules){
         mdl.requires.filter((dep)=>{
             // Only track local modules, not node_modules
-            return dep.startsWith('./') || dep.startsWith('../');
+            return dep.startsWith("./") || dep.startsWith("../");
         }).forEach((dep)=>{
             try {
                 const basedir = _path.default.dirname(mdl.file);

package/lib/lib/normalizeTailwindDirectives.js

@@ -2,8 +2,11 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-exports.default = normalizeTailwindDirectives;
-var _log = _interopRequireDefault(require("../util/log"));
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: ()=>normalizeTailwindDirectives
+});
+const _log = /*#__PURE__*/ _interopRequireDefault(require("../util/log"));
 function _interopRequireDefault(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -14,64 +17,65 @@ function normalizeTailwindDirectives(root) {
     let layerDirectives = new Set();
     let applyDirectives = new Set();
     root.walkAtRules((atRule)=>{
-        if (atRule.name === 'apply') {
+        if (atRule.name === "apply") {
             applyDirectives.add(atRule);
         }
-        if (atRule.name === 'import') {
+        if (atRule.name === "import") {
             if (atRule.params === '"tailwindcss/base"' || atRule.params === "'tailwindcss/base'") {
-                atRule.name = 'tailwind';
-                atRule.params = 'base';
+                atRule.name = "tailwind";
+                atRule.params = "base";
             } else if (atRule.params === '"tailwindcss/components"' || atRule.params === "'tailwindcss/components'") {
-                atRule.name = 'tailwind';
-                atRule.params = 'components';
+                atRule.name = "tailwind";
+                atRule.params = "components";
             } else if (atRule.params === '"tailwindcss/utilities"' || atRule.params === "'tailwindcss/utilities'") {
-                atRule.name = 'tailwind';
-                atRule.params = 'utilities';
+                atRule.name = "tailwind";
+                atRule.params = "utilities";
             } else if (atRule.params === '"tailwindcss/screens"' || atRule.params === "'tailwindcss/screens'" || atRule.params === '"tailwindcss/variants"' || atRule.params === "'tailwindcss/variants'") {
-                atRule.name = 'tailwind';
-                atRule.params = 'variants';
+                atRule.name = "tailwind";
+                atRule.params = "variants";
             }
         }
-        if (atRule.name === 'tailwind') {
-            if (atRule.params === 'screens') {
-                atRule.params = 'variants';
+        if (atRule.name === "tailwind") {
+            if (atRule.params === "screens") {
+                atRule.params = "variants";
             }
             tailwindDirectives.add(atRule.params);
         }
         if ([
-            'layer',
-            'responsive',
-            'variants'
+            "layer",
+            "responsive",
+            "variants"
         ].includes(atRule.name)) {
             if ([
-                'responsive',
-                'variants'
+                "responsive",
+                "variants"
             ].includes(atRule.name)) {
                 _log.default.warn(`${atRule.name}-at-rule-deprecated`, [
                     `The \`@${atRule.name}\` directive has been deprecated in Tailwind CSS v3.0.`,
-                    `Use \`@layer utilities\` or \`@layer components\` instead.`, 
+                    `Use \`@layer utilities\` or \`@layer components\` instead.`,
+                    "https://tailwindcss.com/docs/upgrade-guide#replace-variants-with-layer"
                 ]);
             }
             layerDirectives.add(atRule);
         }
     });
-    if (!tailwindDirectives.has('base') || !tailwindDirectives.has('components') || !tailwindDirectives.has('utilities')) {
+    if (!tailwindDirectives.has("base") || !tailwindDirectives.has("components") || !tailwindDirectives.has("utilities")) {
         for (let rule of layerDirectives){
-            if (rule.name === 'layer' && [
-                'base',
-                'components',
-                'utilities'
+            if (rule.name === "layer" && [
+                "base",
+                "components",
+                "utilities"
             ].includes(rule.params)) {
                 if (!tailwindDirectives.has(rule.params)) {
                     throw rule.error(`\`@layer ${rule.params}\` is used but no matching \`@tailwind ${rule.params}\` directive is present.`);
                 }
-            } else if (rule.name === 'responsive') {
-                if (!tailwindDirectives.has('utilities')) {
-                    throw rule.error('`@responsive` is used but `@tailwind utilities` is missing.');
+            } else if (rule.name === "responsive") {
+                if (!tailwindDirectives.has("utilities")) {
+                    throw rule.error("`@responsive` is used but `@tailwind utilities` is missing.");
                 }
-            } else if (rule.name === 'variants') {
-                if (!tailwindDirectives.has('utilities')) {
-                    throw rule.error('`@variants` is used but `@tailwind utilities` is missing.');
+            } else if (rule.name === "variants") {
+                if (!tailwindDirectives.has("utilities")) {
+                    throw rule.error("`@variants` is used but `@tailwind utilities` is missing.");
                 }
             }
         }

package/lib/lib/offsets.js

@@ -0,0 +1,217 @@
+// @ts-check
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "Offsets", {
+    enumerable: true,
+    get: ()=>Offsets
+});
+const _bigSign = /*#__PURE__*/ _interopRequireDefault(require("../util/bigSign"));
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+class Offsets {
+    constructor(){
+        /**
+     * Offsets for the next rule in a given layer
+     *
+     * @type {Record<Layer, bigint>}
+     */ this.offsets = {
+            defaults: 0n,
+            base: 0n,
+            components: 0n,
+            utilities: 0n,
+            variants: 0n,
+            user: 0n
+        };
+        /**
+     * Positions for a given layer
+     *
+     * @type {Record<Layer, bigint>}
+     */ this.layerPositions = {
+            defaults: 0n,
+            base: 1n,
+            components: 2n,
+            utilities: 3n,
+            // There isn't technically a "user" layer, but we need to give it a position
+            // Because it's used for ordering user-css from @apply
+            user: 4n,
+            variants: 5n
+        };
+        /**
+     * The total number of functions currently registered across all variants (including arbitrary variants)
+     *
+     * @type {bigint}
+     */ this.reservedVariantBits = 0n;
+        /**
+     * Positions for a given variant
+     *
+     * @type {Map<string, bigint>}
+     */ this.variantOffsets = new Map();
+    }
+    /**
+   * @param {Layer} layer
+   * @returns {RuleOffset}
+   */ create(layer) {
+        return {
+            layer,
+            parentLayer: layer,
+            arbitrary: 0n,
+            variants: 0n,
+            parallelIndex: 0n,
+            index: this.offsets[layer]++,
+            options: []
+        };
+    }
+    /**
+   * @returns {RuleOffset}
+   */ arbitraryProperty() {
+        return {
+            ...this.create("utilities"),
+            arbitrary: 1n
+        };
+    }
+    /**
+   * Get the offset for a variant
+   *
+   * @param {string} variant
+   * @param {number} index
+   * @returns {RuleOffset}
+   */ forVariant(variant, index = 0) {
+        let offset = this.variantOffsets.get(variant);
+        if (offset === undefined) {
+            throw new Error(`Cannot find offset for unknown variant ${variant}`);
+        }
+        return {
+            ...this.create("variants"),
+            variants: offset << BigInt(index)
+        };
+    }
+    /**
+   * @param {RuleOffset} rule
+   * @param {RuleOffset} variant
+   * @param {VariantOption} options
+   * @returns {RuleOffset}
+   */ applyVariantOffset(rule, variant, options) {
+        return {
+            ...rule,
+            layer: "variants",
+            parentLayer: rule.layer === "variants" ? rule.parentLayer : rule.layer,
+            variants: rule.variants | variant.variants,
+            options: options.sort ? [].concat(options, rule.options) : rule.options,
+            // TODO: Technically this is wrong. We should be handling parallel index on a per variant basis.
+            // We'll take the max of all the parallel indexes for now.
+            // @ts-ignore
+            parallelIndex: max([
+                rule.parallelIndex,
+                variant.parallelIndex
+            ])
+        };
+    }
+    /**
+   * @param {RuleOffset} offset
+   * @param {number} parallelIndex
+   * @returns {RuleOffset}
+   */ applyParallelOffset(offset, parallelIndex) {
+        return {
+            ...offset,
+            parallelIndex: BigInt(parallelIndex)
+        };
+    }
+    /**
+   * Each variant gets 1 bit per function / rule registered.
+   * This is because multiple variants can be applied to a single rule and we need to know which ones are present and which ones are not.
+   * Additionally, every unique group of variants is grouped together in the stylesheet.
+   *
+   * This grouping is order-independent. For instance, we do not differentiate between `hover:focus` and `focus:hover`.
+   *
+   * @param {string[]} variants
+   * @param {(name: string) => number} getLength
+   */ recordVariants(variants, getLength) {
+        for (let variant of variants){
+            this.recordVariant(variant, getLength(variant));
+        }
+    }
+    /**
+   * The same as `recordVariants` but for a single arbitrary variant at runtime.
+   * @param {string} variant
+   * @param {number} fnCount
+   *
+   * @returns {RuleOffset} The highest offset for this variant
+   */ recordVariant(variant, fnCount = 1) {
+        this.variantOffsets.set(variant, 1n << this.reservedVariantBits);
+        // Ensure space is reserved for each "function" in the parallel variant
+        // by offsetting the next variant by the number of parallel variants
+        // in the one we just added.
+        // Single functions that return parallel variants are NOT handled separately here
+        // They're offset by 1 (or the number of functions) as usual
+        // And each rule returned is tracked separately since the functions are evaluated lazily.
+        // @see `RuleOffset.parallelIndex`
+        this.reservedVariantBits += BigInt(fnCount);
+        return {
+            ...this.create("variants"),
+            variants: 1n << this.reservedVariantBits
+        };
+    }
+    /**
+   * @param {RuleOffset} a
+   * @param {RuleOffset} b
+   * @returns {bigint}
+   */ compare(a, b) {
+        // Sort layers together
+        if (a.layer !== b.layer) {
+            return this.layerPositions[a.layer] - this.layerPositions[b.layer];
+        }
+        // Sort based on the sorting function
+        for (let aOptions of a.options){
+            for (let bOptions of b.options){
+                if (aOptions.id !== bOptions.id) continue;
+                if (!aOptions.sort || !bOptions.sort) continue;
+                let result = aOptions.sort({
+                    value: aOptions.value,
+                    modifier: aOptions.modifier
+                }, {
+                    value: bOptions.value,
+                    modifier: bOptions.modifier
+                });
+                if (result !== 0) return result;
+            }
+        }
+        // Sort variants in the order they were registered
+        if (a.variants !== b.variants) {
+            return a.variants - b.variants;
+        }
+        // Make sure each rule returned by a parallel variant is sorted in ascending order
+        if (a.parallelIndex !== b.parallelIndex) {
+            return a.parallelIndex - b.parallelIndex;
+        }
+        // Always sort arbitrary properties after other utilities
+        if (a.arbitrary !== b.arbitrary) {
+            return a.arbitrary - b.arbitrary;
+        }
+        // Sort utilities, components, etc… in the order they were registered
+        return a.index - b.index;
+    }
+    /**
+   * @template T
+   * @param {[RuleOffset, T][]} list
+   * @returns {[RuleOffset, T][]}
+   */ sort(list) {
+        return list.sort(([a], [b])=>(0, _bigSign.default)(this.compare(a, b)));
+    }
+}
+/**
+ *
+ * @param {bigint[]} nums
+ * @returns {bigint|null}
+ */ function max(nums) {
+    let max = null;
+    for (const num of nums){
+        max = max !== null && max !== void 0 ? max : num;
+        max = max > num ? max : num;
+    }
+    return max;
+}

package/lib/lib/partitionApplyAtRules.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: ()=>expandApplyAtRules
+});
+function partitionRules(root) {
+    if (!root.walkAtRules) return;
+    let applyParents = new Set();
+    root.walkAtRules("apply", (rule)=>{
+        applyParents.add(rule.parent);
+    });
+    if (applyParents.size === 0) {
+        return;
+    }
+    for (let rule of applyParents){
+        let nodeGroups = [];
+        let lastGroup = [];
+        for (let node of rule.nodes){
+            if (node.type === "atrule" && node.name === "apply") {
+                if (lastGroup.length > 0) {
+                    nodeGroups.push(lastGroup);
+                    lastGroup = [];
+                }
+                nodeGroups.push([
+                    node
+                ]);
+            } else {
+                lastGroup.push(node);
+            }
+        }
+        if (lastGroup.length > 0) {
+            nodeGroups.push(lastGroup);
+        }
+        if (nodeGroups.length === 1) {
+            continue;
+        }
+        for (let group of [
+            ...nodeGroups
+        ].reverse()){
+            let clone = rule.clone({
+                nodes: []
+            });
+            clone.append(group);
+            rule.after(clone);
+        }
+        rule.remove();
+    }
+}
+function expandApplyAtRules() {
+    return (root)=>{
+        partitionRules(root);
+    };
+}

package/lib/lib/regex.js

@@ -0,0 +1,60 @@
+"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, {
+    pattern: ()=>pattern,
+    withoutCapturing: ()=>withoutCapturing,
+    any: ()=>any,
+    optional: ()=>optional,
+    zeroOrMore: ()=>zeroOrMore,
+    nestedBrackets: ()=>nestedBrackets,
+    escape: ()=>escape
+});
+const REGEX_SPECIAL = /[\\^$.*+?()[\]{}|]/g;
+const REGEX_HAS_SPECIAL = RegExp(REGEX_SPECIAL.source);
+/**
+ * @param {string|RegExp|Array<string|RegExp>} source
+ */ function toSource(source) {
+    source = Array.isArray(source) ? source : [
+        source
+    ];
+    source = source.map((item)=>item instanceof RegExp ? item.source : item);
+    return source.join("");
+}
+function pattern(source) {
+    return new RegExp(toSource(source), "g");
+}
+function withoutCapturing(source) {
+    return new RegExp(`(?:${toSource(source)})`, "g");
+}
+function any(sources) {
+    return `(?:${sources.map(toSource).join("|")})`;
+}
+function optional(source) {
+    return `(?:${toSource(source)})?`;
+}
+function zeroOrMore(source) {
+    return `(?:${toSource(source)})*`;
+}
+function nestedBrackets(open, close, depth = 1) {
+    return withoutCapturing([
+        escape(open),
+        /[^\s]*/,
+        depth === 1 ? `[^${escape(open)}${escape(close)}\s]*` : any([
+            `[^${escape(open)}${escape(close)}\s]*`,
+            nestedBrackets(open, close, depth - 1)
+        ]),
+        /[^\s]*/,
+        escape(close)
+    ]);
+}
+function escape(string) {
+    return string && REGEX_HAS_SPECIAL.test(string) ? string.replace(REGEX_SPECIAL, "\\$&") : string || "";
+}