tailwindcss 0.0.0-insiders.bb0ab67 → 0.0.0-insiders.bb4f5da

package/CHANGELOG.md

@@ -19,7 +19,15 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Support PostCSS config options in config file in CLI ([#8226](https://github.com/tailwindlabs/tailwindcss/pull/8226))
 - Remove default `[hidden]` style in preflight ([#8248](https://github.com/tailwindlabs/tailwindcss/pull/8248))
 - Only check selectors containing base apply candidates for circular dependencies ([#8222](https://github.com/tailwindlabs/tailwindcss/pull/8222))
-- Handle utilities with multiple and/or grouped selectors better ([#8262](https://github.com/tailwindlabs/tailwindcss/pull/8262))
+- Rewrite default class extractor ([#8204](https://github.com/tailwindlabs/tailwindcss/pull/8204))
+- Move `important` selector to the front when `@apply`-ing selector-modifying variants in custom utilities ([#8313](https://github.com/tailwindlabs/tailwindcss/pull/8313))
+- Error when registering an invalid custom variant ([#8345](https://github.com/tailwindlabs/tailwindcss/pull/8345))
+- Create tailwind.config.cjs file in ESM package when running init ([#8363](https://github.com/tailwindlabs/tailwindcss/pull/8363))
+- Fix `matchVariants` that use at-rules and placeholders ([#8392](https://github.com/tailwindlabs/tailwindcss/pull/8392))
+
+### Changed
+
+- Try using local `postcss` installation first in the CLI ([#8270](https://github.com/tailwindlabs/tailwindcss/pull/8270))
 
 ### Added
 
@@ -34,6 +42,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Add TypeScript types for the `tailwind.config.js` file ([#7891](https://github.com/tailwindlabs/tailwindcss/pull/7891))
 - Add `backdrop` variant ([#7924](https://github.com/tailwindlabs/tailwindcss/pull/7924))
 - Add `grid-flow-dense` utility ([#8193](https://github.com/tailwindlabs/tailwindcss/pull/8193))
+- Add `mix-blend-plus-lighter` utility ([#8288](https://github.com/tailwindlabs/tailwindcss/pull/8288))
+- Add arbitrary variants ([#8299](https://github.com/tailwindlabs/tailwindcss/pull/8299))
+- Add `matchVariant` API ([#8310](https://github.com/tailwindlabs/tailwindcss/pull/8310))
 
 ## [3.0.24] - 2022-04-12
 

package/lib/cli-peer-dependencies.js

@@ -2,11 +2,12 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
+exports.lazyPostcss = lazyPostcss;
 exports.lazyAutoprefixer = lazyAutoprefixer;
 exports.lazyCssnano = lazyCssnano;
-exports.postcss = void 0;
-let postcss = require("postcss");
-exports.postcss = postcss;
+function lazyPostcss() {
+    return require("postcss");
+}
 function lazyAutoprefixer() {
     return require("autoprefixer");
 }

package/lib/cli.js

@@ -18,6 +18,7 @@ var _getModuleDependencies = _interopRequireDefault(require("./lib/getModuleDepe
 var _log = _interopRequireDefault(require("./util/log"));
 var _packageJson = _interopRequireDefault(require("../package.json"));
 var _normalizePath = _interopRequireDefault(require("normalize-path"));
+var _validateConfigJs = require("./util/validateConfig.js");
 function _interopRequireDefault(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -26,6 +27,22 @@ function _interopRequireDefault(obj) {
 let env = {
     DEBUG: process.env.DEBUG !== undefined && process.env.DEBUG !== "0"
 };
+function isESM() {
+    const pkgPath = _path.default.resolve("./package.json");
+    try {
+        let pkg = JSON.parse(_fs.default.readFileSync(pkgPath, "utf8"));
+        return pkg.type && pkg.type === "module";
+    } catch (err) {
+        return false;
+    }
+}
+let configs = isESM() ? {
+    tailwind: "tailwind.config.cjs",
+    postcss: "postcss.config.cjs"
+} : {
+    tailwind: "tailwind.config.js",
+    postcss: "postcss.config.js"
+};
 // ---
 function indentRecursive(node, indent = 0) {
     node.each && node.each((child, i)=>{
@@ -130,21 +147,28 @@ function oneOf(...options) {
         manualParsing: true
     });
 }
+function loadPostcss() {
+    // Try to load a local `postcss` version first
+    try {
+        return require("postcss");
+    } catch  {}
+    return (0, _indexJs).lazyPostcss();
+}
 let commands = {
     init: {
         run: init,
         args: {
             "--full": {
                 type: Boolean,
-                description: "Initialize a full `tailwind.config.js` file"
+                description: `Initialize a full \`${configs.tailwind}\` file`
             },
             "--postcss": {
                 type: Boolean,
-                description: "Initialize a `postcss.config.js` file"
+                description: `Initialize a \`${configs.postcss}\` file`
             },
             "--types": {
                 type: Boolean,
-                description: "Add TypeScript types for the `tailwind.config.js` file"
+                description: `Add TypeScript types for the \`${configs.tailwind}\` file`
             },
             "-f": "--full",
             "-p": "--postcss"
@@ -328,7 +352,7 @@ run();
 function init() {
     let messages = [];
     var ref;
-    let tailwindConfigLocation = _path.default.resolve((ref = args["_"][1]) !== null && ref !== void 0 ? ref : "./tailwind.config.js");
+    let tailwindConfigLocation = _path.default.resolve((ref = args["_"][1]) !== null && ref !== void 0 ? ref : `./${configs.tailwind}`);
     if (_fs.default.existsSync(tailwindConfigLocation)) {
         messages.push(`${_path.default.basename(tailwindConfigLocation)} already exists.`);
     } else {
@@ -343,7 +367,7 @@ function init() {
         messages.push(`Created Tailwind CSS config file: ${_path.default.basename(tailwindConfigLocation)}`);
     }
     if (args["--postcss"]) {
-        let postcssConfigLocation = _path.default.resolve("./postcss.config.js");
+        let postcssConfigLocation = _path.default.resolve(`./${configs.postcss}`);
         if (_fs.default.existsSync(postcssConfigLocation)) {
             messages.push(`${_path.default.basename(postcssConfigLocation)} already exists.`);
         } else {
@@ -383,7 +407,7 @@ async function build() {
         process.exit(9);
     }
     let configPath = args["--config"] ? args["--config"] : ((defaultPath)=>_fs.default.existsSync(defaultPath) ? defaultPath : null
-    )(_path.default.resolve("./tailwind.config.js"));
+    )(_path.default.resolve(`./${configs.tailwind}`));
     async function loadPostCssPlugins() {
         let customPostCssPath = typeof args["--postcss"] === "string" ? args["--postcss"] : undefined;
         let config1 = customPostCssPath ? await (async ()=>{
@@ -441,9 +465,12 @@ async function build() {
                 }
             });
             resolvedConfig.content.files = files;
+            resolvedConfig = (0, _validateConfigJs).validateConfig(resolvedConfig);
             return resolvedConfig;
         }
-        return (0, _resolveConfig).default(config);
+        let resolvedConfig = (0, _resolveConfig).default(config);
+        resolvedConfig = (0, _validateConfigJs).validateConfig(resolvedConfig);
+        return resolvedConfig;
     }
     function extractFileGlobs(config) {
         return config.content.files.filter((file)=>{
@@ -528,7 +555,8 @@ async function build() {
                 return (0, _indexJs).lazyCssnano()(options);
             })(), 
         ].filter(Boolean);
-        let processor = (0, _indexJs).postcss(plugins);
+        let postcss = loadPostcss();
+        let processor = postcss(plugins);
         function processCSS(css) {
             let start = process.hrtime.bigint();
             return Promise.resolve().then(()=>output ? _fs.default.promises.mkdir(_path.default.dirname(output), {
@@ -649,7 +677,8 @@ async function build() {
             let tailwindPluginIdx = plugins.indexOf("__TAILWIND_PLUGIN_POSITION__");
             let copy = plugins.slice();
             copy.splice(tailwindPluginIdx, 1, tailwindPlugin);
-            let processor = (0, _indexJs).postcss(copy);
+            let postcss = loadPostcss();
+            let processor = postcss(copy);
             function processCSS(css) {
                 let start = process.hrtime.bigint();
                 return Promise.resolve().then(()=>output ? _fs.default.promises.mkdir(_path.default.dirname(output), {

package/lib/corePlugins.js

@@ -3068,6 +3068,9 @@ let corePlugins = {
             },
             ".mix-blend-luminosity": {
                 "mix-blend-mode": "luminosity"
+            },
+            ".mix-blend-plus-lighter": {
+                "mix-blend-mode": "plus-lighter"
             }
         });
     },

package/lib/lib/defaultExtractor.js

@@ -3,38 +3,165 @@ Object.defineProperty(exports, "__esModule", {
     value: true
 });
 exports.defaultExtractor = defaultExtractor;
-const PATTERNS = [
-    /(?:\['([^'\s]+[^<>"'`\s:\\])')/.source,
-    /(?:\["([^"\s]+[^<>"'`\s:\\])")/.source,
-    /(?:\[`([^`\s]+[^<>"'`\s:\\])`)/.source,
-    /([^${(<>"'`\s]*\[\w*'[^"`\s]*'?\])/.source,
-    /([^${(<>"'`\s]*\[\w*"[^'`\s]*"?\])/.source,
-    /([^<>"'`\s]*\[\w*\('[^"'`\s]*'\)\])/.source,
-    /([^<>"'`\s]*\[\w*\("[^"'`\s]*"\)\])/.source,
-    /([^<>"'`\s]*\[\w*\('[^"`\s]*'\)\])/.source,
-    /([^<>"'`\s]*\[\w*\("[^'`\s]*"\)\])/.source,
-    /([^<>"'`\s]*\[[^<>"'`\s]*\('[^"`\s]*'\)+\])/.source,
-    /([^<>"'`\s]*\[[^<>"'`\s]*\("[^'`\s]*"\)+\])/.source,
-    /([^${(<>"'`\s]*\['[^"'`\s]*'\])/.source,
-    /([^${(<>"'`\s]*\["[^"'`\s]*"\])/.source,
-    /([^<>"'`\s]*\[[^<>"'`\s]*:[^\]\s]*\])/.source,
-    /([^<>"'`\s]*\[[^<>"'`\s]*:'[^"'`\s]*'\])/.source,
-    /([^<>"'`\s]*\[[^<>"'`\s]*:"[^"'`\s]*"\])/.source,
-    /([^<>"'`\s]*\[[^"'`\s]+\][^<>"'`\s]*)/.source,
-    /([^"'`\s]*[^<>"'`\s:\\])/.source,
-    /([^<>"'`\s]*[^"'`\s:\\])/.source, 
-].join("|");
-const BROAD_MATCH_GLOBAL_REGEXP = new RegExp(PATTERNS, "g");
-const INNER_MATCH_GLOBAL_REGEXP = /[^<>"'`\s.(){}[\]#=%$]*[^<>"'`\s.(){}[\]#=%:$]/g;
-function defaultExtractor(content) {
-    let broadMatches = content.matchAll(BROAD_MATCH_GLOBAL_REGEXP);
-    let innerMatches = content.match(INNER_MATCH_GLOBAL_REGEXP) || [];
-    let results = [
-        ...broadMatches,
-        ...innerMatches
-    ].flat().filter((v)=>v !== undefined
-    );
-    return results;
+var regex = _interopRequireWildcard(require("./regex"));
+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];
+                    }
+                }
+            }
+        }
+        newObj.default = obj;
+        return newObj;
+    }
+}
+function defaultExtractor(context) {
+    let patterns = Array.from(buildRegExps(context));
+    /**
+   * @param {string} content
+   */ return (content)=>{
+        /** @type {(string|string)[]} */ let results = [];
+        for (let pattern of patterns){
+            var ref;
+            results.push(...(ref = content.match(pattern)) !== null && ref !== void 0 ? ref : []);
+        }
+        return results.filter((v)=>v !== undefined
+        ).map(clipAtBalancedParens);
+    };
+}
+function* buildRegExps(context) {
+    let separator = context.tailwindConfig.separator;
+    yield regex.pattern([
+        // Variants
+        "((?=((",
+        regex.any([
+            regex.pattern([
+                /([^\s"'\[\\]+-)?\[[^\s"'\\]+\]/,
+                separator
+            ]),
+            regex.pattern([
+                /[^\s"'\[\\]+/,
+                separator
+            ]), 
+        ], true),
+        ")+))\\2)?",
+        // Important (optional)
+        /!?/,
+        regex.any([
+            // Arbitrary properties
+            /\[[^\s:'"]+:[^\s\]]+\]/,
+            // Utilities
+            regex.pattern([
+                // Utility Name / Group Name
+                /-?(?:\w+)/,
+                // Normal/Arbitrary values
+                regex.optional(regex.any([
+                    regex.pattern([
+                        // Arbitrary values
+                        /-\[[^\s:]+\]/,
+                        // Not immediately followed by an `{[(`
+                        /(?![{([]])/,
+                        // optionally followed by an opacity modifier
+                        /(?:\/[^\s'"\\$]*)?/, 
+                    ]),
+                    regex.pattern([
+                        // Arbitrary values
+                        /-\[[^\s]+\]/,
+                        // Not immediately followed by an `{[(`
+                        /(?![{([]])/,
+                        // optionally followed by an opacity modifier
+                        /(?:\/[^\s'"\\$]*)?/, 
+                    ]),
+                    // Normal values w/o quotes — may include an opacity modifier
+                    /[-\/][^\s'"\\$={]*/, 
+                ])), 
+            ]), 
+        ]), 
+    ]);
+// 5. Inner matches
+// yield /[^<>"'`\s.(){}[\]#=%$]*[^<>"'`\s.(){}[\]#=%:$]/g
+}
+// We want to capture any "special" characters
+// AND the characters immediately following them (if there is one)
+let SPECIALS = /([\[\]'"`])([^\[\]'"`])?/g;
+let ALLOWED_CLASS_CHARACTERS = /[^"'`\s<>\]]+/;
+/**
+ * Clips a string ensuring that parentheses, quotes, etc… are balanced
+ * Used for arbitrary values only
+ *
+ * We will go past the end of the balanced parens until we find a non-class character
+ *
+ * Depth matching behavior:
+ * w-[calc(100%-theme('spacing[some_key][1.5]'))]']
+ *   ┬    ┬          ┬┬       ┬        ┬┬   ┬┬┬┬┬┬┬
+ *   1    2          3        4        34   3 210 END
+ *   ╰────┴──────────┴────────┴────────┴┴───┴─┴┴┴
+ *
+ * @param {string} input
+ */ function clipAtBalancedParens(input) {
+    // We are care about this for arbitrary values
+    if (!input.includes("-[")) {
+        return input;
+    }
+    let depth = 0;
+    let openStringTypes = [];
+    // Find all parens, brackets, quotes, etc
+    // Stop when we end at a balanced pair
+    // This is naive and will treat mismatched parens as balanced
+    // This shouldn't be a problem in practice though
+    let matches = input.matchAll(SPECIALS);
+    // We can't use lookbehind assertions because we have to support Safari
+    // So, instead, we've emulated it using capture groups and we'll re-work the matches to accommodate
+    matches = Array.from(matches).flatMap((match)=>{
+        const [, ...groups] = match;
+        return groups.map((group, idx)=>Object.assign([], match, {
+                index: match.index + idx,
+                0: group
+            })
+        );
+    });
+    for (let match1 of matches){
+        let char = match1[0];
+        let inStringType = openStringTypes[openStringTypes.length - 1];
+        if (char === inStringType) {
+            openStringTypes.pop();
+        } else if (char === "'" || char === '"' || char === "`") {
+            openStringTypes.push(char);
+        }
+        if (inStringType) {
+            continue;
+        } else if (char === "[") {
+            depth++;
+            continue;
+        } else if (char === "]") {
+            depth--;
+            continue;
+        }
+        // We've gone one character past the point where we should stop
+        // This means that there was an extra closing `]`
+        // We'll clip to just before it
+        if (depth < 0) {
+            return input.substring(0, match1.index);
+        }
+        // We've finished balancing the brackets but there still may be characters that can be included
+        // For example in the class `text-[#336699]/[.35]`
+        // The depth goes to `0` at the closing `]` but goes up again at the `[`
+        // If we're at zero and encounter a non-class character then we clip the class there
+        if (depth === 0 && !ALLOWED_CLASS_CHARACTERS.test(char)) {
+            return input.substring(0, match1.index);
+        }
+    }
+    return input;
 } // Regular utilities
  // {{modifier}:}*{namespace}{-{suffix}}*{/{opacityModifier}}?
  // Arbitrary values

package/lib/lib/expandApplyAtRules.js

@@ -47,6 +47,14 @@ function _interopRequireDefault(obj) {
         groups: normalizedGroups
     });
 }
+let selectorExtractor = (0, _postcssSelectorParser).default((root)=>root.nodes.map((node)=>node.toString()
+    )
+);
+/**
+ * @param {string} ruleSelectors
+ */ function extractSelectors(ruleSelectors) {
+    return selectorExtractor.transformSync(ruleSelectors);
+}
 function extractBaseCandidates(candidates, separator) {
     let baseClasses = new Set();
     for (let candidate of candidates){
@@ -281,8 +289,8 @@ function processApply(root, context, localCache) {
                 needle1.replace(/\\2c /g, "\\,")
             ])
         ];
-        let utilitySelectorsList = utilitySelectors.split(/\s*(?<!\\)\,(?![^(]*\))\s*/g);
-        return selector.split(/\s*(?<!\\)\,(?![^(]*\))\s*/g).map((s)=>{
+        let utilitySelectorsList = extractSelectors(utilitySelectors);
+        return extractSelectors(selector).map((s)=>{
             let replaced = [];
             for (let utilitySelector of utilitySelectorsList){
                 let replacedSelector = utilitySelector;
@@ -429,7 +437,17 @@ function processApply(root, context, localCache) {
                             rule.remove();
                             return;
                         }
-                        rule.selector = replaceSelector(parent.selector, rule.selector, applyCandidate);
+                        // Strip the important selector from the parent selector if at the beginning
+                        let importantSelector = typeof context.tailwindConfig.important === "string" ? context.tailwindConfig.important : null;
+                        // We only want to move the "important" selector if this is a Tailwind-generated utility
+                        // We do *not* want to do this for user CSS that happens to be structured the same
+                        let isGenerated = parent.raws.tailwind !== undefined;
+                        let parentSelector = isGenerated && importantSelector && parent.selector.indexOf(importantSelector) === 0 ? parent.selector.slice(importantSelector.length) : parent.selector;
+                        rule.selector = replaceSelector(parentSelector, rule.selector, applyCandidate);
+                        // And then re-add it if it was removed
+                        if (importantSelector && parentSelector !== parent.selector) {
+                            rule.selector = `${importantSelector} ${rule.selector}`;
+                        }
                         rule.walkDecls((d)=>{
                             d.important = meta.important || important;
                         });

package/lib/lib/expandTailwindAtRules.js

@@ -42,7 +42,7 @@ function expandTailwindAtRules(context) {
         env.DEBUG && console.time("Reading changed files");
         for (let { content , extension  } of context.changedContent){
             let transformer = getTransformer(context.tailwindConfig, extension);
-            let extractor = getExtractor(context.tailwindConfig, extension);
+            let extractor = getExtractor(context, extension);
             getClassCandidates(transformer(content), extractor, candidates, seen);
         }
         env.DEBUG && console.timeEnd("Reading changed files");
@@ -174,9 +174,9 @@ const builtInTransformers = {
     ,
     svelte: (content)=>content.replace(/(?:^|\s)class:/g, " ")
 };
-function getExtractor(tailwindConfig, fileExtension) {
-    let extractors = tailwindConfig.content.extract;
-    return extractors[fileExtension] || extractors.DEFAULT || builtInExtractors[fileExtension] || builtInExtractors.DEFAULT;
+function getExtractor(context, fileExtension) {
+    let extractors = context.tailwindConfig.content.extract;
+    return extractors[fileExtension] || extractors.DEFAULT || builtInExtractors[fileExtension] || builtInExtractors.DEFAULT(context);
 }
 function getTransformer(tailwindConfig, fileExtension) {
     let transformers = tailwindConfig.content.transform;

package/lib/lib/generateRules.js

@@ -14,7 +14,9 @@ var sharedState = _interopRequireWildcard(require("./sharedState"));
 var _formatVariantSelector = require("../util/formatVariantSelector");
 var _nameClass = require("../util/nameClass");
 var _dataTypes = require("../util/dataTypes");
+var _setupContextUtils = require("./setupContextUtils");
 var _isValidArbitraryValue = _interopRequireDefault(require("../util/isValidArbitraryValue"));
+var _splitAtTopLevelOnlyJs = require("../util/splitAtTopLevelOnly.js");
 function _interopRequireDefault(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -151,6 +153,28 @@ function applyVariant(variant, matches, context) {
     if (matches.length === 0) {
         return matches;
     }
+    let args;
+    // Find partial arbitrary variants
+    if (variant.endsWith("]") && !variant.startsWith("[")) {
+        args = variant.slice(variant.lastIndexOf("[") + 1, -1);
+        variant = variant.slice(0, variant.indexOf(args) - 1 /* - */  - 1 /* [ */ );
+    }
+    // Register arbitrary variants
+    if (isArbitraryValue(variant) && !context.variantMap.has(variant)) {
+        let selector = (0, _dataTypes).normalize(variant.slice(1, -1));
+        if (!(0, _setupContextUtils).isValidVariantFormatString(selector)) {
+            return [];
+        }
+        let fn = (0, _setupContextUtils).parseVariant(selector);
+        let sort = Array.from(context.variantOrder.values()).pop() << 1n;
+        context.variantMap.set(variant, [
+            [
+                sort,
+                fn
+            ]
+        ]);
+        context.variantOrder.set(variant, sort);
+    }
     if (context.variantMap.has(variant)) {
         let variantFunctionTuples = context.variantMap.get(variant);
         let result = [];
@@ -207,7 +231,8 @@ function applyVariant(variant, matches, context) {
                     },
                     format (selectorFormat) {
                         collectedFormats.push(selectorFormat);
-                    }
+                    },
+                    args
                 });
                 if (typeof ruleWithVariant === "string") {
                     collectedFormats.push(ruleWithVariant);
@@ -416,7 +441,7 @@ function splitWithSeparator(input, separator) {
             sharedState.NOT_ON_DEMAND
         ];
     }
-    return input.split(new RegExp(`\\${separator}(?![^[]*\\])`, "g"));
+    return Array.from((0, _splitAtTopLevelOnlyJs).splitAtTopLevelOnly(input, separator));
 }
 function* recordCandidates(matches, classCandidate) {
     for (const match of matches){

package/lib/lib/regex.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+exports.pattern = pattern;
+exports.withoutCapturing = withoutCapturing;
+exports.any = any;
+exports.optional = optional;
+exports.zeroOrMore = zeroOrMore;
+exports.nestedBrackets = nestedBrackets;
+exports.escape = escape;
+const REGEX_SPECIAL = /[\\^$.*+?()[\]{}|]/g;
+const REGEX_HAS_SPECIAL = RegExp(REGEX_SPECIAL.source);
+/**
+ * @param {string|RegExp|Array<string|RegExp>} source
+ */ function toSource(source) {
+    source = Array.isArray(source) ? source : [
+        source
+    ];
+    source = source.map((item)=>item instanceof RegExp ? item.source : item
+    );
+    return source.join("");
+}
+function pattern(source) {
+    return new RegExp(toSource(source), "g");
+}
+function withoutCapturing(source) {
+    return new RegExp(`(?:${toSource(source)})`, "g");
+}
+function any(sources) {
+    return `(?:${sources.map(toSource).join("|")})`;
+}
+function optional(source) {
+    return `(?:${toSource(source)})?`;
+}
+function zeroOrMore(source) {
+    return `(?:${toSource(source)})*`;
+}
+function nestedBrackets(open, close, depth = 1) {
+    return withoutCapturing([
+        escape(open),
+        /[^\s]*/,
+        depth === 1 ? `[^${escape(open)}${escape(close)}\s]*` : any([
+            `[^${escape(open)}${escape(close)}\s]*`,
+            nestedBrackets(open, close, depth - 1)
+        ]),
+        /[^\s]*/,
+        escape(close), 
+    ]);
+}
+function escape(string) {
+    return string && REGEX_HAS_SPECIAL.test(string) ? string.replace(REGEX_SPECIAL, "\\$&") : string || "";
+}