tailwindcss 3.0.24 → 3.1.0

package/lib/util/formatVariantSelector.js

@@ -14,6 +14,7 @@ function _interopRequireDefault(obj) {
         default: obj
     };
 }
+var ref;
 let MERGE = ":merge";
 let PARENT = "&";
 let selectorFunctions = new Set([
@@ -37,23 +38,31 @@ function formatVariantSelector(current, ...others) {
     }
     return current;
 }
-function finalizeSelector(format, { selector: selector1 , candidate , context  }) {
-    var ref, ref1;
+var ref1;
+function finalizeSelector(format, { selector: selector1 , candidate , context , // 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) {
+    let ast = (0, _postcssSelectorParser).default().astSync(selector1);
+    if (context === null || context === void 0 ? void 0 : (ref2 = context.tailwindConfig) === null || ref2 === void 0 ? void 0 : ref2.prefix) {
         format = (0, _prefixSelector).default(context.tailwindConfig.prefix, format);
     }
     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((node)=>{
+        let hasClassesMatchingCandidate = node.some((n)=>n.type === "class" && n.value === base);
+        if (!hasClassesMatchingCandidate) {
+            node.remove();
+        }
+    });
     // Normalize escaped classes, e.g.:
     //
     // The idea would be to replace the escaped `base` in the selector with the
@@ -65,55 +74,53 @@ 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));
+        }
+    });
     // 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) {
+            node.replaceWith(...formatAst.nodes);
+        }
+    });
+    // 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));
             }
-            let pseudoElements = collectPseudoElements(selector2);
-            if (pseudoElements.length > 0) {
-                selector2.nodes.push(pseudoElements.sort(sortSelector));
+        }
+        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

package/lib/util/getAllConfigs.js

@@ -9,13 +9,18 @@ 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: {
+                    DEFAULT: "#3b82f67f"
+                }
+            }
+        }
     };
-    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/isValidArbitraryValue.js

@@ -55,8 +55,7 @@ let matchingBrackets = new Map([
 let inverseMatchingBrackets = new Map(Array.from(matchingBrackets.entries()).map(([k, v])=>[
         v,
         k
-    ]
-));
+    ]));
 let quotes = new Set([
     '"',
     "'",

package/lib/util/log.js

@@ -12,12 +12,11 @@ function _interopRequireDefault(obj) {
 }
 let alreadyShown = new Set();
 function log(type, messages, key) {
-    if (process.env.JEST_WORKER_ID !== undefined) return;
+    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)
-    );
+    messages.forEach((message)=>console.warn(type, "-", message));
 }
 function dim(input) {
     return _picocolors.default.dim(input);

package/lib/util/negateValue.js

@@ -10,8 +10,7 @@ function _default(value) {
     }
     // Flip sign of numbers
     if (/^[+-]?(\d+|\d*\.\d+)(e[+-]?\d+)?(%|\w+)?$/.test(value)) {
-        return value.replace(/^[+-]?/, (sign)=>sign === "-" ? "" : "-"
-        );
+        return value.replace(/^[+-]?/, (sign)=>sign === "-" ? "" : "-");
     }
     if (value.includes("var(") || value.includes("calc(")) {
         return `calc(${value} * -1)`;

package/lib/util/normalizeConfig.js

@@ -4,26 +4,44 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.normalizeConfig = normalizeConfig;
 var _log = _interopRequireWildcard(require("./log"));
+function _getRequireWildcardCache() {
+    if (typeof WeakMap !== "function") return null;
+    var cache = new WeakMap();
+    _getRequireWildcardCache = function() {
+        return cache;
+    };
+    return cache;
+}
 function _interopRequireWildcard(obj) {
     if (obj && obj.__esModule) {
         return obj;
-    } else {
-        var newObj = {};
-        if (obj != null) {
-            for(var key in obj){
-                if (Object.prototype.hasOwnProperty.call(obj, key)) {
-                    var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {};
-                    if (desc.get || desc.set) {
-                        Object.defineProperty(newObj, key, desc);
-                    } else {
-                        newObj[key] = obj[key];
-                    }
-                }
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache();
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
             }
         }
-        newObj.default = obj;
-        return newObj;
     }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
 }
 function normalizeConfig(config) {
     // Quick structure validation
@@ -75,8 +93,7 @@ function normalizeConfig(config) {
                     "files",
                     "extract",
                     "transform"
-                ].includes(key)
-            )) {
+                ].includes(key))) {
                 return false;
             }
             // `config.content.files` should exist of FilePaths or RawFiles
@@ -229,12 +246,5 @@ function normalizeConfig(config) {
             break;
         }
     }
-    if (config.content.files.length === 0) {
-        _log.default.warn("content-problems", [
-            "The `content` option in your Tailwind CSS configuration is missing or empty.",
-            "Configure your content sources or your generated CSS will be missing styles.",
-            "https://tailwindcss.com/docs/content-configuration", 
-        ]);
-    }
     return config;
 }

package/lib/util/normalizeScreens.js

@@ -36,8 +36,7 @@ function normalizeScreens(screens, root = true) {
             if (Array.isArray(options)) {
                 return {
                     name,
-                    values: options.map((option)=>resolveValue(option)
-                    )
+                    values: options.map((option)=>resolveValue(option))
                 };
             }
             return {

package/lib/util/parseAnimationValue.js

@@ -28,8 +28,7 @@ function parseAnimationValue(input) {
             } else if (!seen.has("TIMING_FUNCTION") && TIMINGS.has(part)) {
                 result.timingFunction = part;
                 seen.add("TIMING_FUNCTION");
-            } else if (!seen.has("TIMING_FUNCTION") && TIMING_FNS.some((f)=>part.startsWith(`${f}(`)
-            )) {
+            } else if (!seen.has("TIMING_FUNCTION") && TIMING_FNS.some((f)=>part.startsWith(`${f}(`))) {
                 result.timingFunction = part;
                 seen.add("TIMING_FUNCTION");
             } else if (!seen.has("DURATION") && TIME.test(part)) {

package/lib/util/parseBoxShadowValue.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.parseBoxShadowValue = parseBoxShadowValue;
 exports.formatBoxShadowValue = formatBoxShadowValue;
+var _splitAtTopLevelOnly = require("./splitAtTopLevelOnly");
 let KEYWORDS = new Set([
     "inset",
     "inherit",
@@ -14,50 +15,8 @@ let KEYWORDS = new Set([
 let SPACE = /\ +(?![^(]*\))/g // Similar to the one above, but with spaces instead.
 ;
 let LENGTH = /^-?(\d+|\.\d+)(.*?)$/g;
-let SPECIALS = /[(),]/g;
-/**
- * This splits a string on top-level commas.
- *
- * Regex doesn't support recursion (at least not the JS-flavored version).
- * So we have to use a tiny state machine to keep track of paren vs comma
- * placement. Before we'd only exclude commas from the inner-most nested
- * set of parens rather than any commas that were not contained in parens
- * at all which is the intended behavior here.
- *
- * Expected behavior:
- * var(--a, 0 0 1px rgb(0, 0, 0)), 0 0 1px rgb(0, 0, 0)
- *       ─┬─             ┬  ┬    ┬
- *        x              x  x    ╰──────── Split because top-level
- *        ╰──────────────┴──┴───────────── Ignored b/c inside >= 1 levels of parens
- *
- * @param {string} input
- */ function* splitByTopLevelCommas(input) {
-    SPECIALS.lastIndex = -1;
-    let depth = 0;
-    let lastIndex = 0;
-    let found = false;
-    // Find all parens & commas
-    // And only split on commas if they're top-level
-    for (let match of input.matchAll(SPECIALS)){
-        if (match[0] === "(") depth++;
-        if (match[0] === ")") depth--;
-        if (match[0] === "," && depth === 0) {
-            found = true;
-            yield input.substring(lastIndex, match.index);
-            lastIndex = match.index + match[0].length;
-        }
-    }
-    // Provide the last segment of the string if available
-    // Otherwise the whole string since no commas were found
-    // This mirrors the behavior of string.split()
-    if (found) {
-        yield input.substring(lastIndex);
-    } else {
-        yield input;
-    }
-}
 function parseBoxShadowValue(input) {
-    let shadows = Array.from(splitByTopLevelCommas(input));
+    let shadows = Array.from((0, _splitAtTopLevelOnly).splitAtTopLevelOnly(input, ","));
     return shadows.map((shadow)=>{
         let value = shadow.trim();
         let result = {

package/lib/util/pluginUtils.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.updateAllClasses = updateAllClasses;
 exports.asValue = asValue;
+exports.parseColorFormat = parseColorFormat;
 exports.asColor = asColor;
 exports.asLookupValue = asLookupValue;
 exports.coerceValue = coerceValue;
@@ -53,8 +54,7 @@ function asNegativeValue(modifier, lookup = {}, validate) {
         return (0, _negateValue).default(resolved);
     }
 }
-function asValue(modifier, options = {}, { validate =()=>true
-  } = {}) {
+function asValue(modifier, options = {}, { validate =()=>true  } = {}) {
     var ref;
     let value = (ref = options.values) === null || ref === void 0 ? void 0 : ref[modifier];
     if (value !== undefined) {
@@ -80,11 +80,18 @@ function splitAlpha(modifier) {
         modifier.slice(slashIdx + 1)
     ];
 }
+function parseColorFormat(value) {
+    if (typeof value === "string" && value.includes("<alpha-value>")) {
+        let oldValue = value;
+        return ({ opacityValue =1  })=>oldValue.replace("<alpha-value>", opacityValue);
+    }
+    return value;
+}
 function asColor(modifier, options = {}, { tailwindConfig ={}  } = {}) {
     var ref;
     if (((ref = options.values) === null || ref === void 0 ? void 0 : ref[modifier]) !== undefined) {
         var ref1;
-        return (ref1 = options.values) === null || ref1 === void 0 ? void 0 : ref1[modifier];
+        return parseColorFormat((ref1 = options.values) === null || ref1 === void 0 ? void 0 : ref1[modifier]);
     }
     let [color, alpha] = splitAlpha(modifier);
     if (alpha !== undefined) {
@@ -94,6 +101,7 @@ function asColor(modifier, options = {}, { tailwindConfig ={}  } = {}) {
         if (normalizedColor === undefined) {
             return undefined;
         }
+        normalizedColor = parseColorFormat(normalizedColor);
         if (isArbitraryValue(alpha)) {
             return (0, _withAlphaVariable).withAlphaValue(normalizedColor, alpha.slice(1, -1));
         }

package/lib/util/resolveConfig.js

@@ -13,6 +13,9 @@ var _toPath = require("./toPath");
 var _normalizeConfig = require("./normalizeConfig");
 var _isPlainObject = _interopRequireDefault(require("./isPlainObject"));
 var _cloneDeep = require("./cloneDeep");
+var _pluginUtils = require("./pluginUtils");
+var _withAlphaVariable = require("./withAlphaVariable");
+var _toColorValue = _interopRequireDefault(require("./toColorValue"));
 function resolveConfig(configs) {
     let allConfigs = [
         ...extractPluginConfigs(configs),
@@ -28,8 +31,7 @@ function resolveConfig(configs) {
         theme: resolveFunctionKeys(mergeExtensions(mergeThemes(allConfigs.map((t)=>{
             return (ref = t === null || t === void 0 ? void 0 : t.theme) !== null && ref !== void 0 ? ref : {};
         })))),
-        corePlugins: resolveCorePlugins(allConfigs.map((c)=>c.corePlugins
-        )),
+        corePlugins: resolveCorePlugins(allConfigs.map((c)=>c.corePlugins)),
         plugins: resolvePluginLists(configs.map((c)=>{
             return (ref1 = c === null || c === void 0 ? void 0 : c.plugins) !== null && ref1 !== void 0 ? ref1 : [];
         }))
@@ -68,8 +70,7 @@ const configUtils = {
     colors: _colors.default,
     negative (scale) {
         // TODO: Log that this function isn't really needed anymore?
-        return Object.keys(scale).filter((key)=>scale[key] !== "0"
-        ).reduce((negativeScale, key)=>{
+        return Object.keys(scale).filter((key)=>scale[key] !== "0").reduce((negativeScale, key)=>{
             let negativeValue = (0, _negateValue).default(scale[key]);
             if (negativeValue !== undefined) {
                 negativeScale[`-${key}`] = negativeValue;
@@ -78,12 +79,10 @@ const configUtils = {
         }, {});
     },
     breakpoints (screens) {
-        return Object.keys(screens).filter((key)=>typeof screens[key] === "string"
-        ).reduce((breakpoints, key)=>({
+        return Object.keys(screens).filter((key)=>typeof screens[key] === "string").reduce((breakpoints, key)=>({
                 ...breakpoints,
                 [`screen-${key}`]: screens[key]
-            })
-        , {});
+            }), {});
     }
 };
 function value(valueToResolve, ...args) {
@@ -112,8 +111,7 @@ function collectExtends(items) {
 }
 function mergeThemes(themes) {
     return {
-        ...themes.reduce((merged, theme)=>(0, _defaults).defaults(merged, theme)
-        , {}),
+        ...themes.reduce((merged, theme)=>(0, _defaults).defaults(merged, theme), {}),
         // In order to resolve n config objects, we combine all of their `extend` properties
         // into arrays instead of objects so they aren't overridden.
         extend: collectExtends(themes)
@@ -147,37 +145,62 @@ function mergeExtensions({ extend , ...theme }) {
         return (resolveThemePath, utils)=>mergeWith({}, ...[
                 themeValue,
                 ...extensions
-            ].map((e)=>value(e, resolveThemePath, utils)
-            ), mergeExtensionCustomizer)
-        ;
+            ].map((e)=>value(e, resolveThemePath, utils)), mergeExtensionCustomizer);
     });
 }
+/**
+ *
+ * @param {string} key
+ * @return {Iterable<string[] & {alpha: string | undefined}>}
+ */ function* toPaths(key) {
+    let path = (0, _toPath).toPath(key);
+    if (path.length === 0) {
+        return;
+    }
+    yield path;
+    if (Array.isArray(key)) {
+        return;
+    }
+    let pattern = /^(.*?)\s*\/\s*([^/]+)$/;
+    let matches = key.match(pattern);
+    if (matches !== null) {
+        let [, prefix, alpha] = matches;
+        let newPath = (0, _toPath).toPath(prefix);
+        newPath.alpha = alpha;
+        yield newPath;
+    }
+}
 function resolveFunctionKeys(object) {
+    // theme('colors.red.500 / 0.5') -> ['colors', 'red', '500 / 0', '5]
     const resolvePath = (key, defaultValue)=>{
-        const path = (0, _toPath).toPath(key);
-        let index = 0;
-        let val = object;
-        while(val !== undefined && val !== null && index < path.length){
-            val = val[path[index++]];
-            val = isFunction(val) ? val(resolvePath, configUtils) : val;
-        }
-        if (val === undefined) {
-            return defaultValue;
-        }
-        if ((0, _isPlainObject).default(val)) {
-            return (0, _cloneDeep).cloneDeep(val);
+        for (const path of toPaths(key)){
+            let index = 0;
+            let val = object;
+            while(val !== undefined && val !== null && index < path.length){
+                val = val[path[index++]];
+                let shouldResolveAsFn = isFunction(val) && (path.alpha === undefined || index < path.length - 1);
+                val = shouldResolveAsFn ? val(resolvePath, configUtils) : val;
+            }
+            if (val !== undefined) {
+                if (path.alpha !== undefined) {
+                    let normalized = (0, _pluginUtils).parseColorFormat(val);
+                    return (0, _withAlphaVariable).withAlphaValue(normalized, path.alpha, (0, _toColorValue).default(normalized));
+                }
+                if ((0, _isPlainObject).default(val)) {
+                    return (0, _cloneDeep).cloneDeep(val);
+                }
+                return val;
+            }
         }
-        return val;
+        return defaultValue;
     };
-    resolvePath.theme = resolvePath;
-    for(let key1 in configUtils){
-        resolvePath[key1] = configUtils[key1];
-    }
+    Object.assign(resolvePath, {
+        theme: resolvePath,
+        ...configUtils
+    });
     return Object.keys(object).reduce((resolved, key)=>{
-        return {
-            ...resolved,
-            [key]: isFunction(object[key]) ? object[key](resolvePath, configUtils) : object[key]
-        };
+        resolved[key] = isFunction(object[key]) ? object[key](resolvePath, configUtils) : object[key];
+        return resolved;
     }, {});
 }
 function extractPluginConfigs(configs) {

package/lib/util/splitAtTopLevelOnly.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+exports.splitAtTopLevelOnly = splitAtTopLevelOnly;
+var regex = _interopRequireWildcard(require("../lib/regex"));
+function _getRequireWildcardCache() {
+    if (typeof WeakMap !== "function") return null;
+    var cache = new WeakMap();
+    _getRequireWildcardCache = function() {
+        return cache;
+    };
+    return cache;
+}
+function _interopRequireWildcard(obj) {
+    if (obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache();
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+function* splitAtTopLevelOnly(input, separator) {
+    let SPECIALS = new RegExp(`[(){}\\[\\]${regex.escape(separator)}]`, "g");
+    let depth = 0;
+    let lastIndex = 0;
+    let found = false;
+    let separatorIndex = 0;
+    let separatorStart = 0;
+    let separatorLength = separator.length;
+    // Find all paren-like things & character
+    // And only split on commas if they're top-level
+    for (let match of input.matchAll(SPECIALS)){
+        let matchesSeparator = match[0] === separator[separatorIndex];
+        let atEndOfSeparator = separatorIndex === separatorLength - 1;
+        let matchesFullSeparator = matchesSeparator && atEndOfSeparator;
+        if (match[0] === "(") depth++;
+        if (match[0] === ")") depth--;
+        if (match[0] === "[") depth++;
+        if (match[0] === "]") depth--;
+        if (match[0] === "{") depth++;
+        if (match[0] === "}") depth--;
+        if (matchesSeparator && depth === 0) {
+            if (separatorStart === 0) {
+                separatorStart = match.index;
+            }
+            separatorIndex++;
+        }
+        if (matchesFullSeparator && depth === 0) {
+            found = true;
+            yield input.substring(lastIndex, separatorStart);
+            lastIndex = separatorStart + separatorLength;
+        }
+        if (separatorIndex === separatorLength) {
+            separatorIndex = 0;
+            separatorStart = 0;
+        }
+    }
+    // Provide the last segment of the string if available
+    // Otherwise the whole string since no `char`s were found
+    // This mirrors the behavior of string.split()
+    if (found) {
+        yield input.substring(lastIndex);
+    } else {
+        yield input;
+    }
+}