tailwindcss 0.0.0-insiders.d3e754a → 0.0.0-insiders.d3f2221

package/lib/util/pseudoElements.js

@@ -0,0 +1,209 @@
+/** @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 */ // There are some pseudo-elements that may or may not be:
+// **Actionable**
+// Zero or more user-action pseudo-classes may be attached to the pseudo-element itself
+// structural-pseudo-classes are NOT allowed but we don't make
+// The spec is not clear on whether this is allowed or not — but in practice it is.
+// **Terminal**
+// It MUST be placed at the end of a selector
+//
+// This is the required in the spec. However, some pseudo elements are not "terminal" because
+// they represent a "boundary piercing" that is compiled out by a build step.
+// **Jumpable**
+// Any terminal element may "jump" over combinators when moving to the end of the selector
+//
+// This is a backwards-compat quirk of pseudo element variants from earlier versions of Tailwind CSS.
+/** @typedef {'terminal' | 'actionable' | 'jumpable'} PseudoProperty */ /** @type {Record<string, PseudoProperty[]>} */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "movePseudos", {
+    enumerable: true,
+    get: function() {
+        return movePseudos;
+    }
+});
+let elementProperties = {
+    // Pseudo elements from the spec
+    '::after': [
+        'terminal',
+        'jumpable'
+    ],
+    '::backdrop': [
+        'terminal',
+        'jumpable'
+    ],
+    '::before': [
+        'terminal',
+        'jumpable'
+    ],
+    '::cue': [
+        'terminal'
+    ],
+    '::cue-region': [
+        'terminal'
+    ],
+    '::first-letter': [
+        'terminal',
+        'jumpable'
+    ],
+    '::first-line': [
+        'terminal',
+        'jumpable'
+    ],
+    '::grammar-error': [
+        'terminal'
+    ],
+    '::marker': [
+        'terminal',
+        'jumpable'
+    ],
+    '::part': [
+        'terminal',
+        'actionable'
+    ],
+    '::placeholder': [
+        'terminal',
+        'jumpable'
+    ],
+    '::selection': [
+        'terminal',
+        'jumpable'
+    ],
+    '::slotted': [
+        'terminal'
+    ],
+    '::spelling-error': [
+        'terminal'
+    ],
+    '::target-text': [
+        'terminal'
+    ],
+    // Pseudo elements from the spec with special rules
+    '::file-selector-button': [
+        'terminal',
+        'actionable'
+    ],
+    // Library-specific pseudo elements used by component libraries
+    // These are Shadow DOM-like
+    '::deep': [
+        'actionable'
+    ],
+    '::v-deep': [
+        'actionable'
+    ],
+    '::ng-deep': [
+        'actionable'
+    ],
+    // 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.
+    ':after': [
+        'terminal',
+        'jumpable'
+    ],
+    ':before': [
+        'terminal',
+        'jumpable'
+    ],
+    ':first-letter': [
+        'terminal',
+        'jumpable'
+    ],
+    ':first-line': [
+        'terminal',
+        'jumpable'
+    ],
+    // The default value is used when the pseudo-element is not recognized
+    // Because it's not recognized, we don't know if it's terminal or not
+    // So we assume it can be moved AND can have user-action pseudo classes attached to it
+    __default__: [
+        'terminal',
+        'actionable'
+    ]
+};
+function movePseudos(sel) {
+    let [pseudos] = movablePseudos(sel);
+    // Remove all pseudo elements from their respective selectors
+    pseudos.forEach(([sel, pseudo])=>sel.removeChild(pseudo));
+    // Re-add them to the end of the selector in the correct order.
+    // This moves terminal pseudo elements to the end of the
+    // selector otherwise the selector will not be valid.
+    //
+    // Examples:
+    //  - `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`
+    //
+    // The selector `::before:hover` does not work but we
+    // can make it work for you by flipping the order.
+    sel.nodes.push(...pseudos.map(([, pseudo])=>pseudo));
+    return sel;
+}
+/** @typedef {[sel: Selector, pseudo: Pseudo, attachedTo: Pseudo | null]} MovablePseudo */ /** @typedef {[pseudos: MovablePseudo[], lastSeenElement: Pseudo | null]} MovablePseudosResult */ /**
+ * @param {Selector} sel
+ * @returns {MovablePseudosResult}
+ */ function movablePseudos(sel) {
+    /** @type {MovablePseudo[]} */ let buffer = [];
+    /** @type {Pseudo | null} */ let lastSeenElement = null;
+    for (let node of sel.nodes){
+        if (node.type === 'combinator') {
+            buffer = buffer.filter(([, node])=>propertiesForPseudo(node).includes('jumpable'));
+            lastSeenElement = null;
+        } else if (node.type === 'pseudo') {
+            if (isMovablePseudoElement(node)) {
+                lastSeenElement = node;
+                buffer.push([
+                    sel,
+                    node,
+                    null
+                ]);
+            } else if (lastSeenElement && isAttachablePseudoClass(node, lastSeenElement)) {
+                buffer.push([
+                    sel,
+                    node,
+                    lastSeenElement
+                ]);
+            } else {
+                lastSeenElement = null;
+            }
+            var _node_nodes;
+            for (let sub of (_node_nodes = node.nodes) !== null && _node_nodes !== void 0 ? _node_nodes : []){
+                let [movable, lastSeenElementInSub] = movablePseudos(sub);
+                lastSeenElement = lastSeenElementInSub || lastSeenElement;
+                buffer.push(...movable);
+            }
+        }
+    }
+    return [
+        buffer,
+        lastSeenElement
+    ];
+}
+/**
+ * @param {Node} node
+ * @returns {boolean}
+ */ function isPseudoElement(node) {
+    return node.value.startsWith('::') || elementProperties[node.value] !== undefined;
+}
+/**
+ * @param {Node} node
+ * @returns {boolean}
+ */ function isMovablePseudoElement(node) {
+    return isPseudoElement(node) && propertiesForPseudo(node).includes('terminal');
+}
+/**
+ * @param {Node} node
+ * @param {Pseudo} pseudo
+ * @returns {boolean}
+ */ function isAttachablePseudoClass(node, pseudo) {
+    if (node.type !== 'pseudo') return false;
+    if (isPseudoElement(node)) return false;
+    return propertiesForPseudo(pseudo).includes('actionable');
+}
+/**
+ * @param {Pseudo} pseudo
+ * @returns {PseudoProperty[]}
+ */ function propertiesForPseudo(pseudo) {
+    var _elementProperties_pseudo_value;
+    return (_elementProperties_pseudo_value = elementProperties[pseudo.value]) !== null && _elementProperties_pseudo_value !== void 0 ? _elementProperties_pseudo_value : elementProperties.__default__;
+}

package/lib/util/removeAlphaVariables.js

@@ -0,0 +1,31 @@
+/**
+ * This function removes any uses of CSS variables used as an alpha channel
+ *
+ * This is required for selectors like `:visited` which do not allow
+ * changes in opacity or external control using CSS variables.
+ *
+ * @param {import('postcss').Container} container
+ * @param {string[]} toRemove
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "removeAlphaVariables", {
+    enumerable: true,
+    get: function() {
+        return removeAlphaVariables;
+    }
+});
+function removeAlphaVariables(container, toRemove) {
+    container.walkDecls((decl)=>{
+        if (toRemove.includes(decl.prop)) {
+            decl.remove();
+            return;
+        }
+        for (let varName of toRemove){
+            if (decl.value.includes(`/ var(${varName})`)) {
+                decl.value = decl.value.replace(`/ var(${varName})`, '');
+            }
+        }
+    });
+}

package/lib/util/resolveConfig.js

@@ -2,18 +2,25 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-exports.default = resolveConfig;
-var _negateValue = _interopRequireDefault(require("./negateValue"));
-var _corePluginList = _interopRequireDefault(require("../corePluginList"));
-var _configurePlugins = _interopRequireDefault(require("./configurePlugins"));
-var _defaultConfigStub = _interopRequireDefault(require("../../stubs/defaultConfig.stub"));
-var _colors = _interopRequireDefault(require("../public/colors"));
-var _defaults = require("./defaults");
-var _toPath = require("./toPath");
-var _normalizeConfig = require("./normalizeConfig");
-var _isPlainObject = _interopRequireDefault(require("./isPlainObject"));
-var _cloneDeep = require("./cloneDeep");
-function _interopRequireDefault(obj) {
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return resolveConfig;
+    }
+});
+const _negateValue = /*#__PURE__*/ _interop_require_default(require("./negateValue"));
+const _corePluginList = /*#__PURE__*/ _interop_require_default(require("../corePluginList"));
+const _configurePlugins = /*#__PURE__*/ _interop_require_default(require("./configurePlugins"));
+const _colors = /*#__PURE__*/ _interop_require_default(require("../public/colors"));
+const _defaults = require("./defaults");
+const _toPath = require("./toPath");
+const _normalizeConfig = require("./normalizeConfig");
+const _isPlainObject = /*#__PURE__*/ _interop_require_default(require("./isPlainObject"));
+const _cloneDeep = require("./cloneDeep");
+const _pluginUtils = require("./pluginUtils");
+const _withAlphaVariable = require("./withAlphaVariable");
+const _toColorValue = /*#__PURE__*/ _interop_require_default(require("./toColorValue"));
+function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
@@ -21,17 +28,14 @@ function _interopRequireDefault(obj) {
 function isFunction(input) {
     return typeof input === 'function';
 }
-function isObject(input) {
-    return typeof input === 'object' && input !== null;
-}
 function mergeWith(target, ...sources) {
     let customizer = sources.pop();
     for (let source of sources){
         for(let k in source){
             let merged = customizer(target[k], source[k]);
             if (merged === undefined) {
-                if (isObject(target[k]) && isObject(source[k])) {
-                    target[k] = mergeWith(target[k], source[k], customizer);
+                if ((0, _isPlainObject.default)(target[k]) && (0, _isPlainObject.default)(source[k])) {
+                    target[k] = mergeWith({}, target[k], source[k], customizer);
                 } else {
                     target[k] = source[k];
                 }
@@ -46,9 +50,8 @@ 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)=>{
-            let negativeValue = (0, _negateValue).default(scale[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;
             }
@@ -56,19 +59,17 @@ 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) {
     return isFunction(valueToResolve) ? valueToResolve(...args) : valueToResolve;
 }
 function collectExtends(items) {
-    return items.reduce((merged, { extend  })=>{
+    return items.reduce((merged, { extend })=>{
         return mergeWith(merged, extend, (mergedValue, extendValue)=>{
             if (mergedValue === undefined) {
                 return [
@@ -90,33 +91,32 @@ 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)
     };
 }
-function mergeExtensionCustomizer(merged, value1) {
+function mergeExtensionCustomizer(merged, value) {
     // When we have an array of objects, we do want to merge it
-    if (Array.isArray(merged) && isObject(merged[0])) {
-        return merged.concat(value1);
+    if (Array.isArray(merged) && (0, _isPlainObject.default)(merged[0])) {
+        return merged.concat(value);
     }
     // When the incoming value is an array, and the existing config is an object, prepend the existing object
-    if (Array.isArray(value1) && isObject(value1[0]) && isObject(merged)) {
+    if (Array.isArray(value) && (0, _isPlainObject.default)(value[0]) && (0, _isPlainObject.default)(merged)) {
         return [
             merged,
-            ...value1
+            ...value
         ];
     }
     // Override arrays (for example for font-families, box-shadows, ...)
-    if (Array.isArray(value1)) {
-        return value1;
+    if (Array.isArray(value)) {
+        return value;
     }
     // Execute default behaviour
     return undefined;
 }
-function mergeExtensions({ extend , ...theme }) {
+function mergeExtensions({ extend, ...theme }) {
     return mergeWith(theme, extend, (themeValue, extensions)=>{
         // The `extend` property is an array, so we need to check if it contains any functions
         if (!isFunction(themeValue) && !extensions.some(isFunction)) {
@@ -125,60 +125,87 @@ 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) {
     let allConfigs = [];
     configs.forEach((config)=>{
+        var _config;
         allConfigs = [
             ...allConfigs,
             config
         ];
-        var ref1;
-        const plugins = (ref1 = config === null || config === void 0 ? void 0 : config.plugins) !== null && ref1 !== void 0 ? ref1 : [];
+        var _config_plugins;
+        const plugins = (_config_plugins = (_config = config) === null || _config === void 0 ? void 0 : _config.plugins) !== null && _config_plugins !== void 0 ? _config_plugins : [];
         if (plugins.length === 0) {
             return;
         }
         plugins.forEach((plugin)=>{
+            var _plugin;
             if (plugin.__isOptionsFunction) {
                 plugin = plugin();
             }
-            var ref;
+            var _plugin_config;
             allConfigs = [
                 ...allConfigs,
                 ...extractPluginConfigs([
-                    (ref = plugin === null || plugin === void 0 ? void 0 : plugin.config) !== null && ref !== void 0 ? ref : {}
+                    (_plugin_config = (_plugin = plugin) === null || _plugin === void 0 ? void 0 : _plugin.config) !== null && _plugin_config !== void 0 ? _plugin_config : {}
                 ])
             ];
         });
@@ -194,7 +221,7 @@ function resolveCorePlugins(corePluginConfigs) {
                 corePlugins: resolved
             });
         }
-        return (0, _configurePlugins).default(corePluginConfig, resolved);
+        return (0, _configurePlugins.default)(corePluginConfig, resolved);
     }, _corePluginList.default);
     return result;
 }
@@ -215,19 +242,19 @@ function resolveConfig(configs) {
         {
             prefix: '',
             important: false,
-            separator: ':',
-            variantOrder: _defaultConfigStub.default.variantOrder
-        }, 
+            separator: ':'
+        }
     ];
-    var ref, ref2;
-    return (0, _normalizeConfig).normalizeConfig((0, _defaults).defaults({
+    var _t_theme, _c_plugins;
+    return (0, _normalizeConfig.normalizeConfig)((0, _defaults.defaults)({
         theme: resolveFunctionKeys(mergeExtensions(mergeThemes(allConfigs.map((t)=>{
-            return (ref = t === null || t === void 0 ? void 0 : t.theme) !== null && ref !== void 0 ? ref : {};
+            var _t;
+            return (_t_theme = (_t = t) === null || _t === void 0 ? void 0 : _t.theme) !== null && _t_theme !== void 0 ? _t_theme : {};
         })))),
-        corePlugins: resolveCorePlugins(allConfigs.map((c)=>c.corePlugins
-        )),
+        corePlugins: resolveCorePlugins(allConfigs.map((c)=>c.corePlugins)),
         plugins: resolvePluginLists(configs.map((c)=>{
-            return (ref2 = c === null || c === void 0 ? void 0 : c.plugins) !== null && ref2 !== void 0 ? ref2 : [];
+            var _c;
+            return (_c_plugins = (_c = c) === null || _c === void 0 ? void 0 : _c.plugins) !== null && _c_plugins !== void 0 ? _c_plugins : [];
         }))
     }, ...allConfigs));
 }

package/lib/util/resolveConfigPath.js

@@ -2,14 +2,33 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-exports.default = resolveConfigPath;
-var _fs = _interopRequireDefault(require("fs"));
-var _path = _interopRequireDefault(require("path"));
-function _interopRequireDefault(obj) {
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    default: function() {
+        return resolveConfigPath;
+    },
+    resolveDefaultConfigPath: function() {
+        return resolveDefaultConfigPath;
+    }
+});
+const _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
 }
+const defaultConfigFiles = [
+    './tailwind.config.js',
+    './tailwind.config.cjs',
+    './tailwind.config.mjs',
+    './tailwind.config.ts'
+];
 function isObject(value) {
     return typeof value === 'object' && value !== null;
 }
@@ -37,10 +56,10 @@ function resolveConfigPath(pathOrConfig) {
         return _path.default.resolve(pathOrConfig);
     }
     // require('tailwindcss')
-    for (const configFile of [
-        './tailwind.config.js',
-        './tailwind.config.cjs'
-    ]){
+    return resolveDefaultConfigPath();
+}
+function resolveDefaultConfigPath() {
+    for (const configFile of defaultConfigFiles){
         try {
             const configPath = _path.default.resolve(configFile);
             _fs.default.accessSync(configPath);

package/lib/util/responsive.js

@@ -2,10 +2,15 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-exports.default = responsive;
-var _postcss = _interopRequireDefault(require("postcss"));
-var _cloneNodes = _interopRequireDefault(require("./cloneNodes"));
-function _interopRequireDefault(obj) {
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return responsive;
+    }
+});
+const _postcss = /*#__PURE__*/ _interop_require_default(require("postcss"));
+const _cloneNodes = /*#__PURE__*/ _interop_require_default(require("./cloneNodes"));
+function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
@@ -13,7 +18,7 @@ function _interopRequireDefault(obj) {
 function responsive(rules) {
     return _postcss.default.atRule({
         name: 'responsive'
-    }).append((0, _cloneNodes).default(Array.isArray(rules) ? rules : [
+    }).append((0, _cloneNodes.default)(Array.isArray(rules) ? rules : [
         rules
     ]));
 }

package/lib/util/splitAtTopLevelOnly.js

@@ -0,0 +1,51 @@
+/**
+ * This splits a string on a top-level character.
+ *
+ * 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 placement.
+ *
+ * Expected behavior using commas:
+ * 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
+ * @param {string} separator
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "splitAtTopLevelOnly", {
+    enumerable: true,
+    get: function() {
+        return splitAtTopLevelOnly;
+    }
+});
+function splitAtTopLevelOnly(input, separator) {
+    let stack = [];
+    let parts = [];
+    let lastPos = 0;
+    let isEscaped = false;
+    for(let idx = 0; idx < input.length; idx++){
+        let char = input[idx];
+        if (stack.length === 0 && char === separator[0] && !isEscaped) {
+            if (separator.length === 1 || input.slice(idx, idx + separator.length) === separator) {
+                parts.push(input.slice(lastPos, idx));
+                lastPos = idx + separator.length;
+            }
+        }
+        if (isEscaped) {
+            isEscaped = false;
+        } else if (char === '\\') {
+            isEscaped = true;
+        }
+        if (char === '(' || char === '[' || char === '{') {
+            stack.push(char);
+        } else if (char === ')' && stack[stack.length - 1] === '(' || char === ']' && stack[stack.length - 1] === '[' || char === '}' && stack[stack.length - 1] === '{') {
+            stack.pop();
+        }
+    }
+    parts.push(input.slice(lastPos));
+    return parts;
+}

package/lib/util/tap.js

@@ -2,7 +2,12 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-exports.tap = tap;
+Object.defineProperty(exports, "tap", {
+    enumerable: true,
+    get: function() {
+        return tap;
+    }
+});
 function tap(value, mutator) {
     mutator(value);
     return value;