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

package/lib/util/formatVariantSelector.js

@@ -2,24 +2,32 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-exports.formatVariantSelector = formatVariantSelector;
-exports.finalizeSelector = finalizeSelector;
-exports.selectorFunctions = void 0;
-var _postcssSelectorParser = _interopRequireDefault(require("postcss-selector-parser"));
-var _unesc = _interopRequireDefault(require("postcss-selector-parser/dist/util/unesc"));
-var _escapeClassName = _interopRequireDefault(require("../util/escapeClassName"));
-var _prefixSelector = _interopRequireDefault(require("../util/prefixSelector"));
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    selectorFunctions: ()=>selectorFunctions,
+    formatVariantSelector: ()=>formatVariantSelector,
+    finalizeSelector: ()=>finalizeSelector
+});
+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"));
 function _interopRequireDefault(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
 }
-let MERGE = ':merge';
-let PARENT = '&';
+var ref;
+let MERGE = ":merge";
+let PARENT = "&";
 let selectorFunctions = new Set([
     MERGE
 ]);
-exports.selectorFunctions = selectorFunctions;
 function formatVariantSelector(current, ...others) {
     for (let other of others){
         let incomingValue = resolveFunctionArgument(other, MERGE);
@@ -28,7 +36,7 @@ function formatVariantSelector(current, ...others) {
             if (existingValue !== null) {
                 let existingTarget = `${MERGE}(${incomingValue})`;
                 let splitIdx = other.indexOf(existingTarget);
-                let addition = other.slice(splitIdx + existingTarget.length).split(' ')[0];
+                let addition = other.slice(splitIdx + existingTarget.length).split(" ")[0];
                 current = current.replace(existingTarget, existingTarget + addition);
                 continue;
             }
@@ -37,23 +45,88 @@ function formatVariantSelector(current, ...others) {
     }
     return current;
 }
-function finalizeSelector(format, { selector: selector1 , candidate , context  }) {
-    var ref, ref1;
+/**
+ * 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 {import('postcss-selector-parser').Node} node
+ * @returns {import('postcss-selector-parser').Node[]}
+ **/ function simpleSelectorForNode(node) {
+    /** @type {import('postcss-selector-parser').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 {import('postcss-selector-parser').Selector} sel
+ * @returns {import('postcss-selector-parser').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;
+    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?
+}
+var ref1;
+function finalizeSelector(format, { selector , candidate , context , isArbitraryVariant , // 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 =candidate.split(new RegExp(`\\${(ref1 = context === null || context === void 0 ? void 0 : (ref = context.tailwindConfig) === null || ref === void 0 ? void 0 : ref.separator) !== null && ref1 !== void 0 ? ref1 : ":"}(?![^[]*\\])`)).pop()  }) {
     var ref2;
-    let separator = (ref2 = context === null || context === void 0 ? void 0 : (ref = context.tailwindConfig) === null || ref === void 0 ? void 0 : ref.separator) !== null && ref2 !== void 0 ? ref2 : ':';
-    // 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
-    //
-    let splitter = new RegExp(`\\${separator}(?![^[]*\\])`);
-    let base = candidate.split(splitter).pop();
-    if (context === null || context === void 0 ? void 0 : (ref1 = context.tailwindConfig) === null || ref1 === void 0 ? void 0 : ref1.prefix) {
-        format = (0, _prefixSelector).default(context.tailwindConfig.prefix, format);
+    let ast = (0, _postcssSelectorParser.default)().astSync(selector);
+    // We explicitly DO NOT prefix classes in arbitrary variants
+    if ((context === null || context === void 0 ? void 0 : (ref2 = context.tailwindConfig) === null || ref2 === void 0 ? void 0 : ref2.prefix) && !isArbitraryVariant) {
+        format = (0, _prefixSelector.default)(context.tailwindConfig.prefix, format);
     }
-    format = format.replace(PARENT, `.${(0, _escapeClassName).default(candidate)}`);
+    format = format.replace(PARENT, `.${(0, _escapeClassName.default)(candidate)}`);
+    let formatAst = (0, _postcssSelectorParser.default)().astSync(format);
+    // Remove extraneous selectors that do not include the base class/candidate being matched against
+    // For example if we have a utility defined `.a, .b { color: red}`
+    // And the formatted variant is sm:b then we want the final selector to be `.sm\:b` and not `.a, .sm\:b`
+    ast.each((sel)=>eliminateIrrelevantSelectors(sel, base));
     // Normalize escaped classes, e.g.:
     //
     // The idea would be to replace the escaped `base` in the selector with the
@@ -65,69 +138,95 @@ function finalizeSelector(format, { selector: selector1 , candidate , context  }
     //   base in selector: bg-\\[rgb\\(255\\,0\\,0\\)\\]
     //       escaped base: bg-\\[rgb\\(255\\2c 0\\2c 0\\)\\]
     //
-    selector1 = (0, _postcssSelectorParser).default((selectors)=>{
-        return selectors.walkClasses((node)=>{
-            if (node.raws && node.value.includes(base)) {
-                node.raws.value = (0, _escapeClassName).default((0, _unesc).default(node.raws.value));
-            }
-            return node;
-        });
-    }).processSync(selector1);
+    ast.walkClasses((node)=>{
+        if (node.raws && node.value.includes(base)) {
+            node.raws.value = (0, _escapeClassName.default)((0, _unesc.default)(node.raws.value));
+        }
+    });
+    let simpleStart = _postcssSelectorParser.default.comment({
+        value: "/*__simple__*/"
+    });
+    let 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.
-    selector1 = selector1.replace(`.${(0, _escapeClassName).default(base)}`, format);
-    // Remove unnecessary pseudo selectors that we used as placeholders
-    return (0, _postcssSelectorParser).default((selectors)=>{
-        return selectors.map((selector2)=>{
-            selector2.walkPseudos((p)=>{
-                if (selectorFunctions.has(p.value)) {
-                    p.replaceWith(p.nodes);
-                }
-                return p;
-            });
-            // This will make sure to move pseudo's to the correct spot (the end for
-            // pseudo elements) because otherwise the selector will never work
-            // anyway.
-            //
-            // E.g.:
-            //  - `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`
-            //
-            // `::before:hover` doesn't work, which means that we can make it work for you by flipping the order.
-            function collectPseudoElements(selector) {
-                let nodes = [];
-                for (let node of selector.nodes){
-                    if (isPseudoElement(node)) {
-                        nodes.push(node);
-                        selector.removeChild(node);
-                    }
-                    if (node === null || node === void 0 ? void 0 : node.nodes) {
-                        nodes.push(...collectPseudoElements(node));
-                    }
-                }
-                return nodes;
+    ast.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);
+        parent.insertBefore(simpleSelector[0], simpleStart);
+        parent.insertAfter(simpleSelector[simpleSelector.length - 1], simpleEnd);
+        for (let child of formatNodes){
+            parent.insertBefore(simpleSelector[0], child);
+        }
+        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, ...resortSelector(_postcssSelectorParser.default.selector({
+            nodes: simpleSelector
+        })).nodes);
+        simpleStart.remove();
+        simpleEnd.remove();
+    });
+    // This will make sure to move pseudo's to the correct spot (the end for
+    // pseudo elements) because otherwise the selector will never work
+    // anyway.
+    //
+    // E.g.:
+    //  - `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`
+    //
+    // `::before:hover` doesn't work, which means that we can make it work for you by flipping the order.
+    function collectPseudoElements(selector) {
+        let nodes = [];
+        for (let node of selector.nodes){
+            if (isPseudoElement(node)) {
+                nodes.push(node);
+                selector.removeChild(node);
             }
-            let pseudoElements = collectPseudoElements(selector2);
-            if (pseudoElements.length > 0) {
-                selector2.nodes.push(pseudoElements.sort(sortSelector));
+            if (node === null || node === void 0 ? void 0 : node.nodes) {
+                nodes.push(...collectPseudoElements(node));
+            }
+        }
+        return nodes;
+    }
+    // Remove unnecessary pseudo selectors that we used as placeholders
+    ast.each((selector)=>{
+        selector.walkPseudos((p)=>{
+            if (selectorFunctions.has(p.value)) {
+                p.replaceWith(p.nodes);
             }
-            return selector2;
         });
-    }).processSync(selector1);
+        let pseudoElements = collectPseudoElements(selector);
+        if (pseudoElements.length > 0) {
+            selector.nodes.push(pseudoElements.sort(sortSelector));
+        }
+    });
+    return ast.toString();
 }
 // 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.
 let pseudoElementsBC = [
-    ':before',
-    ':after',
-    ':first-line',
-    ':first-letter'
+    ":before",
+    ":after",
+    ":first-line",
+    ":first-letter"
 ];
 // These pseudo-elements _can_ be combined with other pseudo selectors AND the order does matter.
 let pseudoElementExceptions = [
-    '::file-selector-button'
+    "::file-selector-button"
 ];
 // This will make sure to move pseudo's to the correct spot (the end for
 // pseudo elements) because otherwise the selector will never work
@@ -142,42 +241,42 @@ let pseudoElementExceptions = [
 function sortSelector(a, z) {
     // Both nodes are non-pseudo's so we can safely ignore them and keep
     // them in the same order.
-    if (a.type !== 'pseudo' && z.type !== 'pseudo') {
+    if (a.type !== "pseudo" && z.type !== "pseudo") {
         return 0;
     }
     // If one of them is a combinator, we need to keep it in the same order
     // because that means it will start a new "section" in the selector.
-    if (a.type === 'combinator' ^ z.type === 'combinator') {
+    if (a.type === "combinator" ^ z.type === "combinator") {
         return 0;
     }
     // One of the items is a pseudo and the other one isn't. Let's move
     // the pseudo to the right.
-    if (a.type === 'pseudo' ^ z.type === 'pseudo') {
-        return (a.type === 'pseudo') - (z.type === 'pseudo');
+    if (a.type === "pseudo" ^ z.type === "pseudo") {
+        return (a.type === "pseudo") - (z.type === "pseudo");
     }
     // Both are pseudo's, move the pseudo elements (except for
     // ::file-selector-button) to the right.
     return isPseudoElement(a) - isPseudoElement(z);
 }
 function isPseudoElement(node) {
-    if (node.type !== 'pseudo') return false;
+    if (node.type !== "pseudo") return false;
     if (pseudoElementExceptions.includes(node.value)) return false;
-    return node.value.startsWith('::') || pseudoElementsBC.includes(node.value);
+    return node.value.startsWith("::") || pseudoElementsBC.includes(node.value);
 }
 function resolveFunctionArgument(haystack, needle, arg) {
     let startIdx = haystack.indexOf(arg ? `${needle}(${arg})` : needle);
     if (startIdx === -1) return null;
     // Start inside the `(`
     startIdx += needle.length + 1;
-    let target = '';
+    let target = "";
     let count = 0;
     for (let char of haystack.slice(startIdx)){
-        if (char !== '(' && char !== ')') {
+        if (char !== "(" && char !== ")") {
             target += char;
-        } else if (char === '(') {
+        } else if (char === "(") {
             target += char;
             count++;
-        } else if (char === ')') {
+        } else if (char === ")") {
             if (--count < 0) break; // unbalanced
             target += char;
         }

package/lib/util/getAllConfigs.js

@@ -2,9 +2,12 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-exports.default = getAllConfigs;
-var _defaultConfigStubJs = _interopRequireDefault(require("../../stubs/defaultConfig.stub.js"));
-var _featureFlags = require("../featureFlags");
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: ()=>getAllConfigs
+});
+const _defaultConfigStubJs = /*#__PURE__*/ _interopRequireDefault(require("../../stubs/defaultConfig.stub.js"));
+const _featureFlags = require("../featureFlags");
 function _interopRequireDefault(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -14,13 +17,29 @@ function getAllConfigs(config) {
     var ref;
     const configs = ((ref = config === null || config === void 0 ? void 0 : config.presets) !== null && ref !== void 0 ? ref : [
         _defaultConfigStubJs.default
-    ]).slice().reverse().flatMap((preset)=>getAllConfigs(preset instanceof Function ? preset() : preset)
-    );
+    ]).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]
-    );
+    const experimentals = Object.keys(features).filter((feature)=>(0, _featureFlags.flagEnabled)(config, feature)).map((feature)=>features[feature]);
     return [
         config,
         ...experimentals,

package/lib/util/hashConfig.js

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

package/lib/util/isKeyframeRule.js

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

package/lib/util/isPlainObject.js

@@ -2,9 +2,12 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-exports.default = isPlainObject;
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: ()=>isPlainObject
+});
 function isPlainObject(value) {
-    if (Object.prototype.toString.call(value) !== '[object Object]') {
+    if (Object.prototype.toString.call(value) !== "[object Object]") {
         return false;
     }
     const prototype = Object.getPrototypeOf(value);

package/lib/util/{isValidArbitraryValue.js → isSyntacticallyValidPropertyValue.js}

@@ -2,45 +2,53 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-exports.default = isValidArbitraryValue;
+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: ()=>isSyntacticallyValidPropertyValue
+});
 let matchingBrackets = new Map([
     [
-        '{',
-        '}'
+        "{",
+        "}"
     ],
     [
-        '[',
-        ']'
+        "[",
+        "]"
     ],
     [
-        '(',
-        ')'
-    ], 
+        "(",
+        ")"
+    ]
 ]);
 let inverseMatchingBrackets = new Map(Array.from(matchingBrackets.entries()).map(([k, v])=>[
         v,
         k
-    ]
-));
+    ]));
 let quotes = new Set([
     '"',
     "'",
-    '`'
+    "`"
 ]);
-function isValidArbitraryValue(value) {
+function isSyntacticallyValidPropertyValue(value) {
     let stack = [];
     let inQuotes = false;
     for(let i = 0; i < value.length; i++){
         let char = value[i];
-        if (char === ':' && !inQuotes && stack.length === 0) {
+        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] !== '\\') {
+        if (quotes.has(char) && value[i - 1] !== "\\") {
             inQuotes = !inQuotes;
         }
         if (inQuotes) continue;
-        if (value[i - 1] === '\\') continue; // Escaped
+        if (value[i - 1] === "\\") continue; // Escaped
         if (matchingBrackets.has(char)) {
             stack.push(char);
         } else if (inverseMatchingBrackets.has(char)) {

package/lib/util/log.js

@@ -2,29 +2,36 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-exports.dim = dim;
-exports.default = void 0;
-var _chalk = _interopRequireDefault(require("chalk"));
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    dim: ()=>dim,
+    default: ()=>_default
+});
+const _picocolors = /*#__PURE__*/ _interopRequireDefault(require("picocolors"));
 function _interopRequireDefault(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
 }
 let alreadyShown = new Set();
-function log(chalk, messages, key) {
-    if (process.env.JEST_WORKER_ID !== undefined) return;
+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(chalk, '-', message)
-    );
+    console.warn("");
+    messages.forEach((message)=>console.warn(type, "-", message));
 }
 function dim(input) {
-    return _chalk.default.dim(input);
+    return _picocolors.default.dim(input);
 }
-var _default = {
+const _default = {
     info (key, messages) {
-        log(_chalk.default.bold.cyan('info'), ...Array.isArray(key) ? [
+        log(_picocolors.default.bold(_picocolors.default.cyan("info")), ...Array.isArray(key) ? [
             key
         ] : [
             messages,
@@ -32,7 +39,7 @@ var _default = {
         ]);
     },
     warn (key, messages) {
-        log(_chalk.default.bold.yellow('warn'), ...Array.isArray(key) ? [
+        log(_picocolors.default.bold(_picocolors.default.yellow("warn")), ...Array.isArray(key) ? [
             key
         ] : [
             messages,
@@ -40,7 +47,7 @@ var _default = {
         ]);
     },
     risk (key, messages) {
-        log(_chalk.default.bold.magenta('risk'), ...Array.isArray(key) ? [
+        log(_picocolors.default.bold(_picocolors.default.magenta("risk")), ...Array.isArray(key) ? [
             key
         ] : [
             messages,
@@ -48,4 +55,3 @@ var _default = {
         ]);
     }
 };
-exports.default = _default;

package/lib/util/nameClass.js

@@ -2,31 +2,42 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-exports.asClass = asClass;
-exports.default = nameClass;
-exports.formatClass = formatClass;
-var _escapeClassName = _interopRequireDefault(require("./escapeClassName"));
-var _escapeCommas = _interopRequireDefault(require("./escapeCommas"));
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    asClass: ()=>asClass,
+    default: ()=>nameClass,
+    formatClass: ()=>formatClass
+});
+const _escapeClassName = /*#__PURE__*/ _interopRequireDefault(require("./escapeClassName"));
+const _escapeCommas = /*#__PURE__*/ _interopRequireDefault(require("./escapeCommas"));
 function _interopRequireDefault(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
 }
 function asClass(name) {
-    return (0, _escapeCommas).default(`.${(0, _escapeClassName).default(name)}`);
+    return (0, _escapeCommas.default)(`.${(0, _escapeClassName.default)(name)}`);
 }
 function nameClass(classPrefix, key) {
     return asClass(formatClass(classPrefix, key));
 }
 function formatClass(classPrefix, key) {
-    if (key === 'DEFAULT') {
+    if (key === "DEFAULT") {
         return classPrefix;
     }
-    if (key === '-' || key === '-DEFAULT') {
+    if (key === "-" || key === "-DEFAULT") {
         return `-${classPrefix}`;
     }
-    if (key.startsWith('-')) {
+    if (key.startsWith("-")) {
         return `-${classPrefix}${key}`;
     }
+    if (key.startsWith("/")) {
+        return `${classPrefix}${key}`;
+    }
     return `${classPrefix}-${key}`;
 }