tailwindcss 0.0.0-oxide-insiders.a7fe2fe → 0.0.0-oxide-insiders.7f555c4

package/lib/util/formatVariantSelector.js

@@ -1,113 +1,262 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", {
-    value: !0
-}), function(target, all) {
+    value: true
+});
+function _export(target, all) {
     for(var name in all)Object.defineProperty(target, name, {
-        enumerable: !0,
+        enumerable: true,
         get: all[name]
     });
-}(exports, {
-    formatVariantSelector: ()=>formatVariantSelector,
-    eliminateIrrelevantSelectors: ()=>eliminateIrrelevantSelectors,
-    finalizeSelector: ()=>finalizeSelector,
-    handleMergePseudo: ()=>handleMergePseudo
+}
+_export(exports, {
+    formatVariantSelector: function() {
+        return formatVariantSelector;
+    },
+    eliminateIrrelevantSelectors: function() {
+        return eliminateIrrelevantSelectors;
+    },
+    finalizeSelector: function() {
+        return finalizeSelector;
+    },
+    handleMergePseudo: function() {
+        return handleMergePseudo;
+    }
 });
-const _postcssSelectorParser = _interopRequireDefault(require("postcss-selector-parser")), _unesc = _interopRequireDefault(require("postcss-selector-parser/dist/util/unesc")), _escapeClassName = _interopRequireDefault(require("../util/escapeClassName")), _prefixSelector = _interopRequireDefault(require("../util/prefixSelector")), _pseudoElements = require("./pseudoElements");
-function _interopRequireDefault(obj) {
+const _postcssselectorparser = /*#__PURE__*/ _interop_require_default(require("postcss-selector-parser"));
+const _unesc = /*#__PURE__*/ _interop_require_default(require("postcss-selector-parser/dist/util/unesc"));
+const _escapeClassName = /*#__PURE__*/ _interop_require_default(require("../util/escapeClassName"));
+const _prefixSelector = /*#__PURE__*/ _interop_require_default(require("../util/prefixSelector"));
+const _pseudoElements = require("./pseudoElements");
+function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
 }
-let MERGE = ":merge";
+/** @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 */ /** @typedef {{format: string, isArbitraryVariant: boolean}[]} RawFormats */ /** @typedef {import('postcss-selector-parser').Root} ParsedFormats */ /** @typedef {RawFormats | ParsedFormats} AcceptedFormats */ let MERGE = ":merge";
 function formatVariantSelector(formats, { context , candidate  }) {
     var _context_tailwindConfig_prefix;
-    let prefix = null !== (_context_tailwindConfig_prefix = null == context ? void 0 : context.tailwindConfig.prefix) && void 0 !== _context_tailwindConfig_prefix ? _context_tailwindConfig_prefix : "", parsedFormats = formats.map((format)=>{
-        let ast = (0, _postcssSelectorParser.default)().astSync(format.format);
+    let prefix = (_context_tailwindConfig_prefix = context === null || context === void 0 ? void 0 : context.tailwindConfig.prefix) !== null && _context_tailwindConfig_prefix !== void 0 ? _context_tailwindConfig_prefix : "";
+    // Parse the format selector into an AST
+    let parsedFormats = formats.map((format)=>{
+        let ast = (0, _postcssselectorparser.default)().astSync(format.format);
         return {
             ...format,
             ast: format.isArbitraryVariant ? ast : (0, _prefixSelector.default)(prefix, ast)
         };
-    }), formatAst = _postcssSelectorParser.default.root({
+    });
+    // We start with the candidate selector
+    let formatAst = _postcssselectorparser.default.root({
         nodes: [
-            _postcssSelectorParser.default.selector({
+            _postcssselectorparser.default.selector({
                 nodes: [
-                    _postcssSelectorParser.default.className({
+                    _postcssselectorparser.default.className({
                         value: (0, _escapeClassName.default)(candidate)
                     })
                 ]
             })
         ]
     });
-    for (let { ast  } of parsedFormats)[formatAst, ast] = handleMergePseudo(formatAst, ast), ast.walkNesting((nesting)=>nesting.replaceWith(...formatAst.nodes[0].nodes)), formatAst = ast;
+    // And iteratively merge each format selector into the candidate selector
+    for (let { ast  } of parsedFormats){
+        [formatAst, ast] = handleMergePseudo(formatAst, ast);
+        // 2. Merge the format selector into the current selector AST
+        ast.walkNesting((nesting)=>nesting.replaceWith(...formatAst.nodes[0].nodes));
+        // 3. Keep going!
+        formatAst = ast;
+    }
     return formatAst;
 }
-function simpleSelectorForNode(node) {
-    let nodes = [];
-    for(; node.prev() && "combinator" !== node.prev().type;)node = node.prev();
-    for(; node && "combinator" !== node.type;)nodes.push(node), node = node.next();
+/**
+ * Given any node in a selector this gets the "simple" selector it's a part of
+ * A simple selector is just a list of nodes without any combinators
+ * Technically :is(), :not(), :has(), etc… can have combinators but those are nested
+ * inside the relevant node and won't be picked up so they're fine to ignore
+ *
+ * @param {Node} node
+ * @returns {Node[]}
+ **/ function simpleSelectorForNode(node) {
+    /** @type {Node[]} */ let nodes = [];
+    // Walk backwards until we hit a combinator node (or the start)
+    while(node.prev() && node.prev().type !== "combinator"){
+        node = node.prev();
+    }
+    // Now record all non-combinator nodes until we hit one (or the end)
+    while(node && node.type !== "combinator"){
+        nodes.push(node);
+        node = node.next();
+    }
     return nodes;
 }
+/**
+ * Resorts the nodes in a selector to ensure they're in the correct order
+ * Tags go before classes, and pseudo classes go after classes
+ *
+ * @param {Selector} sel
+ * @returns {Selector}
+ **/ function resortSelector(sel) {
+    sel.sort((a, b)=>{
+        if (a.type === "tag" && b.type === "class") {
+            return -1;
+        } else if (a.type === "class" && b.type === "tag") {
+            return 1;
+        } else if (a.type === "class" && b.type === "pseudo" && b.value.startsWith("::")) {
+            return -1;
+        } else if (a.type === "pseudo" && a.value.startsWith("::") && b.type === "class") {
+            return 1;
+        }
+        return sel.index(a) - sel.index(b);
+    });
+    return sel;
+}
 function eliminateIrrelevantSelectors(sel, base) {
-    let hasClassesMatchingCandidate = !1;
+    let hasClassesMatchingCandidate = false;
     sel.walk((child)=>{
-        if ("class" === child.type && child.value === base) return hasClassesMatchingCandidate = !0, !1;
-    }), hasClassesMatchingCandidate || sel.remove();
+        if (child.type === "class" && child.value === base) {
+            hasClassesMatchingCandidate = true;
+            return false // Stop walking
+            ;
+        }
+    });
+    if (!hasClassesMatchingCandidate) {
+        sel.remove();
+    }
+// We do NOT recursively eliminate sub selectors that don't have the base class
+// as this is NOT a safe operation. For example, if we have:
+// `.space-x-2 > :not([hidden]) ~ :not([hidden])`
+// We cannot remove the [hidden] from the :not() because it would change the
+// meaning of the selector.
+// TODO: Can we do this for :matches, :is, and :where?
 }
 function finalizeSelector(current, formats, { context , candidate , base  }) {
-    var _context_tailwindConfig, _context_tailwindConfig_separator;
-    let separator = null !== (_context_tailwindConfig_separator = null == context ? void 0 : null === (_context_tailwindConfig = context.tailwindConfig) || void 0 === _context_tailwindConfig ? void 0 : _context_tailwindConfig.separator) && void 0 !== _context_tailwindConfig_separator ? _context_tailwindConfig_separator : ":";
-    base = null != base ? base : candidate.split(RegExp(`\\${separator}(?![^[]*\\])`)).pop();
-    let selector = (0, _postcssSelectorParser.default)().astSync(current);
+    var _context_tailwindConfig;
+    var _context_tailwindConfig_separator;
+    let separator = (_context_tailwindConfig_separator = context === null || context === void 0 ? void 0 : (_context_tailwindConfig = context.tailwindConfig) === null || _context_tailwindConfig === void 0 ? void 0 : _context_tailwindConfig.separator) !== null && _context_tailwindConfig_separator !== void 0 ? _context_tailwindConfig_separator : ":";
+    // 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
+    //
+    base = base !== null && base !== void 0 ? base : candidate.split(new RegExp(`\\${separator}(?![^[]*\\])`)).pop();
+    // Parse the selector into an AST
+    let selector = (0, _postcssselectorparser.default)().astSync(current);
+    // 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\\)\\]
+    //
     selector.walkClasses((node)=>{
-        node.raws && node.value.includes(base) && (node.raws.value = (0, _escapeClassName.default)((0, _unesc.default)(node.raws.value)));
-    }), selector.each((sel)=>eliminateIrrelevantSelectors(sel, base));
+        if (node.raws && node.value.includes(base)) {
+            node.raws.value = (0, _escapeClassName.default)((0, _unesc.default)(node.raws.value));
+        }
+    });
+    // Remove extraneous selectors that do not include the base candidate
+    selector.each((sel)=>eliminateIrrelevantSelectors(sel, base));
+    // If there are no formats that means there were no variants added to the candidate
+    // so we can just return the selector as-is
     let formatAst = Array.isArray(formats) ? formatVariantSelector(formats, {
         context,
         candidate
     }) : formats;
-    if (null === formatAst) return selector.toString();
-    let simpleStart = _postcssSelectorParser.default.comment({
+    if (formatAst === null) {
+        return selector.toString();
+    }
+    let simpleStart = _postcssselectorparser.default.comment({
         value: "/*__simple__*/"
-    }), simpleEnd = _postcssSelectorParser.default.comment({
+    });
+    let simpleEnd = _postcssselectorparser.default.comment({
         value: "/*__simple__*/"
     });
-    return selector.walkClasses((node)=>{
-        var sel;
-        if (node.value !== base) return;
-        let parent = node.parent, formatNodes = formatAst.nodes[0].nodes;
-        if (1 === parent.nodes.length) {
+    // We can safely replace the escaped base now, since the `base` section is
+    // now in a normalized escaped value.
+    selector.walkClasses((node)=>{
+        if (node.value !== base) {
+            return;
+        }
+        let parent = node.parent;
+        let formatNodes = formatAst.nodes[0].nodes;
+        // Perf optimization: if the parent is a single class we can just replace it and be done
+        if (parent.nodes.length === 1) {
             node.replaceWith(...formatNodes);
             return;
         }
         let simpleSelector = simpleSelectorForNode(node);
-        for (let child of (parent.insertBefore(simpleSelector[0], simpleStart), parent.insertAfter(simpleSelector[simpleSelector.length - 1], simpleEnd), formatNodes))parent.insertBefore(simpleSelector[0], child.clone());
-        node.remove(), simpleSelector = simpleSelectorForNode(simpleStart);
+        parent.insertBefore(simpleSelector[0], simpleStart);
+        parent.insertAfter(simpleSelector[simpleSelector.length - 1], simpleEnd);
+        for (let child of formatNodes){
+            parent.insertBefore(simpleSelector[0], child.clone());
+        }
+        node.remove();
+        // Re-sort the simple selector to ensure it's in the correct order
+        simpleSelector = simpleSelectorForNode(simpleStart);
         let firstNode = parent.index(simpleStart);
-        parent.nodes.splice(firstNode, simpleSelector.length, ...((sel = _postcssSelectorParser.default.selector({
+        parent.nodes.splice(firstNode, simpleSelector.length, ...resortSelector(_postcssselectorparser.default.selector({
             nodes: simpleSelector
-        })).sort((a, b)=>"tag" === a.type && "class" === b.type ? -1 : "class" === a.type && "tag" === b.type ? 1 : "class" === a.type && "pseudo" === b.type && b.value.startsWith("::") ? -1 : "pseudo" === a.type && a.value.startsWith("::") && "class" === b.type ? 1 : sel.index(a) - sel.index(b)), sel).nodes), simpleStart.remove(), simpleEnd.remove();
-    }), selector.walkPseudos((p)=>{
-        p.value === MERGE && p.replaceWith(p.nodes);
-    }), selector.each((sel)=>(0, _pseudoElements.movePseudos)(sel)), selector.toString();
+        })).nodes);
+        simpleStart.remove();
+        simpleEnd.remove();
+    });
+    // Remove unnecessary pseudo selectors that we used as placeholders
+    selector.walkPseudos((p)=>{
+        if (p.value === MERGE) {
+            p.replaceWith(p.nodes);
+        }
+    });
+    // Move pseudo elements to the end of the selector (if necessary)
+    selector.each((sel)=>(0, _pseudoElements.movePseudos)(sel));
+    return selector.toString();
 }
 function handleMergePseudo(selector, format) {
-    let merges = [];
-    return selector.walkPseudos((pseudo)=>{
-        pseudo.value === MERGE && merges.push({
-            pseudo,
-            value: pseudo.nodes[0].toString()
-        });
-    }), format.walkPseudos((pseudo)=>{
-        if (pseudo.value !== MERGE) return;
-        let value = pseudo.nodes[0].toString(), existing = merges.find((merge)=>merge.value === value);
-        if (!existing) return;
-        let attachments = [], next = pseudo.next();
-        for(; next && "combinator" !== next.type;)attachments.push(next), next = next.next();
+    /** @type {{pseudo: Pseudo, value: string}[]} */ let merges = [];
+    // Find all :merge() pseudo-classes in `selector`
+    selector.walkPseudos((pseudo)=>{
+        if (pseudo.value === MERGE) {
+            merges.push({
+                pseudo,
+                value: pseudo.nodes[0].toString()
+            });
+        }
+    });
+    // Find all :merge() "attachments" in `format` and attach them to the matching selector in `selector`
+    format.walkPseudos((pseudo)=>{
+        if (pseudo.value !== MERGE) {
+            return;
+        }
+        let value = pseudo.nodes[0].toString();
+        // Does `selector` contain a :merge() pseudo-class with the same value?
+        let existing = merges.find((merge)=>merge.value === value);
+        // Nope so there's nothing to do
+        if (!existing) {
+            return;
+        }
+        // Everything after `:merge()` up to the next combinator is what is attached to the merged selector
+        let attachments = [];
+        let next = pseudo.next();
+        while(next && next.type !== "combinator"){
+            attachments.push(next);
+            next = next.next();
+        }
         let combinator = next;
-        existing.pseudo.parent.insertAfter(existing.pseudo, _postcssSelectorParser.default.selector({
+        existing.pseudo.parent.insertAfter(existing.pseudo, _postcssselectorparser.default.selector({
             nodes: attachments.map((node)=>node.clone())
-        })), pseudo.remove(), attachments.forEach((node)=>node.remove()), combinator && "combinator" === combinator.type && combinator.remove();
-    }), [
+        }));
+        pseudo.remove();
+        attachments.forEach((node)=>node.remove());
+        // What about this case:
+        // :merge(.group):focus > &
+        // :merge(.group):hover &
+        if (combinator && combinator.type === "combinator") {
+            combinator.remove();
+        }
+    });
+    return [
         selector,
         format
     ];

package/lib/util/getAllConfigs.js

@@ -1,41 +1,50 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", {
-    value: !0
-}), Object.defineProperty(exports, "default", {
-    enumerable: !0,
-    get: ()=>function getAllConfigs(config) {
-            var _config_presets;
-            let configs = (null !== (_config_presets = null == config ? void 0 : config.presets) && void 0 !== _config_presets ? _config_presets : [
-                _configFullJs.default
-            ]).slice().reverse().flatMap((preset)=>getAllConfigs(preset instanceof Function ? preset() : preset)), features = {
-                respectDefaultRingColorOpacity: {
-                    theme: {
-                        ringColor: ({ theme  })=>({
-                                DEFAULT: "#3b82f67f",
-                                ...theme("colors")
-                            })
-                    }
-                },
-                disableColorOpacityUtilitiesByDefault: {
-                    corePlugins: {
-                        backgroundOpacity: !1,
-                        borderOpacity: !1,
-                        divideOpacity: !1,
-                        placeholderOpacity: !1,
-                        ringOpacity: !1,
-                        textOpacity: !1
-                    }
-                }
-            }, experimentals = Object.keys(features).filter((feature)=>(0, _featureFlags.flagEnabled)(config, feature)).map((feature)=>features[feature]);
-            return [
-                config,
-                ...experimentals,
-                ...configs
-            ];
-        }
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return getAllConfigs;
+    }
 });
-const _configFullJs = function(obj) {
+const _configfull = /*#__PURE__*/ _interop_require_default(require("../../stubs/config.full.js"));
+const _featureFlags = require("../featureFlags");
+function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
-}(require("../../stubs/config.full.js")), _featureFlags = require("../featureFlags");
+}
+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 : [
+        _configfull.default
+    ]).slice().reverse().flatMap((preset)=>getAllConfigs(preset instanceof Function ? preset() : preset));
+    const features = {
+        // Add experimental configs here...
+        respectDefaultRingColorOpacity: {
+            theme: {
+                ringColor: ({ theme  })=>({
+                        DEFAULT: "#3b82f67f",
+                        ...theme("colors")
+                    })
+            }
+        },
+        disableColorOpacityUtilitiesByDefault: {
+            corePlugins: {
+                backgroundOpacity: false,
+                borderOpacity: false,
+                divideOpacity: false,
+                placeholderOpacity: false,
+                ringOpacity: false,
+                textOpacity: false
+            }
+        }
+    };
+    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,17 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", {
-    value: !0
-}), Object.defineProperty(exports, "default", {
-    enumerable: !0,
-    get: ()=>hashConfig
+    value: true
 });
-const _objectHash = function(obj) {
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return hashConfig;
+    }
+});
+const _objecthash = /*#__PURE__*/ _interop_require_default(require("object-hash"));
+function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
-}(require("object-hash"));
+}
 function hashConfig(config) {
-    return (0, _objectHash.default)(config, {
-        ignoreUnknown: !0
+    return (0, _objecthash.default)(config, {
+        ignoreUnknown: true
     });
 }

package/lib/util/isKeyframeRule.js

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

package/lib/util/isPlainObject.js

@@ -1,12 +1,17 @@
 "use strict";
-function isPlainObject(value) {
-    if ("[object Object]" !== Object.prototype.toString.call(value)) return !1;
-    let prototype = Object.getPrototypeOf(value);
-    return null === prototype || prototype === Object.prototype;
-}
 Object.defineProperty(exports, "__esModule", {
-    value: !0
-}), Object.defineProperty(exports, "default", {
-    enumerable: !0,
-    get: ()=>isPlainObject
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return 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;
+}

package/lib/util/isSyntacticallyValidPropertyValue.js

@@ -1,9 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", {
-    value: !0
-}), Object.defineProperty(exports, "default", {
-    enumerable: !0,
-    get: ()=>isSyntacticallyValidPropertyValue
+    value: true
+});
+Object.defineProperty(exports, // Arbitrary values must contain balanced brackets (), [] and {}. Escaped
+// values don't count, and brackets inside quotes also don't count.
+//
+// E.g.: w-[this-is]w-[weird-and-invalid]
+// E.g.: w-[this-is\\]w-\\[weird-but-valid]
+// E.g.: content-['this-is-also-valid]-weirdly-enough']
+"default", {
+    enumerable: true,
+    get: function() {
+        return isSyntacticallyValidPropertyValue;
+    }
 });
 let matchingBrackets = new Map([
     [
@@ -18,26 +27,48 @@ let matchingBrackets = new Map([
         "(",
         ")"
     ]
-]), inverseMatchingBrackets = new Map(Array.from(matchingBrackets.entries()).map(([k, v])=>[
+]);
+let inverseMatchingBrackets = new Map(Array.from(matchingBrackets.entries()).map(([k, v])=>[
         v,
         k
-    ])), quotes = new Set([
+    ]));
+let quotes = new Set([
     '"',
     "'",
     "`"
 ]);
 function isSyntacticallyValidPropertyValue(value) {
-    let stack = [], inQuotes = !1;
+    let stack = [];
+    let inQuotes = false;
     for(let i = 0; i < value.length; i++){
         let char = value[i];
-        if (":" === char && !inQuotes && 0 === stack.length) return !1;
-        if (quotes.has(char) && "\\" !== value[i - 1] && (inQuotes = !inQuotes), !inQuotes && "\\" !== value[i - 1]) {
-            if (matchingBrackets.has(char)) stack.push(char);
-            else if (inverseMatchingBrackets.has(char)) {
-                let inverse = inverseMatchingBrackets.get(char);
-                if (stack.length <= 0 || stack.pop() !== inverse) return !1;
+        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;
             }
         }
     }
-    return !(stack.length > 0);
+    // 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,23 +1,34 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", {
-    value: !0
-}), function(target, all) {
+    value: true
+});
+function _export(target, all) {
     for(var name in all)Object.defineProperty(target, name, {
-        enumerable: !0,
+        enumerable: true,
         get: all[name]
     });
-}(exports, {
-    dim: ()=>dim,
-    default: ()=>_default
+}
+_export(exports, {
+    dim: function() {
+        return dim;
+    },
+    default: function() {
+        return _default;
+    }
 });
-const _picocolors = function(obj) {
+const _picocolors = /*#__PURE__*/ _interop_require_default(require("picocolors"));
+function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
-}(require("picocolors"));
+}
 let alreadyShown = new Set();
 function log(type, messages, key) {
-    ("undefined" == typeof process || !process.env.JEST_WORKER_ID) && (key && alreadyShown.has(key) || (key && alreadyShown.add(key), console.warn(""), messages.forEach((message)=>console.warn(type, "-", message))));
+    if (typeof process !== "undefined" && process.env.JEST_WORKER_ID) return;
+    if (key && alreadyShown.has(key)) return;
+    if (key) alreadyShown.add(key);
+    console.warn("");
+    messages.forEach((message)=>console.warn(type, "-", message));
 }
 function dim(input) {
     return _picocolors.default.dim(input);