tailwindcss 0.0.0-oxide-insiders.9ebaaac → 0.0.0-oxide.1

package/lib/lib/regex.js

@@ -1,74 +0,0 @@
-"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: function() {
-        return pattern;
-    },
-    withoutCapturing: function() {
-        return withoutCapturing;
-    },
-    any: function() {
-        return any;
-    },
-    optional: function() {
-        return optional;
-    },
-    zeroOrMore: function() {
-        return zeroOrMore;
-    },
-    nestedBrackets: function() {
-        return nestedBrackets;
-    },
-    escape: function() {
-        return 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 || "";
-}

package/lib/lib/remap-bitfield.js

@@ -1,89 +0,0 @@
-// @ts-check
-/**
- * We must remap all the old bits to new bits for each set variant
- * Only arbitrary variants are considered as those are the only
- * ones that need to be re-sorted at this time
- *
- * An iterated process that removes and sets individual bits simultaneously
- * will not work because we may have a new bit that is also a later old bit
- * This means that we would be removing a previously set bit which we don't
- * want to do
- *
- * For example (assume `bN` = `1<<N`)
- * Given the "total" mapping `[[b1, b3], [b2, b4], [b3, b1], [b4, b2]]`
- * The mapping is "total" because:
- * 1. Every input and output is accounted for
- * 2. All combinations are unique
- * 3. No one input maps to multiple outputs and vice versa
- * And, given an offset with all bits set:
- * V = b1 | b2 | b3 | b4
- *
- * Let's explore the issue with removing and setting bits simultaneously:
- * V & ~b1 | b3 = b2 | b3 | b4
- * V & ~b2 | b4 = b3 | b4
- * V & ~b3 | b1 = b1 | b4
- * V & ~b4 | b2 = b1 | b2
- *
- * As you can see, we end up with the wrong result.
- * This is because we're removing a bit that was previously set.
- * And, thus the final result is missing b3 and b4.
- *
- * Now, let's explore the issue with removing the bits first:
- * V & ~b1 = b2 | b3 | b4
- * V & ~b2 = b3 | b4
- * V & ~b3 = b4
- * V & ~b4 = 0
- *
- * And then setting the bits:
- * V | b3 = b3
- * V | b4 = b3 | b4
- * V | b1 = b1 | b3 | b4
- * V | b2 = b1 | b2 | b3 | b4
- *
- * We get the correct result because we're not removing any bits that were
- * previously set thus properly remapping the bits to the new order
- *
- * To collect this into a single operation that can be done simultaneously
- * we must first create a mask for the old bits that are set and a mask for
- * the new bits that are set. Then we can remove the old bits and set the new
- * bits simultaneously in a "single" operation like so:
- * OldMask = b1 | b2 | b3 | b4
- * NewMask = b3 | b4 | b1 | b2
- *
- * So this:
- * V & ~oldMask | newMask
- *
- * Expands to this:
- * V & ~b1 & ~b2 & ~b3 & ~b4 | b3 | b4 | b1 | b2
- *
- * Which becomes this:
- * b1 | b2 | b3 | b4
- *
- * Which is the correct result!
- *
- * @param {bigint} num
- * @param {[bigint, bigint][]} mapping
- */ "use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "remapBitfield", {
-    enumerable: true,
-    get: function() {
-        return remapBitfield;
-    }
-});
-function remapBitfield(num, mapping) {
-    // Create masks for the old and new bits that are set
-    let oldMask = 0n;
-    let newMask = 0n;
-    for (let [oldBit, newBit] of mapping){
-        if (num & oldBit) {
-            oldMask = oldMask | oldBit;
-            newMask = newMask | newBit;
-        }
-    }
-    // Remove all old bits
-    // Set all new bits
-    return num & ~oldMask | newMask;
-}

package/lib/lib/resolveDefaultsAtRules.js

@@ -1,165 +0,0 @@
-"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, {
-    elementSelectorParser: function() {
-        return elementSelectorParser;
-    },
-    default: function() {
-        return resolveDefaultsAtRules;
-    }
-});
-const _postcss = /*#__PURE__*/ _interop_require_default(require("postcss"));
-const _postcssselectorparser = /*#__PURE__*/ _interop_require_default(require("postcss-selector-parser"));
-const _featureFlags = require("../featureFlags");
-function _interop_require_default(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-let getNode = {
-    id (node) {
-        return _postcssselectorparser.default.attribute({
-            attribute: "id",
-            operator: "=",
-            value: node.value,
-            quoteMark: '"'
-        });
-    }
-};
-function minimumImpactSelector(nodes) {
-    let rest = nodes.filter((node)=>{
-        // Keep non-pseudo nodes
-        if (node.type !== "pseudo") return true;
-        // Keep pseudo nodes that have subnodes
-        // E.g.: `:not()` contains subnodes inside the parentheses
-        if (node.nodes.length > 0) return true;
-        // Keep pseudo `elements`
-        // This implicitly means that we ignore pseudo `classes`
-        return node.value.startsWith("::") || [
-            ":before",
-            ":after",
-            ":first-line",
-            ":first-letter"
-        ].includes(node.value);
-    }).reverse();
-    let searchFor = new Set([
-        "tag",
-        "class",
-        "id",
-        "attribute"
-    ]);
-    let splitPointIdx = rest.findIndex((n)=>searchFor.has(n.type));
-    if (splitPointIdx === -1) return rest.reverse().join("").trim();
-    let node = rest[splitPointIdx];
-    let bestNode = getNode[node.type] ? getNode[node.type](node) : node;
-    rest = rest.slice(0, splitPointIdx);
-    let combinatorIdx = rest.findIndex((n)=>n.type === "combinator" && n.value === ">");
-    if (combinatorIdx !== -1) {
-        rest.splice(0, combinatorIdx);
-        rest.unshift(_postcssselectorparser.default.universal());
-    }
-    return [
-        bestNode,
-        ...rest.reverse()
-    ].join("").trim();
-}
-let elementSelectorParser = (0, _postcssselectorparser.default)((selectors)=>{
-    return selectors.map((s)=>{
-        let nodes = s.split((n)=>n.type === "combinator" && n.value === " ").pop();
-        return minimumImpactSelector(nodes);
-    });
-});
-let cache = new Map();
-function extractElementSelector(selector) {
-    if (!cache.has(selector)) {
-        cache.set(selector, elementSelectorParser.transformSync(selector));
-    }
-    return cache.get(selector);
-}
-function resolveDefaultsAtRules({ tailwindConfig  }) {
-    return (root)=>{
-        let variableNodeMap = new Map();
-        /** @type {Set<import('postcss').AtRule>} */ let universals = new Set();
-        root.walkAtRules("defaults", (rule)=>{
-            if (rule.nodes && rule.nodes.length > 0) {
-                universals.add(rule);
-                return;
-            }
-            let variable = rule.params;
-            if (!variableNodeMap.has(variable)) {
-                variableNodeMap.set(variable, new Set());
-            }
-            variableNodeMap.get(variable).add(rule.parent);
-            rule.remove();
-        });
-        if ((0, _featureFlags.flagEnabled)(tailwindConfig, "optimizeUniversalDefaults")) {
-            for (let universal of universals){
-                /** @type {Map<string, Set<string>>} */ let selectorGroups = new Map();
-                var _variableNodeMap_get;
-                let rules = (_variableNodeMap_get = variableNodeMap.get(universal.params)) !== null && _variableNodeMap_get !== void 0 ? _variableNodeMap_get : [];
-                for (let rule of rules){
-                    for (let selector of extractElementSelector(rule.selector)){
-                        // If selector contains a vendor prefix after a pseudo element or class,
-                        // we consider them separately because merging the declarations into
-                        // a single rule will cause browsers that do not understand the
-                        // vendor prefix to throw out the whole rule
-                        let selectorGroupName = selector.includes(":-") || selector.includes("::-") ? selector : "__DEFAULT__";
-                        var _selectorGroups_get;
-                        let selectors = (_selectorGroups_get = selectorGroups.get(selectorGroupName)) !== null && _selectorGroups_get !== void 0 ? _selectorGroups_get : new Set();
-                        selectorGroups.set(selectorGroupName, selectors);
-                        selectors.add(selector);
-                    }
-                }
-                if ((0, _featureFlags.flagEnabled)(tailwindConfig, "optimizeUniversalDefaults")) {
-                    if (selectorGroups.size === 0) {
-                        universal.remove();
-                        continue;
-                    }
-                    for (let [, selectors] of selectorGroups){
-                        let universalRule = _postcss.default.rule({
-                            source: universal.source
-                        });
-                        universalRule.selectors = [
-                            ...selectors
-                        ];
-                        universalRule.append(universal.nodes.map((node)=>node.clone()));
-                        universal.before(universalRule);
-                    }
-                }
-                universal.remove();
-            }
-        } else if (universals.size) {
-            let universalRule = _postcss.default.rule({
-                selectors: [
-                    "*",
-                    "::before",
-                    "::after"
-                ]
-            });
-            for (let universal of universals){
-                universalRule.append(universal.nodes);
-                if (!universalRule.parent) {
-                    universal.before(universalRule);
-                }
-                if (!universalRule.source) {
-                    universalRule.source = universal.source;
-                }
-                universal.remove();
-            }
-            let backdropRule = universalRule.clone({
-                selectors: [
-                    "::backdrop"
-                ]
-            });
-            universalRule.after(backdropRule);
-        }
-    };
-}