@dreamcommerce/aurora 3.0.0-1 → 3.0.0-101

package/build/cjs/external/tailwind-merge/dist/bundle-mjs.mjs.js

@@ -2,56 +2,58 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-const CLASS_PART_SEPARATOR = '-';
-const createClassGroupUtils = config => {
-  const classMap = createClassMap(config);
-  const {
-    conflictingClassGroups,
-    conflictingClassGroupModifiers
-  } = config;
-  const getClassGroupId = className => {
-    const classParts = className.split(CLASS_PART_SEPARATOR);
+var _rollupPluginBabelHelpers = require('../../../_virtual/_rollupPluginBabelHelpers.js');
+
+var CLASS_PART_SEPARATOR = '-';
+var createClassGroupUtils = function createClassGroupUtils(config) {
+  var classMap = createClassMap(config);
+  var conflictingClassGroups = config.conflictingClassGroups,
+    conflictingClassGroupModifiers = config.conflictingClassGroupModifiers;
+  var getClassGroupId = function getClassGroupId(className) {
+    var classParts = className.split(CLASS_PART_SEPARATOR);
     // Classes like `-inset-1` produce an empty string as first classPart. We assume that classes for negative values are used correctly and remove it from classParts.
     if (classParts[0] === '' && classParts.length !== 1) {
       classParts.shift();
     }
-    return getGroupRecursive(classParts, classMap) || getGroupIdForArbitraryProperty(className);
+    return _getGroupRecursive(classParts, classMap) || getGroupIdForArbitraryProperty(className);
   };
-  const getConflictingClassGroupIds = (classGroupId, hasPostfixModifier) => {
-    const conflicts = conflictingClassGroups[classGroupId] || [];
+  var getConflictingClassGroupIds = function getConflictingClassGroupIds(classGroupId, hasPostfixModifier) {
+    var conflicts = conflictingClassGroups[classGroupId] || [];
     if (hasPostfixModifier && conflictingClassGroupModifiers[classGroupId]) {
-      return [...conflicts, ...conflictingClassGroupModifiers[classGroupId]];
+      return [].concat(_rollupPluginBabelHelpers.toConsumableArray(conflicts), _rollupPluginBabelHelpers.toConsumableArray(conflictingClassGroupModifiers[classGroupId]));
     }
     return conflicts;
   };
   return {
-    getClassGroupId,
-    getConflictingClassGroupIds
+    getClassGroupId: getClassGroupId,
+    getConflictingClassGroupIds: getConflictingClassGroupIds
   };
 };
-const getGroupRecursive = (classParts, classPartObject) => {
+var _getGroupRecursive = function getGroupRecursive(classParts, classPartObject) {
+  var _classPartObject$vali;
   if (classParts.length === 0) {
     return classPartObject.classGroupId;
   }
-  const currentClassPart = classParts[0];
-  const nextClassPartObject = classPartObject.nextPart.get(currentClassPart);
-  const classGroupFromNextClassPart = nextClassPartObject ? getGroupRecursive(classParts.slice(1), nextClassPartObject) : undefined;
+  var currentClassPart = classParts[0];
+  var nextClassPartObject = classPartObject.nextPart.get(currentClassPart);
+  var classGroupFromNextClassPart = nextClassPartObject ? _getGroupRecursive(classParts.slice(1), nextClassPartObject) : undefined;
   if (classGroupFromNextClassPart) {
     return classGroupFromNextClassPart;
   }
   if (classPartObject.validators.length === 0) {
     return undefined;
   }
-  const classRest = classParts.join(CLASS_PART_SEPARATOR);
-  return classPartObject.validators.find(({
-    validator
-  }) => validator(classRest))?.classGroupId;
+  var classRest = classParts.join(CLASS_PART_SEPARATOR);
+  return (_classPartObject$vali = classPartObject.validators.find(function (_ref) {
+    var validator = _ref.validator;
+    return validator(classRest);
+  })) === null || _classPartObject$vali === void 0 ? void 0 : _classPartObject$vali.classGroupId;
 };
-const arbitraryPropertyRegex = /^\[(.+)\]$/;
-const getGroupIdForArbitraryProperty = className => {
+var arbitraryPropertyRegex = /^\[(.+)\]$/;
+var getGroupIdForArbitraryProperty = function getGroupIdForArbitraryProperty(className) {
   if (arbitraryPropertyRegex.test(className)) {
-    const arbitraryPropertyClassName = arbitraryPropertyRegex.exec(className)[1];
-    const property = arbitraryPropertyClassName?.substring(0, arbitraryPropertyClassName.indexOf(':'));
+    var arbitraryPropertyClassName = arbitraryPropertyRegex.exec(className)[1];
+    var property = arbitraryPropertyClassName === null || arbitraryPropertyClassName === void 0 ? void 0 : arbitraryPropertyClassName.substring(0, arbitraryPropertyClassName.indexOf(':'));
     if (property) {
       // I use two dots here because one dot is used as prefix for class groups in plugins
       return 'arbitrary..' + property;
@@ -61,47 +63,51 @@ const getGroupIdForArbitraryProperty = className => {
 /**
  * Exported for testing only
  */
-const createClassMap = config => {
-  const {
-    theme,
-    prefix
-  } = config;
-  const classMap = {
+var createClassMap = function createClassMap(config) {
+  var theme = config.theme,
+    prefix = config.prefix;
+  var classMap = {
     nextPart: new Map(),
     validators: []
   };
-  const prefixedClassGroupEntries = getPrefixedClassGroupEntries(Object.entries(config.classGroups), prefix);
-  prefixedClassGroupEntries.forEach(([classGroupId, classGroup]) => {
-    processClassesRecursively(classGroup, classMap, classGroupId, theme);
+  var prefixedClassGroupEntries = getPrefixedClassGroupEntries(Object.entries(config.classGroups), prefix);
+  prefixedClassGroupEntries.forEach(function (_ref2) {
+    var _ref3 = _rollupPluginBabelHelpers.slicedToArray(_ref2, 2),
+      classGroupId = _ref3[0],
+      classGroup = _ref3[1];
+    _processClassesRecursively(classGroup, classMap, classGroupId, theme);
   });
   return classMap;
 };
-const processClassesRecursively = (classGroup, classPartObject, classGroupId, theme) => {
-  classGroup.forEach(classDefinition => {
+var _processClassesRecursively = function processClassesRecursively(classGroup, classPartObject, classGroupId, theme) {
+  classGroup.forEach(function (classDefinition) {
     if (typeof classDefinition === 'string') {
-      const classPartObjectToEdit = classDefinition === '' ? classPartObject : getPart(classPartObject, classDefinition);
+      var classPartObjectToEdit = classDefinition === '' ? classPartObject : getPart(classPartObject, classDefinition);
       classPartObjectToEdit.classGroupId = classGroupId;
       return;
     }
     if (typeof classDefinition === 'function') {
       if (isThemeGetter(classDefinition)) {
-        processClassesRecursively(classDefinition(theme), classPartObject, classGroupId, theme);
+        _processClassesRecursively(classDefinition(theme), classPartObject, classGroupId, theme);
         return;
       }
       classPartObject.validators.push({
         validator: classDefinition,
-        classGroupId
+        classGroupId: classGroupId
       });
       return;
     }
-    Object.entries(classDefinition).forEach(([key, classGroup]) => {
-      processClassesRecursively(classGroup, getPart(classPartObject, key), classGroupId, theme);
+    Object.entries(classDefinition).forEach(function (_ref4) {
+      var _ref5 = _rollupPluginBabelHelpers.slicedToArray(_ref4, 2),
+        key = _ref5[0],
+        classGroup = _ref5[1];
+      _processClassesRecursively(classGroup, getPart(classPartObject, key), classGroupId, theme);
     });
   });
 };
-const getPart = (classPartObject, path) => {
-  let currentClassPartObject = classPartObject;
-  path.split(CLASS_PART_SEPARATOR).forEach(pathPart => {
+var getPart = function getPart(classPartObject, path) {
+  var currentClassPartObject = classPartObject;
+  path.split(CLASS_PART_SEPARATOR).forEach(function (pathPart) {
     if (!currentClassPartObject.nextPart.has(pathPart)) {
       currentClassPartObject.nextPart.set(pathPart, {
         nextPart: new Map(),
@@ -112,18 +118,28 @@ const getPart = (classPartObject, path) => {
   });
   return currentClassPartObject;
 };
-const isThemeGetter = func => func.isThemeGetter;
-const getPrefixedClassGroupEntries = (classGroupEntries, prefix) => {
+var isThemeGetter = function isThemeGetter(func) {
+  return func.isThemeGetter;
+};
+var getPrefixedClassGroupEntries = function getPrefixedClassGroupEntries(classGroupEntries, prefix) {
   if (!prefix) {
     return classGroupEntries;
   }
-  return classGroupEntries.map(([classGroupId, classGroup]) => {
-    const prefixedClassGroup = classGroup.map(classDefinition => {
+  return classGroupEntries.map(function (_ref6) {
+    var _ref7 = _rollupPluginBabelHelpers.slicedToArray(_ref6, 2),
+      classGroupId = _ref7[0],
+      classGroup = _ref7[1];
+    var prefixedClassGroup = classGroup.map(function (classDefinition) {
       if (typeof classDefinition === 'string') {
         return prefix + classDefinition;
       }
-      if (typeof classDefinition === 'object') {
-        return Object.fromEntries(Object.entries(classDefinition).map(([key, value]) => [prefix + key, value]));
+      if (_rollupPluginBabelHelpers['typeof'](classDefinition) === 'object') {
+        return Object.fromEntries(Object.entries(classDefinition).map(function (_ref8) {
+          var _ref9 = _rollupPluginBabelHelpers.slicedToArray(_ref8, 2),
+            key = _ref9[0],
+            value = _ref9[1];
+          return [prefix + key, value];
+        }));
       }
       return classDefinition;
     });
@@ -132,17 +148,19 @@ const getPrefixedClassGroupEntries = (classGroupEntries, prefix) => {
 };
 
 // LRU cache inspired from hashlru (https://github.com/dominictarr/hashlru/blob/v1.0.4/index.js) but object replaced with Map to improve performance
-const createLruCache = maxCacheSize => {
+var createLruCache = function createLruCache(maxCacheSize) {
   if (maxCacheSize < 1) {
     return {
-      get: () => undefined,
-      set: () => {}
+      get: function get() {
+        return undefined;
+      },
+      set: function set() {}
     };
   }
-  let cacheSize = 0;
-  let cache = new Map();
-  let previousCache = new Map();
-  const update = (key, value) => {
+  var cacheSize = 0;
+  var cache = new Map();
+  var previousCache = new Map();
+  var update = function update(key, value) {
     cache.set(key, value);
     cacheSize++;
     if (cacheSize > maxCacheSize) {
@@ -152,8 +170,8 @@ const createLruCache = maxCacheSize => {
     }
   };
   return {
-    get(key) {
-      let value = cache.get(key);
+    get: function get(key) {
+      var value = cache.get(key);
       if (value !== undefined) {
         return value;
       }
@@ -162,7 +180,7 @@ const createLruCache = maxCacheSize => {
         return value;
       }
     },
-    set(key, value) {
+    set: function set(key, value) {
       if (cache.has(key)) {
         cache.set(key, value);
       } else {
@@ -171,23 +189,21 @@ const createLruCache = maxCacheSize => {
     }
   };
 };
-const IMPORTANT_MODIFIER = '!';
-const createParseClassName = config => {
-  const {
-    separator,
-    experimentalParseClassName
-  } = config;
-  const isSeparatorSingleCharacter = separator.length === 1;
-  const firstSeparatorCharacter = separator[0];
-  const separatorLength = separator.length;
+var IMPORTANT_MODIFIER = '!';
+var createParseClassName = function createParseClassName(config) {
+  var separator = config.separator,
+    experimentalParseClassName = config.experimentalParseClassName;
+  var isSeparatorSingleCharacter = separator.length === 1;
+  var firstSeparatorCharacter = separator[0];
+  var separatorLength = separator.length;
   // parseClassName inspired by https://github.com/tailwindlabs/tailwindcss/blob/v3.2.2/src/util/splitAtTopLevelOnly.js
-  const parseClassName = className => {
-    const modifiers = [];
-    let bracketDepth = 0;
-    let modifierStart = 0;
-    let postfixModifierPosition;
-    for (let index = 0; index < className.length; index++) {
-      let currentCharacter = className[index];
+  var parseClassName = function parseClassName(className) {
+    var modifiers = [];
+    var bracketDepth = 0;
+    var modifierStart = 0;
+    var postfixModifierPosition;
+    for (var index = 0; index < className.length; index++) {
+      var currentCharacter = className[index];
       if (bracketDepth === 0) {
         if (currentCharacter === firstSeparatorCharacter && (isSeparatorSingleCharacter || className.slice(index, index + separatorLength) === separator)) {
           modifiers.push(className.slice(modifierStart, index));
@@ -205,22 +221,24 @@ const createParseClassName = config => {
         bracketDepth--;
       }
     }
-    const baseClassNameWithImportantModifier = modifiers.length === 0 ? className : className.substring(modifierStart);
-    const hasImportantModifier = baseClassNameWithImportantModifier.startsWith(IMPORTANT_MODIFIER);
-    const baseClassName = hasImportantModifier ? baseClassNameWithImportantModifier.substring(1) : baseClassNameWithImportantModifier;
-    const maybePostfixModifierPosition = postfixModifierPosition && postfixModifierPosition > modifierStart ? postfixModifierPosition - modifierStart : undefined;
+    var baseClassNameWithImportantModifier = modifiers.length === 0 ? className : className.substring(modifierStart);
+    var hasImportantModifier = baseClassNameWithImportantModifier.startsWith(IMPORTANT_MODIFIER);
+    var baseClassName = hasImportantModifier ? baseClassNameWithImportantModifier.substring(1) : baseClassNameWithImportantModifier;
+    var maybePostfixModifierPosition = postfixModifierPosition && postfixModifierPosition > modifierStart ? postfixModifierPosition - modifierStart : undefined;
     return {
-      modifiers,
-      hasImportantModifier,
-      baseClassName,
-      maybePostfixModifierPosition
+      modifiers: modifiers,
+      hasImportantModifier: hasImportantModifier,
+      baseClassName: baseClassName,
+      maybePostfixModifierPosition: maybePostfixModifierPosition
     };
   };
   if (experimentalParseClassName) {
-    return className => experimentalParseClassName({
-      className,
-      parseClassName
-    });
+    return function (className) {
+      return experimentalParseClassName({
+        className: className,
+        parseClassName: parseClassName
+      });
+    };
   }
   return parseClassName;
 };
@@ -229,36 +247,35 @@ const createParseClassName = config => {
  * - Predefined modifiers are sorted alphabetically
  * - When an arbitrary variant appears, it must be preserved which modifiers are before and after it
  */
-const sortModifiers = modifiers => {
+var sortModifiers = function sortModifiers(modifiers) {
   if (modifiers.length <= 1) {
     return modifiers;
   }
-  const sortedModifiers = [];
-  let unsortedModifiers = [];
-  modifiers.forEach(modifier => {
-    const isArbitraryVariant = modifier[0] === '[';
+  var sortedModifiers = [];
+  var unsortedModifiers = [];
+  modifiers.forEach(function (modifier) {
+    var isArbitraryVariant = modifier[0] === '[';
     if (isArbitraryVariant) {
-      sortedModifiers.push(...unsortedModifiers.sort(), modifier);
+      sortedModifiers.push.apply(sortedModifiers, _rollupPluginBabelHelpers.toConsumableArray(unsortedModifiers.sort()).concat([modifier]));
       unsortedModifiers = [];
     } else {
       unsortedModifiers.push(modifier);
     }
   });
-  sortedModifiers.push(...unsortedModifiers.sort());
+  sortedModifiers.push.apply(sortedModifiers, _rollupPluginBabelHelpers.toConsumableArray(unsortedModifiers.sort()));
   return sortedModifiers;
 };
-const createConfigUtils = config => ({
-  cache: createLruCache(config.cacheSize),
-  parseClassName: createParseClassName(config),
-  ...createClassGroupUtils(config)
-});
-const SPLIT_CLASSES_REGEX = /\s+/;
-const mergeClassList = (classList, configUtils) => {
-  const {
-    parseClassName,
-    getClassGroupId,
-    getConflictingClassGroupIds
-  } = configUtils;
+var createConfigUtils = function createConfigUtils(config) {
+  return _rollupPluginBabelHelpers.objectSpread2({
+    cache: createLruCache(config.cacheSize),
+    parseClassName: createParseClassName(config)
+  }, createClassGroupUtils(config));
+};
+var SPLIT_CLASSES_REGEX = /\s+/;
+var mergeClassList = function mergeClassList(classList, configUtils) {
+  var parseClassName = configUtils.parseClassName,
+    getClassGroupId = configUtils.getClassGroupId,
+    getConflictingClassGroupIds = configUtils.getConflictingClassGroupIds;
   /**
    * Set of classGroupIds in following format:
    * `{importantModifier}{variantModifiers}{classGroupId}`
@@ -266,19 +283,18 @@ const mergeClassList = (classList, configUtils) => {
    * @example 'hover:focus:bg-color'
    * @example 'md:!pr'
    */
-  const classGroupsInConflict = [];
-  const classNames = classList.trim().split(SPLIT_CLASSES_REGEX);
-  let result = '';
-  for (let index = classNames.length - 1; index >= 0; index -= 1) {
-    const originalClassName = classNames[index];
-    const {
-      modifiers,
-      hasImportantModifier,
-      baseClassName,
-      maybePostfixModifierPosition
-    } = parseClassName(originalClassName);
-    let hasPostfixModifier = Boolean(maybePostfixModifierPosition);
-    let classGroupId = getClassGroupId(hasPostfixModifier ? baseClassName.substring(0, maybePostfixModifierPosition) : baseClassName);
+  var classGroupsInConflict = [];
+  var classNames = classList.trim().split(SPLIT_CLASSES_REGEX);
+  var result = '';
+  for (var index = classNames.length - 1; index >= 0; index -= 1) {
+    var originalClassName = classNames[index];
+    var _parseClassName = parseClassName(originalClassName),
+      modifiers = _parseClassName.modifiers,
+      hasImportantModifier = _parseClassName.hasImportantModifier,
+      baseClassName = _parseClassName.baseClassName,
+      maybePostfixModifierPosition = _parseClassName.maybePostfixModifierPosition;
+    var hasPostfixModifier = Boolean(maybePostfixModifierPosition);
+    var classGroupId = getClassGroupId(hasPostfixModifier ? baseClassName.substring(0, maybePostfixModifierPosition) : baseClassName);
     if (!classGroupId) {
       if (!hasPostfixModifier) {
         // Not a Tailwind class
@@ -293,17 +309,17 @@ const mergeClassList = (classList, configUtils) => {
       }
       hasPostfixModifier = false;
     }
-    const variantModifier = sortModifiers(modifiers).join(':');
-    const modifierId = hasImportantModifier ? variantModifier + IMPORTANT_MODIFIER : variantModifier;
-    const classId = modifierId + classGroupId;
+    var variantModifier = sortModifiers(modifiers).join(':');
+    var modifierId = hasImportantModifier ? variantModifier + IMPORTANT_MODIFIER : variantModifier;
+    var classId = modifierId + classGroupId;
     if (classGroupsInConflict.includes(classId)) {
       // Tailwind class omitted due to conflict
       continue;
     }
     classGroupsInConflict.push(classId);
-    const conflictGroups = getConflictingClassGroupIds(classGroupId, hasPostfixModifier);
-    for (let i = 0; i < conflictGroups.length; ++i) {
-      const group = conflictGroups[i];
+    var conflictGroups = getConflictingClassGroupIds(classGroupId, hasPostfixModifier);
+    for (var i = 0; i < conflictGroups.length; ++i) {
+      var group = conflictGroups[i];
       classGroupsInConflict.push(modifierId + group);
     }
     // Tailwind class not in conflict
@@ -322,13 +338,13 @@ const mergeClassList = (classList, configUtils) => {
  * Original code has MIT license: Copyright (c) Luke Edwards <luke.edwards05@gmail.com> (lukeed.com)
  */
 function twJoin() {
-  let index = 0;
-  let argument;
-  let resolvedValue;
-  let string = '';
+  var index = 0;
+  var argument;
+  var resolvedValue;
+  var string = '';
   while (index < arguments.length) {
     if (argument = arguments[index++]) {
-      if (resolvedValue = toValue(argument)) {
+      if (resolvedValue = _toValue(argument)) {
         string && (string += ' ');
         string += resolvedValue;
       }
@@ -336,15 +352,15 @@ function twJoin() {
   }
   return string;
 }
-const toValue = mix => {
+var _toValue = function toValue(mix) {
   if (typeof mix === 'string') {
     return mix;
   }
-  let resolvedValue;
-  let string = '';
-  for (let k = 0; k < mix.length; k++) {
+  var resolvedValue;
+  var string = '';
+  for (var k = 0; k < mix.length; k++) {
     if (mix[k]) {
-      if (resolvedValue = toValue(mix[k])) {
+      if (resolvedValue = _toValue(mix[k])) {
         string && (string += ' ');
         string += resolvedValue;
       }
@@ -352,13 +368,18 @@ const toValue = mix => {
   }
   return string;
 };
-function createTailwindMerge(createConfigFirst, ...createConfigRest) {
-  let configUtils;
-  let cacheGet;
-  let cacheSet;
-  let functionToCall = initTailwindMerge;
+function createTailwindMerge(createConfigFirst) {
+  for (var _len = arguments.length, createConfigRest = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    createConfigRest[_key - 1] = arguments[_key];
+  }
+  var configUtils;
+  var cacheGet;
+  var cacheSet;
+  var functionToCall = initTailwindMerge;
   function initTailwindMerge(classList) {
-    const config = createConfigRest.reduce((previousConfig, createConfigCurrent) => createConfigCurrent(previousConfig), createConfigFirst());
+    var config = createConfigRest.reduce(function (previousConfig, createConfigCurrent) {
+      return createConfigCurrent(previousConfig);
+    }, createConfigFirst());
     configUtils = createConfigUtils(config);
     cacheGet = configUtils.cache.get;
     cacheSet = configUtils.cache.set;
@@ -366,11 +387,11 @@ function createTailwindMerge(createConfigFirst, ...createConfigRest) {
     return tailwindMerge(classList);
   }
   function tailwindMerge(classList) {
-    const cachedResult = cacheGet(classList);
+    var cachedResult = cacheGet(classList);
     if (cachedResult) {
       return cachedResult;
     }
-    const result = mergeClassList(classList, configUtils);
+    var result = mergeClassList(classList, configUtils);
     cacheSet(classList, result);
     return result;
   }
@@ -378,37 +399,65 @@ function createTailwindMerge(createConfigFirst, ...createConfigRest) {
     return functionToCall(twJoin.apply(null, arguments));
   };
 }
-const fromTheme = key => {
-  const themeGetter = theme => theme[key] || [];
+var fromTheme = function fromTheme(key) {
+  var themeGetter = function themeGetter(theme) {
+    return theme[key] || [];
+  };
   themeGetter.isThemeGetter = true;
   return themeGetter;
 };
-const arbitraryValueRegex = /^\[(?:([a-z-]+):)?(.+)\]$/i;
-const fractionRegex = /^\d+\/\d+$/;
-const stringLengths = /*#__PURE__*/new Set(['px', 'full', 'screen']);
-const tshirtUnitRegex = /^(\d+(\.\d+)?)?(xs|sm|md|lg|xl)$/;
-const lengthUnitRegex = /\d+(%|px|r?em|[sdl]?v([hwib]|min|max)|pt|pc|in|cm|mm|cap|ch|ex|r?lh|cq(w|h|i|b|min|max))|\b(calc|min|max|clamp)\(.+\)|^0$/;
-const colorFunctionRegex = /^(rgba?|hsla?|hwb|(ok)?(lab|lch))\(.+\)$/;
+var arbitraryValueRegex = /^\[(?:([a-z-]+):)?(.+)\]$/i;
+var fractionRegex = /^\d+\/\d+$/;
+var stringLengths = /*#__PURE__*/new Set(['px', 'full', 'screen']);
+var tshirtUnitRegex = /^(\d+(\.\d+)?)?(xs|sm|md|lg|xl)$/;
+var lengthUnitRegex = /\d+(%|px|r?em|[sdl]?v([hwib]|min|max)|pt|pc|in|cm|mm|cap|ch|ex|r?lh|cq(w|h|i|b|min|max))|\b(calc|min|max|clamp)\(.+\)|^0$/;
+var colorFunctionRegex = /^(rgba?|hsla?|hwb|(ok)?(lab|lch))\(.+\)$/;
 // Shadow always begins with x and y offset separated by underscore optionally prepended by inset
-const shadowRegex = /^(inset_)?-?((\d+)?\.?(\d+)[a-z]+|0)_-?((\d+)?\.?(\d+)[a-z]+|0)/;
-const imageRegex = /^(url|image|image-set|cross-fade|element|(repeating-)?(linear|radial|conic)-gradient)\(.+\)$/;
-const isLength = value => isNumber(value) || stringLengths.has(value) || fractionRegex.test(value);
-const isArbitraryLength = value => getIsArbitraryValue(value, 'length', isLengthOnly);
-const isNumber = value => Boolean(value) && !Number.isNaN(Number(value));
-const isArbitraryNumber = value => getIsArbitraryValue(value, 'number', isNumber);
-const isInteger = value => Boolean(value) && Number.isInteger(Number(value));
-const isPercent = value => value.endsWith('%') && isNumber(value.slice(0, -1));
-const isArbitraryValue = value => arbitraryValueRegex.test(value);
-const isTshirtSize = value => tshirtUnitRegex.test(value);
-const sizeLabels = /*#__PURE__*/new Set(['length', 'size', 'percentage']);
-const isArbitrarySize = value => getIsArbitraryValue(value, sizeLabels, isNever);
-const isArbitraryPosition = value => getIsArbitraryValue(value, 'position', isNever);
-const imageLabels = /*#__PURE__*/new Set(['image', 'url']);
-const isArbitraryImage = value => getIsArbitraryValue(value, imageLabels, isImage);
-const isArbitraryShadow = value => getIsArbitraryValue(value, '', isShadow);
-const isAny = () => true;
-const getIsArbitraryValue = (value, label, testValue) => {
-  const result = arbitraryValueRegex.exec(value);
+var shadowRegex = /^(inset_)?-?((\d+)?\.?(\d+)[a-z]+|0)_-?((\d+)?\.?(\d+)[a-z]+|0)/;
+var imageRegex = /^(url|image|image-set|cross-fade|element|(repeating-)?(linear|radial|conic)-gradient)\(.+\)$/;
+var isLength = function isLength(value) {
+  return isNumber(value) || stringLengths.has(value) || fractionRegex.test(value);
+};
+var isArbitraryLength = function isArbitraryLength(value) {
+  return getIsArbitraryValue(value, 'length', isLengthOnly);
+};
+var isNumber = function isNumber(value) {
+  return Boolean(value) && !Number.isNaN(Number(value));
+};
+var isArbitraryNumber = function isArbitraryNumber(value) {
+  return getIsArbitraryValue(value, 'number', isNumber);
+};
+var isInteger = function isInteger(value) {
+  return Boolean(value) && Number.isInteger(Number(value));
+};
+var isPercent = function isPercent(value) {
+  return value.endsWith('%') && isNumber(value.slice(0, -1));
+};
+var isArbitraryValue = function isArbitraryValue(value) {
+  return arbitraryValueRegex.test(value);
+};
+var isTshirtSize = function isTshirtSize(value) {
+  return tshirtUnitRegex.test(value);
+};
+var sizeLabels = /*#__PURE__*/new Set(['length', 'size', 'percentage']);
+var isArbitrarySize = function isArbitrarySize(value) {
+  return getIsArbitraryValue(value, sizeLabels, isNever);
+};
+var isArbitraryPosition = function isArbitraryPosition(value) {
+  return getIsArbitraryValue(value, 'position', isNever);
+};
+var imageLabels = /*#__PURE__*/new Set(['image', 'url']);
+var isArbitraryImage = function isArbitraryImage(value) {
+  return getIsArbitraryValue(value, imageLabels, isImage);
+};
+var isArbitraryShadow = function isArbitraryShadow(value) {
+  return getIsArbitraryValue(value, '', isShadow);
+};
+var isAny = function isAny() {
+  return true;
+};
+var getIsArbitraryValue = function getIsArbitraryValue(value, label, testValue) {
+  var result = arbitraryValueRegex.exec(value);
   if (result) {
     if (result[1]) {
       return typeof label === 'string' ? result[1] === label : label.has(result[1]);
@@ -417,53 +466,88 @@ const getIsArbitraryValue = (value, label, testValue) => {
   }
   return false;
 };
-const isLengthOnly = value =>
-// `colorFunctionRegex` check is necessary because color functions can have percentages in them which which would be incorrectly classified as lengths.
-// For example, `hsl(0 0% 0%)` would be classified as a length without this check.
-// I could also use lookbehind assertion in `lengthUnitRegex` but that isn't supported widely enough.
-lengthUnitRegex.test(value) && !colorFunctionRegex.test(value);
-const isNever = () => false;
-const isShadow = value => shadowRegex.test(value);
-const isImage = value => imageRegex.test(value);
-const getDefaultConfig = () => {
-  const colors = fromTheme('colors');
-  const spacing = fromTheme('spacing');
-  const blur = fromTheme('blur');
-  const brightness = fromTheme('brightness');
-  const borderColor = fromTheme('borderColor');
-  const borderRadius = fromTheme('borderRadius');
-  const borderSpacing = fromTheme('borderSpacing');
-  const borderWidth = fromTheme('borderWidth');
-  const contrast = fromTheme('contrast');
-  const grayscale = fromTheme('grayscale');
-  const hueRotate = fromTheme('hueRotate');
-  const invert = fromTheme('invert');
-  const gap = fromTheme('gap');
-  const gradientColorStops = fromTheme('gradientColorStops');
-  const gradientColorStopPositions = fromTheme('gradientColorStopPositions');
-  const inset = fromTheme('inset');
-  const margin = fromTheme('margin');
-  const opacity = fromTheme('opacity');
-  const padding = fromTheme('padding');
-  const saturate = fromTheme('saturate');
-  const scale = fromTheme('scale');
-  const sepia = fromTheme('sepia');
-  const skew = fromTheme('skew');
-  const space = fromTheme('space');
-  const translate = fromTheme('translate');
-  const getOverscroll = () => ['auto', 'contain', 'none'];
-  const getOverflow = () => ['auto', 'hidden', 'clip', 'visible', 'scroll'];
-  const getSpacingWithAutoAndArbitrary = () => ['auto', isArbitraryValue, spacing];
-  const getSpacingWithArbitrary = () => [isArbitraryValue, spacing];
-  const getLengthWithEmptyAndArbitrary = () => ['', isLength, isArbitraryLength];
-  const getNumberWithAutoAndArbitrary = () => ['auto', isNumber, isArbitraryValue];
-  const getPositions = () => ['bottom', 'center', 'left', 'left-bottom', 'left-top', 'right', 'right-bottom', 'right-top', 'top'];
-  const getLineStyles = () => ['solid', 'dashed', 'dotted', 'double', 'none'];
-  const getBlendModes = () => ['normal', 'multiply', 'screen', 'overlay', 'darken', 'lighten', 'color-dodge', 'color-burn', 'hard-light', 'soft-light', 'difference', 'exclusion', 'hue', 'saturation', 'color', 'luminosity'];
-  const getAlign = () => ['start', 'end', 'center', 'between', 'around', 'evenly', 'stretch'];
-  const getZeroAndEmpty = () => ['', '0', isArbitraryValue];
-  const getBreaks = () => ['auto', 'avoid', 'all', 'avoid-page', 'page', 'left', 'right', 'column'];
-  const getNumberAndArbitrary = () => [isNumber, isArbitraryValue];
+var isLengthOnly = function isLengthOnly(value) {
+  return (
+    // `colorFunctionRegex` check is necessary because color functions can have percentages in them which which would be incorrectly classified as lengths.
+    // For example, `hsl(0 0% 0%)` would be classified as a length without this check.
+    // I could also use lookbehind assertion in `lengthUnitRegex` but that isn't supported widely enough.
+    lengthUnitRegex.test(value) && !colorFunctionRegex.test(value)
+  );
+};
+var isNever = function isNever() {
+  return false;
+};
+var isShadow = function isShadow(value) {
+  return shadowRegex.test(value);
+};
+var isImage = function isImage(value) {
+  return imageRegex.test(value);
+};
+var getDefaultConfig = function getDefaultConfig() {
+  var colors = fromTheme('colors');
+  var spacing = fromTheme('spacing');
+  var blur = fromTheme('blur');
+  var brightness = fromTheme('brightness');
+  var borderColor = fromTheme('borderColor');
+  var borderRadius = fromTheme('borderRadius');
+  var borderSpacing = fromTheme('borderSpacing');
+  var borderWidth = fromTheme('borderWidth');
+  var contrast = fromTheme('contrast');
+  var grayscale = fromTheme('grayscale');
+  var hueRotate = fromTheme('hueRotate');
+  var invert = fromTheme('invert');
+  var gap = fromTheme('gap');
+  var gradientColorStops = fromTheme('gradientColorStops');
+  var gradientColorStopPositions = fromTheme('gradientColorStopPositions');
+  var inset = fromTheme('inset');
+  var margin = fromTheme('margin');
+  var opacity = fromTheme('opacity');
+  var padding = fromTheme('padding');
+  var saturate = fromTheme('saturate');
+  var scale = fromTheme('scale');
+  var sepia = fromTheme('sepia');
+  var skew = fromTheme('skew');
+  var space = fromTheme('space');
+  var translate = fromTheme('translate');
+  var getOverscroll = function getOverscroll() {
+    return ['auto', 'contain', 'none'];
+  };
+  var getOverflow = function getOverflow() {
+    return ['auto', 'hidden', 'clip', 'visible', 'scroll'];
+  };
+  var getSpacingWithAutoAndArbitrary = function getSpacingWithAutoAndArbitrary() {
+    return ['auto', isArbitraryValue, spacing];
+  };
+  var getSpacingWithArbitrary = function getSpacingWithArbitrary() {
+    return [isArbitraryValue, spacing];
+  };
+  var getLengthWithEmptyAndArbitrary = function getLengthWithEmptyAndArbitrary() {
+    return ['', isLength, isArbitraryLength];
+  };
+  var getNumberWithAutoAndArbitrary = function getNumberWithAutoAndArbitrary() {
+    return ['auto', isNumber, isArbitraryValue];
+  };
+  var getPositions = function getPositions() {
+    return ['bottom', 'center', 'left', 'left-bottom', 'left-top', 'right', 'right-bottom', 'right-top', 'top'];
+  };
+  var getLineStyles = function getLineStyles() {
+    return ['solid', 'dashed', 'dotted', 'double', 'none'];
+  };
+  var getBlendModes = function getBlendModes() {
+    return ['normal', 'multiply', 'screen', 'overlay', 'darken', 'lighten', 'color-dodge', 'color-burn', 'hard-light', 'soft-light', 'difference', 'exclusion', 'hue', 'saturation', 'color', 'luminosity'];
+  };
+  var getAlign = function getAlign() {
+    return ['start', 'end', 'center', 'between', 'around', 'evenly', 'stretch'];
+  };
+  var getZeroAndEmpty = function getZeroAndEmpty() {
+    return ['', '0', isArbitraryValue];
+  };
+  var getBreaks = function getBreaks() {
+    return ['auto', 'avoid', 'all', 'avoid-page', 'page', 'left', 'right', 'column'];
+  };
+  var getNumberAndArbitrary = function getNumberAndArbitrary() {
+    return [isNumber, isArbitraryValue];
+  };
   return {
     cacheSize: 500,
     separator: ':',
@@ -586,7 +670,7 @@ const getDefaultConfig = () => {
        * @see https://tailwindcss.com/docs/object-position
        */
       'object-position': [{
-        object: [...getPositions(), isArbitraryValue]
+        object: [].concat(_rollupPluginBabelHelpers.toConsumableArray(getPositions()), [isArbitraryValue])
       }],
       /**
        * Overflow
@@ -867,7 +951,7 @@ const getDefaultConfig = () => {
        * @see https://tailwindcss.com/docs/justify-content
        */
       'justify-content': [{
-        justify: ['normal', ...getAlign()]
+        justify: ['normal'].concat(_rollupPluginBabelHelpers.toConsumableArray(getAlign()))
       }],
       /**
        * Justify Items
@@ -888,7 +972,7 @@ const getDefaultConfig = () => {
        * @see https://tailwindcss.com/docs/align-content
        */
       'align-content': [{
-        content: ['normal', ...getAlign(), 'baseline']
+        content: ['normal'].concat(_rollupPluginBabelHelpers.toConsumableArray(getAlign()), ['baseline'])
       }],
       /**
        * Align Items
@@ -909,7 +993,7 @@ const getDefaultConfig = () => {
        * @see https://tailwindcss.com/docs/place-content
        */
       'place-content': [{
-        'place-content': [...getAlign(), 'baseline']
+        'place-content': [].concat(_rollupPluginBabelHelpers.toConsumableArray(getAlign()), ['baseline'])
       }],
       /**
        * Place Items
@@ -1278,7 +1362,7 @@ const getDefaultConfig = () => {
        * @see https://tailwindcss.com/docs/text-decoration-style
        */
       'text-decoration-style': [{
-        decoration: [...getLineStyles(), 'wavy']
+        decoration: [].concat(_rollupPluginBabelHelpers.toConsumableArray(getLineStyles()), ['wavy'])
       }],
       /**
        * Text Decoration Thickness
@@ -1395,7 +1479,7 @@ const getDefaultConfig = () => {
        * @see https://tailwindcss.com/docs/background-position
        */
       'bg-position': [{
-        bg: [...getPositions(), isArbitraryPosition]
+        bg: [].concat(_rollupPluginBabelHelpers.toConsumableArray(getPositions()), [isArbitraryPosition])
       }],
       /**
        * Background Repeat
@@ -1652,7 +1736,7 @@ const getDefaultConfig = () => {
        * @see https://tailwindcss.com/docs/border-style
        */
       'border-style': [{
-        border: [...getLineStyles(), 'hidden']
+        border: [].concat(_rollupPluginBabelHelpers.toConsumableArray(getLineStyles()), ['hidden'])
       }],
       /**
        * Divide Width X
@@ -1767,7 +1851,7 @@ const getDefaultConfig = () => {
        * @see https://tailwindcss.com/docs/outline-style
        */
       'outline-style': [{
-        outline: ['', ...getLineStyles()]
+        outline: [''].concat(_rollupPluginBabelHelpers.toConsumableArray(getLineStyles()))
       }],
       /**
        * Outline Offset
@@ -1857,7 +1941,7 @@ const getDefaultConfig = () => {
        * @see https://tailwindcss.com/docs/mix-blend-mode
        */
       'mix-blend': [{
-        'mix-blend': [...getBlendModes(), 'plus-lighter', 'plus-darker']
+        'mix-blend': [].concat(_rollupPluginBabelHelpers.toConsumableArray(getBlendModes()), ['plus-lighter', 'plus-darker'])
       }],
       /**
        * Background Blend Mode
@@ -2492,7 +2576,7 @@ const getDefaultConfig = () => {
     }
   };
 };
-const twMerge = /*#__PURE__*/createTailwindMerge(getDefaultConfig);
+var twMerge = /*#__PURE__*/createTailwindMerge(getDefaultConfig);
 
 exports.createTailwindMerge = createTailwindMerge;
 exports.fromTheme = fromTheme;