first commit

node_modules/tailwind-merge/dist/lib/class-utils.mjs

@@ -0,0 +1,141 @@
+var CLASS_PART_SEPARATOR = '-';
+function createClassUtils(config) {
+  var classMap = createClassMap(config);
+  var conflictingClassGroups = config.conflictingClassGroups,
+    _config$conflictingCl = config.conflictingClassGroupModifiers,
+    conflictingClassGroupModifiers = _config$conflictingCl === void 0 ? {} : _config$conflictingCl;
+  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);
+  }
+  function getConflictingClassGroupIds(classGroupId, hasPostfixModifier) {
+    var conflicts = conflictingClassGroups[classGroupId] || [];
+    if (hasPostfixModifier && conflictingClassGroupModifiers[classGroupId]) {
+      return [].concat(conflicts, conflictingClassGroupModifiers[classGroupId]);
+    }
+    return conflicts;
+  }
+  return {
+    getClassGroupId: getClassGroupId,
+    getConflictingClassGroupIds: getConflictingClassGroupIds
+  };
+}
+function getGroupRecursive(classParts, classPartObject) {
+  if (classParts.length === 0) {
+    return classPartObject.classGroupId;
+  }
+  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;
+  }
+  var classRest = classParts.join(CLASS_PART_SEPARATOR);
+  return classPartObject.validators.find(function (_ref) {
+    var validator = _ref.validator;
+    return validator(classRest);
+  })?.classGroupId;
+}
+var arbitraryPropertyRegex = /^\[(.+)\]$/;
+function getGroupIdForArbitraryProperty(className) {
+  if (arbitraryPropertyRegex.test(className)) {
+    var arbitraryPropertyClassName = arbitraryPropertyRegex.exec(className)[1];
+    var property = 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;
+    }
+  }
+}
+/**
+ * Exported for testing only
+ */
+function createClassMap(config) {
+  var theme = config.theme,
+    prefix = config.prefix;
+  var classMap = {
+    nextPart: new Map(),
+    validators: []
+  };
+  var prefixedClassGroupEntries = getPrefixedClassGroupEntries(Object.entries(config.classGroups), prefix);
+  prefixedClassGroupEntries.forEach(function (_ref2) {
+    var classGroupId = _ref2[0],
+      classGroup = _ref2[1];
+    processClassesRecursively(classGroup, classMap, classGroupId, theme);
+  });
+  return classMap;
+}
+function processClassesRecursively(classGroup, classPartObject, classGroupId, theme) {
+  classGroup.forEach(function (classDefinition) {
+    if (typeof classDefinition === 'string') {
+      var classPartObjectToEdit = classDefinition === '' ? classPartObject : getPart(classPartObject, classDefinition);
+      classPartObjectToEdit.classGroupId = classGroupId;
+      return;
+    }
+    if (typeof classDefinition === 'function') {
+      if (isThemeGetter(classDefinition)) {
+        processClassesRecursively(classDefinition(theme), classPartObject, classGroupId, theme);
+        return;
+      }
+      classPartObject.validators.push({
+        validator: classDefinition,
+        classGroupId: classGroupId
+      });
+      return;
+    }
+    Object.entries(classDefinition).forEach(function (_ref3) {
+      var key = _ref3[0],
+        classGroup = _ref3[1];
+      processClassesRecursively(classGroup, getPart(classPartObject, key), classGroupId, theme);
+    });
+  });
+}
+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(),
+        validators: []
+      });
+    }
+    currentClassPartObject = currentClassPartObject.nextPart.get(pathPart);
+  });
+  return currentClassPartObject;
+}
+function isThemeGetter(func) {
+  return func.isThemeGetter;
+}
+function getPrefixedClassGroupEntries(classGroupEntries, prefix) {
+  if (!prefix) {
+    return classGroupEntries;
+  }
+  return classGroupEntries.map(function (_ref4) {
+    var classGroupId = _ref4[0],
+      classGroup = _ref4[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(function (_ref5) {
+          var key = _ref5[0],
+            value = _ref5[1];
+          return [prefix + key, value];
+        }));
+      }
+      return classDefinition;
+    });
+    return [classGroupId, prefixedClassGroup];
+  });
+}
+
+export { createClassMap, createClassUtils };
+//# sourceMappingURL=class-utils.mjs.map