tailwindcss 0.0.0-oxide-insiders.a7fe2fe → 0.0.0-oxide-insiders.7f555c4

package/lib/util/resolveConfig.js

@@ -1,137 +1,256 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", {
-    value: !0
-}), Object.defineProperty(exports, "default", {
-    enumerable: !0,
-    get: ()=>resolveConfig
+    value: true
 });
-const _negateValue = _interopRequireDefault(require("./negateValue")), _corePluginList = _interopRequireDefault(require("../corePluginList")), _configurePlugins = _interopRequireDefault(require("./configurePlugins")), _colors = _interopRequireDefault(require("../public/colors")), _defaults = require("./defaults"), _toPath = require("./toPath"), _normalizeConfig = require("./normalizeConfig"), _isPlainObject = _interopRequireDefault(require("./isPlainObject")), _cloneDeep = require("./cloneDeep"), _pluginUtils = require("./pluginUtils"), _withAlphaVariable = require("./withAlphaVariable"), _toColorValue = _interopRequireDefault(require("./toColorValue"));
-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
     };
 }
 function isFunction(input) {
-    return "function" == typeof input;
+    return typeof input === "function";
 }
 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]);
-        void 0 === merged ? (0, _isPlainObject.default)(target[k]) && (0, _isPlainObject.default)(source[k]) ? target[k] = mergeWith({}, target[k], source[k], customizer) : target[k] = source[k] : target[k] = merged;
+    for (let source of sources){
+        for(let k in source){
+            let merged = customizer(target[k], source[k]);
+            if (merged === undefined) {
+                if ((0, _isPlainObject.default)(target[k]) && (0, _isPlainObject.default)(source[k])) {
+                    target[k] = mergeWith({}, target[k], source[k], customizer);
+                } else {
+                    target[k] = source[k];
+                }
+            } else {
+                target[k] = merged;
+            }
+        }
     }
     return target;
 }
 const configUtils = {
     colors: _colors.default,
-    negative: (scale)=>Object.keys(scale).filter((key)=>"0" !== scale[key]).reduce((negativeScale, key)=>{
+    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 void 0 !== negativeValue && (negativeScale[`-${key}`] = negativeValue), negativeScale;
-        }, {}),
-    breakpoints: (screens)=>Object.keys(screens).filter((key)=>"string" == typeof screens[key]).reduce((breakpoints, key)=>({
+            if (negativeValue !== undefined) {
+                negativeScale[`-${key}`] = negativeValue;
+            }
+            return negativeScale;
+        }, {});
+    },
+    breakpoints (screens) {
+        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 mergeWith(merged, extend, (mergedValue, extendValue)=>{
+            if (mergedValue === undefined) {
+                return [
+                    extendValue
+                ];
+            }
+            if (Array.isArray(mergedValue)) {
+                return [
+                    extendValue,
+                    ...mergedValue
+                ];
+            }
+            return [
+                extendValue,
+                mergedValue
+            ];
+        });
+    }, {});
+}
+function mergeThemes(themes) {
+    return {
+        ...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, value) {
-    return Array.isArray(merged) && (0, _isPlainObject.default)(merged[0]) ? merged.concat(value) : Array.isArray(value) && (0, _isPlainObject.default)(value[0]) && (0, _isPlainObject.default)(merged) ? [
-        merged,
-        ...value
-    ] : Array.isArray(value) ? value : void 0;
+    // When we have an array of objects, we do want to merge it
+    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(value) && (0, _isPlainObject.default)(value[0]) && (0, _isPlainObject.default)(merged)) {
+        return [
+            merged,
+            ...value
+        ];
+    }
+    // Override arrays (for example for font-families, box-shadows, ...)
+    if (Array.isArray(value)) {
+        return value;
+    }
+    // Execute default behaviour
+    return undefined;
+}
+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)) {
+            return mergeWith({}, themeValue, ...extensions, mergeExtensionCustomizer);
+        }
+        return (resolveThemePath, utils)=>mergeWith({}, ...[
+                themeValue,
+                ...extensions
+            ].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)=>{
+        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 defaultValue;
+    };
+    Object.assign(resolvePath, {
+        theme: resolvePath,
+        ...configUtils
+    });
+    return Object.keys(object).reduce((resolved, key)=>{
+        resolved[key] = isFunction(object[key]) ? object[key](resolvePath, configUtils) : object[key];
+        return resolved;
+    }, {});
+}
+function extractPluginConfigs(configs) {
+    let allConfigs = [];
+    configs.forEach((config)=>{
+        allConfigs = [
+            ...allConfigs,
+            config
+        ];
+        var _config_plugins;
+        const plugins = (_config_plugins = config === null || config === void 0 ? void 0 : config.plugins) !== null && _config_plugins !== void 0 ? _config_plugins : [];
+        if (plugins.length === 0) {
+            return;
+        }
+        plugins.forEach((plugin)=>{
+            if (plugin.__isOptionsFunction) {
+                plugin = plugin();
+            }
+            var _plugin_config;
+            allConfigs = [
+                ...allConfigs,
+                ...extractPluginConfigs([
+                    (_plugin_config = plugin === null || plugin === void 0 ? void 0 : plugin.config) !== null && _plugin_config !== void 0 ? _plugin_config : {}
+                ])
+            ];
+        });
+    });
+    return allConfigs;
+}
+function resolveCorePlugins(corePluginConfigs) {
+    const result = [
+        ...corePluginConfigs
+    ].reduceRight((resolved, corePluginConfig)=>{
+        if (isFunction(corePluginConfig)) {
+            return corePluginConfig({
+                corePlugins: resolved
+            });
+        }
+        return (0, _configurePlugins.default)(corePluginConfig, resolved);
+    }, _corePluginList.default);
+    return result;
+}
+function resolvePluginLists(pluginLists) {
+    const result = [
+        ...pluginLists
+    ].reduceRight((resolved, pluginList)=>{
+        return [
+            ...resolved,
+            ...pluginList
+        ];
+    }, []);
+    return result;
 }
 function resolveConfig(configs) {
-    var _t_theme, _c_plugins, themes;
     let allConfigs = [
-        ...function extractPluginConfigs(configs) {
-            let allConfigs = [];
-            return configs.forEach((config)=>{
-                var _config_plugins;
-                allConfigs = [
-                    ...allConfigs,
-                    config
-                ];
-                let plugins = null !== (_config_plugins = null == config ? void 0 : config.plugins) && void 0 !== _config_plugins ? _config_plugins : [];
-                0 !== plugins.length && plugins.forEach((plugin)=>{
-                    var _plugin_config;
-                    plugin.__isOptionsFunction && (plugin = plugin()), allConfigs = [
-                        ...allConfigs,
-                        ...extractPluginConfigs([
-                            null !== (_plugin_config = null == plugin ? void 0 : plugin.config) && void 0 !== _plugin_config ? _plugin_config : {}
-                        ])
-                    ];
-                });
-            }), allConfigs;
-        }(configs),
+        ...extractPluginConfigs(configs),
         {
             prefix: "",
-            important: !1,
+            important: false,
             separator: ":"
         }
     ];
+    var _t_theme, _c_plugins;
     return (0, _normalizeConfig.normalizeConfig)((0, _defaults.defaults)({
-        theme: function(object) {
-            let resolvePath = (key, defaultValue)=>{
-                for (let path of function*(key) {
-                    let path = (0, _toPath.toPath)(key);
-                    if (0 === path.length || (yield path, Array.isArray(key))) return;
-                    let matches = key.match(/^(.*?)\s*\/\s*([^/]+)$/);
-                    if (null !== matches) {
-                        let [, prefix, alpha] = matches, newPath = (0, _toPath.toPath)(prefix);
-                        newPath.alpha = alpha, yield newPath;
-                    }
-                }(key)){
-                    let index = 0, val = object;
-                    for(; null != val && index < path.length;)val = isFunction(val = val[path[index++]]) && (void 0 === path.alpha || index <= path.length - 1) ? val(resolvePath, configUtils) : val;
-                    if (void 0 !== val) {
-                        if (void 0 !== path.alpha) {
-                            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 defaultValue;
-            };
-            return Object.assign(resolvePath, {
-                theme: resolvePath,
-                ...configUtils
-            }), Object.keys(object).reduce((resolved, key)=>(resolved[key] = isFunction(object[key]) ? object[key](resolvePath, configUtils) : object[key], resolved), {});
-        }(function({ extend , ...theme }) {
-            return mergeWith(theme, extend, (themeValue, extensions)=>isFunction(themeValue) || extensions.some(isFunction) ? (resolveThemePath, utils)=>mergeWith({}, ...[
-                        themeValue,
-                        ...extensions
-                    ].map((e)=>(function(valueToResolve, ...args) {
-                            return isFunction(valueToResolve) ? valueToResolve(...args) : valueToResolve;
-                        })(e, resolveThemePath, utils)), mergeExtensionCustomizer) : mergeWith({}, themeValue, ...extensions, mergeExtensionCustomizer));
-        }({
-            ...(themes = allConfigs.map((t)=>null !== (_t_theme = null == t ? void 0 : t.theme) && void 0 !== _t_theme ? _t_theme : {})).reduce((merged, theme)=>(0, _defaults.defaults)(merged, theme), {}),
-            extend: themes.reduce((merged, { extend  })=>mergeWith(merged, extend, (mergedValue, extendValue)=>void 0 === mergedValue ? [
-                        extendValue
-                    ] : Array.isArray(mergedValue) ? [
-                        extendValue,
-                        ...mergedValue
-                    ] : [
-                        extendValue,
-                        mergedValue
-                    ]), {})
-        })),
-        corePlugins: function(corePluginConfigs) {
-            let result = [
-                ...corePluginConfigs
-            ].reduceRight((resolved, corePluginConfig)=>isFunction(corePluginConfig) ? corePluginConfig({
-                    corePlugins: resolved
-                }) : (0, _configurePlugins.default)(corePluginConfig, resolved), _corePluginList.default);
-            return result;
-        }(allConfigs.map((c)=>c.corePlugins)),
-        plugins: function(pluginLists) {
-            let result = [
-                ...pluginLists
-            ].reduceRight((resolved, pluginList)=>[
-                    ...resolved,
-                    ...pluginList
-                ], []);
-            return result;
-        }(configs.map((c)=>null !== (_c_plugins = null == c ? void 0 : c.plugins) && void 0 !== _c_plugins ? _c_plugins : []))
+        theme: resolveFunctionKeys(mergeExtensions(mergeThemes(allConfigs.map((t)=>{
+            return (_t_theme = t === null || t === void 0 ? void 0 : t.theme) !== null && _t_theme !== void 0 ? _t_theme : {};
+        })))),
+        corePlugins: resolveCorePlugins(allConfigs.map((c)=>c.corePlugins)),
+        plugins: resolvePluginLists(configs.map((c)=>{
+            return (_c_plugins = c === null || c === void 0 ? void 0 : c.plugins) !== null && _c_plugins !== void 0 ? _c_plugins : [];
+        }))
     }, ...allConfigs));
 }

package/lib/util/resolveConfigPath.js

@@ -1,17 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", {
-    value: !0
-}), function(target, all) {
+    value: true
+});
+function _export(target, all) {
     for(var name in all)Object.defineProperty(target, name, {
-        enumerable: !0,
+        enumerable: true,
         get: all[name]
     });
-}(exports, {
-    default: ()=>resolveConfigPath,
-    resolveDefaultConfigPath: ()=>resolveDefaultConfigPath
+}
+_export(exports, {
+    default: function() {
+        return resolveConfigPath;
+    },
+    resolveDefaultConfigPath: function() {
+        return resolveDefaultConfigPath;
+    }
 });
-const _fs = _interopRequireDefault(require("fs")), _path = _interopRequireDefault(require("path"));
-function _interopRequireDefault(obj) {
+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
     };
@@ -23,18 +30,41 @@ const defaultConfigFiles = [
     "./tailwind.config.ts"
 ];
 function isObject(value) {
-    return "object" == typeof value && null !== value;
+    return typeof value === "object" && value !== null;
+}
+function isEmpty(obj) {
+    return Object.keys(obj).length === 0;
 }
 function isString(value) {
-    return "string" == typeof value || value instanceof String;
+    return typeof value === "string" || value instanceof String;
 }
 function resolveConfigPath(pathOrConfig) {
-    return isObject(pathOrConfig) && void 0 === pathOrConfig.config && 0 !== Object.keys(pathOrConfig).length ? null : isObject(pathOrConfig) && void 0 !== pathOrConfig.config && isString(pathOrConfig.config) ? _path.default.resolve(pathOrConfig.config) : isObject(pathOrConfig) && void 0 !== pathOrConfig.config && isObject(pathOrConfig.config) ? null : isString(pathOrConfig) ? _path.default.resolve(pathOrConfig) : resolveDefaultConfigPath();
+    // require('tailwindcss')({ theme: ..., variants: ... })
+    if (isObject(pathOrConfig) && pathOrConfig.config === undefined && !isEmpty(pathOrConfig)) {
+        return null;
+    }
+    // require('tailwindcss')({ config: 'custom-config.js' })
+    if (isObject(pathOrConfig) && pathOrConfig.config !== undefined && isString(pathOrConfig.config)) {
+        return _path.default.resolve(pathOrConfig.config);
+    }
+    // require('tailwindcss')({ config: { theme: ..., variants: ... } })
+    if (isObject(pathOrConfig) && pathOrConfig.config !== undefined && isObject(pathOrConfig.config)) {
+        return null;
+    }
+    // require('tailwindcss')('custom-config.js')
+    if (isString(pathOrConfig)) {
+        return _path.default.resolve(pathOrConfig);
+    }
+    // require('tailwindcss')
+    return resolveDefaultConfigPath();
 }
 function resolveDefaultConfigPath() {
-    for (let configFile of defaultConfigFiles)try {
-        let configPath = _path.default.resolve(configFile);
-        return _fs.default.accessSync(configPath), configPath;
-    } catch (err) {}
+    for (const configFile of defaultConfigFiles){
+        try {
+            const configPath = _path.default.resolve(configFile);
+            _fs.default.accessSync(configPath);
+            return configPath;
+        } catch (err) {}
+    }
     return null;
 }

package/lib/util/responsive.js

@@ -1,12 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", {
-    value: !0
-}), Object.defineProperty(exports, "default", {
-    enumerable: !0,
-    get: ()=>responsive
+    value: true
 });
-const _postcss = _interopRequireDefault(require("postcss")), _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
     };

package/lib/util/splitAtTopLevelOnly.js

@@ -1,15 +1,51 @@
-"use strict";
+/**
+ * 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 = [], parts = [], lastPos = 0, isEscaped = !1;
+    let stack = [];
+    let parts = [];
+    let lastPos = 0;
+    let isEscaped = false;
     for(let idx = 0; idx < input.length; idx++){
         let char = input[idx];
-        0 !== stack.length || char !== separator[0] || isEscaped || 1 !== separator.length && input.slice(idx, idx + separator.length) !== separator || (parts.push(input.slice(lastPos, idx)), lastPos = idx + separator.length), isEscaped ? isEscaped = !1 : "\\" === char && (isEscaped = !0), "(" === char || "[" === char || "{" === char ? stack.push(char) : (")" === char && "(" === stack[stack.length - 1] || "]" === char && "[" === stack[stack.length - 1] || "}" === char && "{" === stack[stack.length - 1]) && stack.pop();
+        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();
+        }
     }
-    return parts.push(input.slice(lastPos)), parts;
+    parts.push(input.slice(lastPos));
+    return parts;
 }
-Object.defineProperty(exports, "__esModule", {
-    value: !0
-}), Object.defineProperty(exports, "splitAtTopLevelOnly", {
-    enumerable: !0,
-    get: ()=>splitAtTopLevelOnly
-});

package/lib/util/tap.js

@@ -1,10 +1,14 @@
 "use strict";
-function tap(value, mutator) {
-    return mutator(value), value;
-}
 Object.defineProperty(exports, "__esModule", {
-    value: !0
-}), Object.defineProperty(exports, "tap", {
-    enumerable: !0,
-    get: ()=>tap
+    value: true
+});
+Object.defineProperty(exports, "tap", {
+    enumerable: true,
+    get: function() {
+        return tap;
+    }
 });
+function tap(value, mutator) {
+    mutator(value);
+    return value;
+}

package/lib/util/toColorValue.js

@@ -1,10 +1,13 @@
 "use strict";
-function toColorValue(maybeFunction) {
-    return "function" == typeof maybeFunction ? maybeFunction({}) : maybeFunction;
-}
 Object.defineProperty(exports, "__esModule", {
-    value: !0
-}), Object.defineProperty(exports, "default", {
-    enumerable: !0,
-    get: ()=>toColorValue
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return toColorValue;
+    }
 });
+function toColorValue(maybeFunction) {
+    return typeof maybeFunction === "function" ? maybeFunction({}) : maybeFunction;
+}

package/lib/util/toPath.js

@@ -1,12 +1,32 @@
-"use strict";
+/**
+ * Parse a path string into an array of path segments.
+ *
+ * Square bracket notation `a[b]` may be used to "escape" dots that would otherwise be interpreted as path separators.
+ *
+ * Example:
+ * a -> ['a']
+ * a.b.c -> ['a', 'b', 'c']
+ * a[b].c -> ['a', 'b', 'c']
+ * a[b.c].e.f -> ['a', 'b.c', 'e', 'f']
+ * a[b][c][d] -> ['a', 'b', 'c', 'd']
+ *
+ * @param {string|string[]} path
+ **/ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "toPath", {
+    enumerable: true,
+    get: function() {
+        return toPath;
+    }
+});
 function toPath(path) {
     if (Array.isArray(path)) return path;
-    if (path.split("[").length - 1 != path.split("]").length - 1) throw Error(`Path is invalid. Has unbalanced brackets: ${path}`);
+    let openBrackets = path.split("[").length - 1;
+    let closedBrackets = path.split("]").length - 1;
+    if (openBrackets !== closedBrackets) {
+        throw new Error(`Path is invalid. Has unbalanced brackets: ${path}`);
+    }
     return path.split(/\.(?![^\[]*\])|[\[\]]/g).filter(Boolean);
 }
-Object.defineProperty(exports, "__esModule", {
-    value: !0
-}), Object.defineProperty(exports, "toPath", {
-    enumerable: !0,
-    get: ()=>toPath
-});