tailwindcss 0.0.0-oxide-insiders.dddaded → 0.0.0-oxide-insiders.b2e3cf2

package/lib/util/flattenColorPalette.js

@@ -1,16 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "default", {
-    enumerable: true,
+    value: !0
+}), Object.defineProperty(exports, "default", {
+    enumerable: !0,
     get: ()=>_default
 });
-const flattenColorPalette = (colors)=>Object.assign({}, ...Object.entries(colors !== null && colors !== void 0 ? colors : {}).flatMap(([color, values])=>typeof values == "object" ? Object.entries(flattenColorPalette(values)).map(([number, hex])=>({
-                [color + (number === "DEFAULT" ? "" : `-${number}`)]: hex
+const flattenColorPalette = (colors)=>Object.assign({}, ...Object.entries(null != colors ? colors : {}).flatMap(([color, values])=>"object" == typeof values ? Object.entries(flattenColorPalette(values)).map(([number, hex])=>({
+                [color + ("DEFAULT" === number ? "" : `-${number}`)]: hex
             })) : [
             {
                 [`${color}`]: values
             }
-        ]));
-const _default = flattenColorPalette;
+        ])), _default = flattenColorPalette;

package/lib/util/formatVariantSelector.js

@@ -1,43 +1,33 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
+    value: !0
+}), function(target, all) {
     for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
+        enumerable: !0,
         get: all[name]
     });
-}
-_export(exports, {
+}(exports, {
     formatVariantSelector: ()=>formatVariantSelector,
     eliminateIrrelevantSelectors: ()=>eliminateIrrelevantSelectors,
     finalizeSelector: ()=>finalizeSelector,
     handleMergePseudo: ()=>handleMergePseudo
 });
-const _postcssSelectorParser = /*#__PURE__*/ _interopRequireDefault(require("postcss-selector-parser"));
-const _unesc = /*#__PURE__*/ _interopRequireDefault(require("postcss-selector-parser/dist/util/unesc"));
-const _escapeClassName = /*#__PURE__*/ _interopRequireDefault(require("../util/escapeClassName"));
-const _prefixSelector = /*#__PURE__*/ _interopRequireDefault(require("../util/prefixSelector"));
-const _pseudoElements = require("./pseudoElements");
+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) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
 }
-/** @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";
+let MERGE = ":merge";
 function formatVariantSelector(formats, { context , candidate  }) {
     var _context_tailwindConfig_prefix;
-    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 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);
         return {
             ...format,
             ast: format.isArbitraryVariant ? ast : (0, _prefixSelector.default)(prefix, ast)
         };
-    });
-    // We start with the candidate selector
-    let formatAst = _postcssSelectorParser.default.root({
+    }), formatAst = _postcssSelectorParser.default.root({
         nodes: [
             _postcssSelectorParser.default.selector({
                 nodes: [
@@ -48,207 +38,76 @@ function formatVariantSelector(formats, { context , candidate  }) {
             })
         ]
     });
-    // 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;
-    }
+    for (let { ast  } of parsedFormats)[formatAst, ast] = handleMergePseudo(formatAst, ast), ast.walkNesting((nesting)=>nesting.replaceWith(...formatAst.nodes[0].nodes)), formatAst = ast;
     return formatAst;
 }
-/**
- * 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();
-    }
+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();
     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 = false;
+    let hasClassesMatchingCandidate = !1;
     sel.walk((child)=>{
-        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?
+        if ("class" === child.type && child.value === base) return hasClassesMatchingCandidate = !0, !1;
+    }), hasClassesMatchingCandidate || sel.remove();
 }
 function finalizeSelector(current, formats, { context , candidate , base  }) {
-    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
+    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);
-    // 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)=>{
-        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
+        node.raws && node.value.includes(base) && (node.raws.value = (0, _escapeClassName.default)((0, _unesc.default)(node.raws.value)));
+    }), selector.each((sel)=>eliminateIrrelevantSelectors(sel, base));
     let formatAst = Array.isArray(formats) ? formatVariantSelector(formats, {
         context,
         candidate
     }) : formats;
-    if (formatAst === null) {
-        return selector.toString();
-    }
+    if (null === formatAst) return selector.toString();
     let simpleStart = _postcssSelectorParser.default.comment({
         value: "/*__simple__*/"
-    });
-    let simpleEnd = _postcssSelectorParser.default.comment({
+    }), simpleEnd = _postcssSelectorParser.default.comment({
         value: "/*__simple__*/"
     });
-    // 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) {
+    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) {
             node.replaceWith(...formatNodes);
             return;
         }
         let simpleSelector = simpleSelectorForNode(node);
-        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);
+        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);
         let firstNode = parent.index(simpleStart);
-        parent.nodes.splice(firstNode, simpleSelector.length, ...resortSelector(_postcssSelectorParser.default.selector({
+        parent.nodes.splice(firstNode, simpleSelector.length, ...((sel = _postcssSelectorParser.default.selector({
             nodes: simpleSelector
-        })).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();
+        })).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();
 }
 function handleMergePseudo(selector, format) {
-    /** @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 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();
         let combinator = next;
         existing.pseudo.parent.insertAfter(existing.pseudo, _postcssSelectorParser.default.selector({
             nodes: attachments.map((node)=>node.clone())
-        }));
-        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 [
+        })), pseudo.remove(), attachments.forEach((node)=>node.remove()), combinator && "combinator" === combinator.type && combinator.remove();
+    }), [
         selector,
         format
     ];

package/lib/util/getAllConfigs.js

@@ -1,48 +1,41 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "default", {
-    enumerable: true,
-    get: ()=>getAllConfigs
+    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
+            ];
+        }
 });
-const _configFullJs = /*#__PURE__*/ _interopRequireDefault(require("../../stubs/config.full.js"));
-const _featureFlags = require("../featureFlags");
-function _interopRequireDefault(obj) {
+const _configFullJs = function(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 : [
-        _configFullJs.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
-    ];
-}
+}(require("../../stubs/config.full.js")), _featureFlags = require("../featureFlags");

package/lib/util/hashConfig.js

@@ -1,19 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "default", {
-    enumerable: true,
+    value: !0
+}), Object.defineProperty(exports, "default", {
+    enumerable: !0,
     get: ()=>hashConfig
 });
-const _objectHash = /*#__PURE__*/ _interopRequireDefault(require("object-hash"));
-function _interopRequireDefault(obj) {
+const _objectHash = function(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
-}
+}(require("object-hash"));
 function hashConfig(config) {
     return (0, _objectHash.default)(config, {
-        ignoreUnknown: true
+        ignoreUnknown: !0
     });
 }

package/lib/util/isKeyframeRule.js

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

package/lib/util/isPlainObject.js

@@ -1,15 +1,12 @@
 "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: true
-});
-Object.defineProperty(exports, "default", {
-    enumerable: true,
+    value: !0
+}), Object.defineProperty(exports, "default", {
+    enumerable: !0,
     get: ()=>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,15 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", {
-    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,
+    value: !0
+}), Object.defineProperty(exports, "default", {
+    enumerable: !0,
     get: ()=>isSyntacticallyValidPropertyValue
 });
 let matchingBrackets = new Map([
@@ -25,48 +18,26 @@ let matchingBrackets = new Map([
         "(",
         ")"
     ]
-]);
-let inverseMatchingBrackets = new Map(Array.from(matchingBrackets.entries()).map(([k, v])=>[
+]), inverseMatchingBrackets = new Map(Array.from(matchingBrackets.entries()).map(([k, v])=>[
         v,
         k
-    ]));
-let quotes = new Set([
+    ])), quotes = new Set([
     '"',
     "'",
     "`"
 ]);
 function isSyntacticallyValidPropertyValue(value) {
-    let stack = [];
-    let inQuotes = false;
+    let stack = [], inQuotes = !1;
     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 (":" === 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 there is still something on the stack, it is also unbalanced
-    if (stack.length > 0) {
-        return false;
-    }
-    // All good, totally balanced!
-    return true;
+    return !(stack.length > 0);
 }

package/lib/util/log.js

@@ -1,30 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
+    value: !0
+}), function(target, all) {
     for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
+        enumerable: !0,
         get: all[name]
     });
-}
-_export(exports, {
+}(exports, {
     dim: ()=>dim,
     default: ()=>_default
 });
-const _picocolors = /*#__PURE__*/ _interopRequireDefault(require("picocolors"));
-function _interopRequireDefault(obj) {
+const _picocolors = function(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
-}
+}(require("picocolors"));
 let alreadyShown = new Set();
 function log(type, messages, key) {
-    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));
+    ("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))));
 }
 function dim(input) {
     return _picocolors.default.dim(input);

package/lib/util/nameClass.js

@@ -1,20 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
+    value: !0
+}), function(target, all) {
     for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
+        enumerable: !0,
         get: all[name]
     });
-}
-_export(exports, {
+}(exports, {
     asClass: ()=>asClass,
     default: ()=>nameClass,
     formatClass: ()=>formatClass
 });
-const _escapeClassName = /*#__PURE__*/ _interopRequireDefault(require("./escapeClassName"));
-const _escapeCommas = /*#__PURE__*/ _interopRequireDefault(require("./escapeCommas"));
+const _escapeClassName = _interopRequireDefault(require("./escapeClassName")), _escapeCommas = _interopRequireDefault(require("./escapeCommas"));
 function _interopRequireDefault(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -27,17 +24,5 @@ function nameClass(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}`;
-    }
-    if (key.startsWith("/")) {
-        return `${classPrefix}${key}`;
-    }
-    return `${classPrefix}-${key}`;
+    return "DEFAULT" === key ? classPrefix : "-" === key || "-DEFAULT" === key ? `-${classPrefix}` : key.startsWith("-") ? `-${classPrefix}${key}` : key.startsWith("/") ? `${classPrefix}${key}` : `${classPrefix}-${key}`;
 }