module.exports = [ "[project]/coding/projects/LangBot/web/node_modules/lucide-react/dist/esm/shared/src/utils.js [app-rsc] (ecmascript)", ((__turbopack_context__) => { "use strict"; __turbopack_context__.s([ "hasA11yProp", ()=>hasA11yProp, "mergeClasses", ()=>mergeClasses, "toCamelCase", ()=>toCamelCase, "toKebabCase", ()=>toKebabCase, "toPascalCase", ()=>toPascalCase ]); /** * @license lucide-react v0.507.0 - ISC * * This source code is licensed under the ISC license. * See the LICENSE file in the root directory of this source tree. */ const toKebabCase = (string)=>string.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase(); const toCamelCase = (string)=>string.replace(/^([A-Z])|[\s-_]+(\w)/g, (match, p1, p2)=>p2 ? p2.toUpperCase() : p1.toLowerCase()); const toPascalCase = (string)=>{ const camelCase = toCamelCase(string); return camelCase.charAt(0).toUpperCase() + camelCase.slice(1); }; const mergeClasses = (...classes)=>classes.filter((className, index, array)=>{ return Boolean(className) && className.trim() !== "" && array.indexOf(className) === index; }).join(" ").trim(); const hasA11yProp = (props)=>{ for(const prop in props){ if (prop.startsWith("aria-") || prop === "role" || prop === "title") { return true; } } }; ; //# sourceMappingURL=utils.js.map }), "[project]/coding/projects/LangBot/web/node_modules/lucide-react/dist/esm/defaultAttributes.js [app-rsc] (ecmascript)", ((__turbopack_context__) => { "use strict"; __turbopack_context__.s([ "default", ()=>defaultAttributes ]); /** * @license lucide-react v0.507.0 - ISC * * This source code is licensed under the ISC license. * See the LICENSE file in the root directory of this source tree. */ var defaultAttributes = { xmlns: "http://www.w3.org/2000/svg", width: 24, height: 24, viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: 2, strokeLinecap: "round", strokeLinejoin: "round" }; ; //# sourceMappingURL=defaultAttributes.js.map }), "[project]/coding/projects/LangBot/web/node_modules/lucide-react/dist/esm/Icon.js [app-rsc] (ecmascript)", ((__turbopack_context__) => { "use strict"; __turbopack_context__.s([ "default", ()=>Icon ]); /** * @license lucide-react v0.507.0 - ISC * * This source code is licensed under the ISC license. * See the LICENSE file in the root directory of this source tree. */ var __TURBOPACK__imported__module__$5b$project$5d2f$coding$2f$projects$2f$LangBot$2f$web$2f$node_modules$2f$next$2f$dist$2f$server$2f$route$2d$modules$2f$app$2d$page$2f$vendored$2f$rsc$2f$react$2e$js__$5b$app$2d$rsc$5d$__$28$ecmascript$29$__ = __turbopack_context__.i("[project]/coding/projects/LangBot/web/node_modules/next/dist/server/route-modules/app-page/vendored/rsc/react.js [app-rsc] (ecmascript)"); var __TURBOPACK__imported__module__$5b$project$5d2f$coding$2f$projects$2f$LangBot$2f$web$2f$node_modules$2f$lucide$2d$react$2f$dist$2f$esm$2f$defaultAttributes$2e$js__$5b$app$2d$rsc$5d$__$28$ecmascript$29$__ = __turbopack_context__.i("[project]/coding/projects/LangBot/web/node_modules/lucide-react/dist/esm/defaultAttributes.js [app-rsc] (ecmascript)"); var __TURBOPACK__imported__module__$5b$project$5d2f$coding$2f$projects$2f$LangBot$2f$web$2f$node_modules$2f$lucide$2d$react$2f$dist$2f$esm$2f$shared$2f$src$2f$utils$2e$js__$5b$app$2d$rsc$5d$__$28$ecmascript$29$__ = __turbopack_context__.i("[project]/coding/projects/LangBot/web/node_modules/lucide-react/dist/esm/shared/src/utils.js [app-rsc] (ecmascript)"); ; ; ; const Icon = (0, __TURBOPACK__imported__module__$5b$project$5d2f$coding$2f$projects$2f$LangBot$2f$web$2f$node_modules$2f$next$2f$dist$2f$server$2f$route$2d$modules$2f$app$2d$page$2f$vendored$2f$rsc$2f$react$2e$js__$5b$app$2d$rsc$5d$__$28$ecmascript$29$__["forwardRef"])(({ color = "currentColor", size = 24, strokeWidth = 2, absoluteStrokeWidth, className = "", children, iconNode, ...rest }, ref)=>(0, __TURBOPACK__imported__module__$5b$project$5d2f$coding$2f$projects$2f$LangBot$2f$web$2f$node_modules$2f$next$2f$dist$2f$server$2f$route$2d$modules$2f$app$2d$page$2f$vendored$2f$rsc$2f$react$2e$js__$5b$app$2d$rsc$5d$__$28$ecmascript$29$__["createElement"])("svg", { ref, ...__TURBOPACK__imported__module__$5b$project$5d2f$coding$2f$projects$2f$LangBot$2f$web$2f$node_modules$2f$lucide$2d$react$2f$dist$2f$esm$2f$defaultAttributes$2e$js__$5b$app$2d$rsc$5d$__$28$ecmascript$29$__["default"], width: size, height: size, stroke: color, strokeWidth: absoluteStrokeWidth ? Number(strokeWidth) * 24 / Number(size) : strokeWidth, className: (0, __TURBOPACK__imported__module__$5b$project$5d2f$coding$2f$projects$2f$LangBot$2f$web$2f$node_modules$2f$lucide$2d$react$2f$dist$2f$esm$2f$shared$2f$src$2f$utils$2e$js__$5b$app$2d$rsc$5d$__$28$ecmascript$29$__["mergeClasses"])("lucide", className), ...!children && !(0, __TURBOPACK__imported__module__$5b$project$5d2f$coding$2f$projects$2f$LangBot$2f$web$2f$node_modules$2f$lucide$2d$react$2f$dist$2f$esm$2f$shared$2f$src$2f$utils$2e$js__$5b$app$2d$rsc$5d$__$28$ecmascript$29$__["hasA11yProp"])(rest) && { "aria-hidden": "true" }, ...rest }, [ ...iconNode.map(([tag, attrs])=>(0, __TURBOPACK__imported__module__$5b$project$5d2f$coding$2f$projects$2f$LangBot$2f$web$2f$node_modules$2f$next$2f$dist$2f$server$2f$route$2d$modules$2f$app$2d$page$2f$vendored$2f$rsc$2f$react$2e$js__$5b$app$2d$rsc$5d$__$28$ecmascript$29$__["createElement"])(tag, attrs)), ...Array.isArray(children) ? children : [ children ] ])); ; //# sourceMappingURL=Icon.js.map }), "[project]/coding/projects/LangBot/web/node_modules/lucide-react/dist/esm/createLucideIcon.js [app-rsc] (ecmascript)", ((__turbopack_context__) => { "use strict"; __turbopack_context__.s([ "default", ()=>createLucideIcon ]); /** * @license lucide-react v0.507.0 - ISC * * This source code is licensed under the ISC license. * See the LICENSE file in the root directory of this source tree. */ var __TURBOPACK__imported__module__$5b$project$5d2f$coding$2f$projects$2f$LangBot$2f$web$2f$node_modules$2f$next$2f$dist$2f$server$2f$route$2d$modules$2f$app$2d$page$2f$vendored$2f$rsc$2f$react$2e$js__$5b$app$2d$rsc$5d$__$28$ecmascript$29$__ = __turbopack_context__.i("[project]/coding/projects/LangBot/web/node_modules/next/dist/server/route-modules/app-page/vendored/rsc/react.js [app-rsc] (ecmascript)"); var __TURBOPACK__imported__module__$5b$project$5d2f$coding$2f$projects$2f$LangBot$2f$web$2f$node_modules$2f$lucide$2d$react$2f$dist$2f$esm$2f$shared$2f$src$2f$utils$2e$js__$5b$app$2d$rsc$5d$__$28$ecmascript$29$__ = __turbopack_context__.i("[project]/coding/projects/LangBot/web/node_modules/lucide-react/dist/esm/shared/src/utils.js [app-rsc] (ecmascript)"); var __TURBOPACK__imported__module__$5b$project$5d2f$coding$2f$projects$2f$LangBot$2f$web$2f$node_modules$2f$lucide$2d$react$2f$dist$2f$esm$2f$Icon$2e$js__$5b$app$2d$rsc$5d$__$28$ecmascript$29$__ = __turbopack_context__.i("[project]/coding/projects/LangBot/web/node_modules/lucide-react/dist/esm/Icon.js [app-rsc] (ecmascript)"); ; ; ; const createLucideIcon = (iconName, iconNode)=>{ const Component = (0, __TURBOPACK__imported__module__$5b$project$5d2f$coding$2f$projects$2f$LangBot$2f$web$2f$node_modules$2f$next$2f$dist$2f$server$2f$route$2d$modules$2f$app$2d$page$2f$vendored$2f$rsc$2f$react$2e$js__$5b$app$2d$rsc$5d$__$28$ecmascript$29$__["forwardRef"])(({ className, ...props }, ref)=>(0, __TURBOPACK__imported__module__$5b$project$5d2f$coding$2f$projects$2f$LangBot$2f$web$2f$node_modules$2f$next$2f$dist$2f$server$2f$route$2d$modules$2f$app$2d$page$2f$vendored$2f$rsc$2f$react$2e$js__$5b$app$2d$rsc$5d$__$28$ecmascript$29$__["createElement"])(__TURBOPACK__imported__module__$5b$project$5d2f$coding$2f$projects$2f$LangBot$2f$web$2f$node_modules$2f$lucide$2d$react$2f$dist$2f$esm$2f$Icon$2e$js__$5b$app$2d$rsc$5d$__$28$ecmascript$29$__["default"], { ref, iconNode, className: (0, __TURBOPACK__imported__module__$5b$project$5d2f$coding$2f$projects$2f$LangBot$2f$web$2f$node_modules$2f$lucide$2d$react$2f$dist$2f$esm$2f$shared$2f$src$2f$utils$2e$js__$5b$app$2d$rsc$5d$__$28$ecmascript$29$__["mergeClasses"])(`lucide-${(0, __TURBOPACK__imported__module__$5b$project$5d2f$coding$2f$projects$2f$LangBot$2f$web$2f$node_modules$2f$lucide$2d$react$2f$dist$2f$esm$2f$shared$2f$src$2f$utils$2e$js__$5b$app$2d$rsc$5d$__$28$ecmascript$29$__["toKebabCase"])((0, __TURBOPACK__imported__module__$5b$project$5d2f$coding$2f$projects$2f$LangBot$2f$web$2f$node_modules$2f$lucide$2d$react$2f$dist$2f$esm$2f$shared$2f$src$2f$utils$2e$js__$5b$app$2d$rsc$5d$__$28$ecmascript$29$__["toPascalCase"])(iconName))}`, `lucide-${iconName}`, className), ...props })); Component.displayName = (0, __TURBOPACK__imported__module__$5b$project$5d2f$coding$2f$projects$2f$LangBot$2f$web$2f$node_modules$2f$lucide$2d$react$2f$dist$2f$esm$2f$shared$2f$src$2f$utils$2e$js__$5b$app$2d$rsc$5d$__$28$ecmascript$29$__["toPascalCase"])(iconName); return Component; }; ; //# sourceMappingURL=createLucideIcon.js.map }), "[project]/coding/projects/LangBot/web/node_modules/lucide-react/dist/esm/icons/loader-circle.js [app-rsc] (ecmascript)", ((__turbopack_context__) => { "use strict"; __turbopack_context__.s([ "__iconNode", ()=>__iconNode, "default", ()=>LoaderCircle ]); /** * @license lucide-react v0.507.0 - ISC * * This source code is licensed under the ISC license. * See the LICENSE file in the root directory of this source tree. */ var __TURBOPACK__imported__module__$5b$project$5d2f$coding$2f$projects$2f$LangBot$2f$web$2f$node_modules$2f$lucide$2d$react$2f$dist$2f$esm$2f$createLucideIcon$2e$js__$5b$app$2d$rsc$5d$__$28$ecmascript$29$__ = __turbopack_context__.i("[project]/coding/projects/LangBot/web/node_modules/lucide-react/dist/esm/createLucideIcon.js [app-rsc] (ecmascript)"); ; const __iconNode = [ [ "path", { d: "M21 12a9 9 0 1 1-6.219-8.56", key: "13zald" } ] ]; const LoaderCircle = (0, __TURBOPACK__imported__module__$5b$project$5d2f$coding$2f$projects$2f$LangBot$2f$web$2f$node_modules$2f$lucide$2d$react$2f$dist$2f$esm$2f$createLucideIcon$2e$js__$5b$app$2d$rsc$5d$__$28$ecmascript$29$__["default"])("loader-circle", __iconNode); ; //# sourceMappingURL=loader-circle.js.map }), "[project]/coding/projects/LangBot/web/node_modules/lucide-react/dist/esm/icons/loader-circle.js [app-rsc] (ecmascript) ", ((__turbopack_context__) => { "use strict"; __turbopack_context__.s([ "Loader2", ()=>__TURBOPACK__imported__module__$5b$project$5d2f$coding$2f$projects$2f$LangBot$2f$web$2f$node_modules$2f$lucide$2d$react$2f$dist$2f$esm$2f$icons$2f$loader$2d$circle$2e$js__$5b$app$2d$rsc$5d$__$28$ecmascript$29$__["default"] ]); var __TURBOPACK__imported__module__$5b$project$5d2f$coding$2f$projects$2f$LangBot$2f$web$2f$node_modules$2f$lucide$2d$react$2f$dist$2f$esm$2f$icons$2f$loader$2d$circle$2e$js__$5b$app$2d$rsc$5d$__$28$ecmascript$29$__ = __turbopack_context__.i("[project]/coding/projects/LangBot/web/node_modules/lucide-react/dist/esm/icons/loader-circle.js [app-rsc] (ecmascript)"); }), "[project]/coding/projects/LangBot/web/node_modules/clsx/dist/clsx.mjs [app-rsc] (ecmascript)", ((__turbopack_context__) => { "use strict"; __turbopack_context__.s([ "clsx", ()=>clsx, "default", ()=>__TURBOPACK__default__export__ ]); function r(e) { var t, f, n = ""; if ("string" == typeof e || "number" == typeof e) n += e; else if ("object" == typeof e) if (Array.isArray(e)) { var o = e.length; for(t = 0; t < o; t++)e[t] && (f = r(e[t])) && (n && (n += " "), n += f); } else for(f in e)e[f] && (n && (n += " "), n += f); return n; } function clsx() { for(var e, t, f = 0, n = "", o = arguments.length; f < o; f++)(e = arguments[f]) && (t = r(e)) && (n && (n += " "), n += t); return n; } const __TURBOPACK__default__export__ = clsx; }), "[project]/coding/projects/LangBot/web/node_modules/tailwind-merge/dist/bundle-mjs.mjs [app-rsc] (ecmascript)", ((__turbopack_context__) => { "use strict"; __turbopack_context__.s([ "createTailwindMerge", ()=>createTailwindMerge, "extendTailwindMerge", ()=>extendTailwindMerge, "fromTheme", ()=>fromTheme, "getDefaultConfig", ()=>getDefaultConfig, "mergeConfigs", ()=>mergeConfigs, "twJoin", ()=>twJoin, "twMerge", ()=>twMerge, "validators", ()=>validators ]); /** * Concatenates two arrays faster than the array spread operator. */ const concatArrays = (array1, array2)=>{ // Pre-allocate for better V8 optimization const combinedArray = new Array(array1.length + array2.length); for(let i = 0; i < array1.length; i++){ combinedArray[i] = array1[i]; } for(let i = 0; i < array2.length; i++){ combinedArray[array1.length + i] = array2[i]; } return combinedArray; }; // Factory function ensures consistent object shapes const createClassValidatorObject = (classGroupId, validator)=>({ classGroupId, validator }); // Factory ensures consistent ClassPartObject shape const createClassPartObject = (nextPart = new Map(), validators = null, classGroupId)=>({ nextPart, validators, classGroupId }); const CLASS_PART_SEPARATOR = '-'; const EMPTY_CONFLICTS = []; // I use two dots here because one dot is used as prefix for class groups in plugins const ARBITRARY_PROPERTY_PREFIX = 'arbitrary..'; const createClassGroupUtils = (config)=>{ const classMap = createClassMap(config); const { conflictingClassGroups, conflictingClassGroupModifiers } = config; const getClassGroupId = (className)=>{ if (className.startsWith('[') && className.endsWith(']')) { return getGroupIdForArbitraryProperty(className); } const 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 skip it. const startIndex = classParts[0] === '' && classParts.length > 1 ? 1 : 0; return getGroupRecursive(classParts, startIndex, classMap); }; const getConflictingClassGroupIds = (classGroupId, hasPostfixModifier)=>{ if (hasPostfixModifier) { const modifierConflicts = conflictingClassGroupModifiers[classGroupId]; const baseConflicts = conflictingClassGroups[classGroupId]; if (modifierConflicts) { if (baseConflicts) { // Merge base conflicts with modifier conflicts return concatArrays(baseConflicts, modifierConflicts); } // Only modifier conflicts return modifierConflicts; } // Fall back to without postfix if no modifier conflicts return baseConflicts || EMPTY_CONFLICTS; } return conflictingClassGroups[classGroupId] || EMPTY_CONFLICTS; }; return { getClassGroupId, getConflictingClassGroupIds }; }; const getGroupRecursive = (classParts, startIndex, classPartObject)=>{ const classPathsLength = classParts.length - startIndex; if (classPathsLength === 0) { return classPartObject.classGroupId; } const currentClassPart = classParts[startIndex]; const nextClassPartObject = classPartObject.nextPart.get(currentClassPart); if (nextClassPartObject) { const result = getGroupRecursive(classParts, startIndex + 1, nextClassPartObject); if (result) return result; } const validators = classPartObject.validators; if (validators === null) { return undefined; } // Build classRest string efficiently by joining from startIndex onwards const classRest = startIndex === 0 ? classParts.join(CLASS_PART_SEPARATOR) : classParts.slice(startIndex).join(CLASS_PART_SEPARATOR); const validatorsLength = validators.length; for(let i = 0; i < validatorsLength; i++){ const validatorObj = validators[i]; if (validatorObj.validator(classRest)) { return validatorObj.classGroupId; } } return undefined; }; /** * Get the class group ID for an arbitrary property. * * @param className - The class name to get the group ID for. Is expected to be string starting with `[` and ending with `]`. */ const getGroupIdForArbitraryProperty = (className)=>className.slice(1, -1).indexOf(':') === -1 ? undefined : (()=>{ const content = className.slice(1, -1); const colonIndex = content.indexOf(':'); const property = content.slice(0, colonIndex); return property ? ARBITRARY_PROPERTY_PREFIX + property : undefined; })(); /** * Exported for testing only */ const createClassMap = (config)=>{ const { theme, classGroups } = config; return processClassGroups(classGroups, theme); }; // Split into separate functions to maintain monomorphic call sites const processClassGroups = (classGroups, theme)=>{ const classMap = createClassPartObject(); for(const classGroupId in classGroups){ const group = classGroups[classGroupId]; processClassesRecursively(group, classMap, classGroupId, theme); } return classMap; }; const processClassesRecursively = (classGroup, classPartObject, classGroupId, theme)=>{ const len = classGroup.length; for(let i = 0; i < len; i++){ const classDefinition = classGroup[i]; processClassDefinition(classDefinition, classPartObject, classGroupId, theme); } }; // Split into separate functions for each type to maintain monomorphic call sites const processClassDefinition = (classDefinition, classPartObject, classGroupId, theme)=>{ if (typeof classDefinition === 'string') { processStringDefinition(classDefinition, classPartObject, classGroupId); return; } if (typeof classDefinition === 'function') { processFunctionDefinition(classDefinition, classPartObject, classGroupId, theme); return; } processObjectDefinition(classDefinition, classPartObject, classGroupId, theme); }; const processStringDefinition = (classDefinition, classPartObject, classGroupId)=>{ const classPartObjectToEdit = classDefinition === '' ? classPartObject : getPart(classPartObject, classDefinition); classPartObjectToEdit.classGroupId = classGroupId; }; const processFunctionDefinition = (classDefinition, classPartObject, classGroupId, theme)=>{ if (isThemeGetter(classDefinition)) { processClassesRecursively(classDefinition(theme), classPartObject, classGroupId, theme); return; } if (classPartObject.validators === null) { classPartObject.validators = []; } classPartObject.validators.push(createClassValidatorObject(classGroupId, classDefinition)); }; const processObjectDefinition = (classDefinition, classPartObject, classGroupId, theme)=>{ const entries = Object.entries(classDefinition); const len = entries.length; for(let i = 0; i < len; i++){ const [key, value] = entries[i]; processClassesRecursively(value, getPart(classPartObject, key), classGroupId, theme); } }; const getPart = (classPartObject, path)=>{ let current = classPartObject; const parts = path.split(CLASS_PART_SEPARATOR); const len = parts.length; for(let i = 0; i < len; i++){ const part = parts[i]; let next = current.nextPart.get(part); if (!next) { next = createClassPartObject(); current.nextPart.set(part, next); } current = next; } return current; }; // Type guard maintains monomorphic check const isThemeGetter = (func)=>'isThemeGetter' in func && func.isThemeGetter === true; // LRU cache implementation using plain objects for simplicity const createLruCache = (maxCacheSize)=>{ if (maxCacheSize < 1) { return { get: ()=>undefined, set: ()=>{} }; } let cacheSize = 0; let cache = Object.create(null); let previousCache = Object.create(null); const update = (key, value)=>{ cache[key] = value; cacheSize++; if (cacheSize > maxCacheSize) { cacheSize = 0; previousCache = cache; cache = Object.create(null); } }; return { get (key) { let value = cache[key]; if (value !== undefined) { return value; } if ((value = previousCache[key]) !== undefined) { update(key, value); return value; } }, set (key, value) { if (key in cache) { cache[key] = value; } else { update(key, value); } } }; }; const IMPORTANT_MODIFIER = '!'; const MODIFIER_SEPARATOR = ':'; const EMPTY_MODIFIERS = []; // Pre-allocated result object shape for consistency const createResultObject = (modifiers, hasImportantModifier, baseClassName, maybePostfixModifierPosition, isExternal)=>({ modifiers, hasImportantModifier, baseClassName, maybePostfixModifierPosition, isExternal }); const createParseClassName = (config)=>{ const { prefix, experimentalParseClassName } = config; /** * Parse class name into parts. * * Inspired by `splitAtTopLevelOnly` used in Tailwind CSS * @see https://github.com/tailwindlabs/tailwindcss/blob/v3.2.2/src/util/splitAtTopLevelOnly.js */ let parseClassName = (className)=>{ // Use simple array with push for better performance const modifiers = []; let bracketDepth = 0; let parenDepth = 0; let modifierStart = 0; let postfixModifierPosition; const len = className.length; for(let index = 0; index < len; index++){ const currentCharacter = className[index]; if (bracketDepth === 0 && parenDepth === 0) { if (currentCharacter === MODIFIER_SEPARATOR) { modifiers.push(className.slice(modifierStart, index)); modifierStart = index + 1; continue; } if (currentCharacter === '/') { postfixModifierPosition = index; continue; } } if (currentCharacter === '[') bracketDepth++; else if (currentCharacter === ']') bracketDepth--; else if (currentCharacter === '(') parenDepth++; else if (currentCharacter === ')') parenDepth--; } const baseClassNameWithImportantModifier = modifiers.length === 0 ? className : className.slice(modifierStart); // Inline important modifier check let baseClassName = baseClassNameWithImportantModifier; let hasImportantModifier = false; if (baseClassNameWithImportantModifier.endsWith(IMPORTANT_MODIFIER)) { baseClassName = baseClassNameWithImportantModifier.slice(0, -1); hasImportantModifier = true; } else if (/** * In Tailwind CSS v3 the important modifier was at the start of the base class name. This is still supported for legacy reasons. * @see https://github.com/dcastil/tailwind-merge/issues/513#issuecomment-2614029864 */ baseClassNameWithImportantModifier.startsWith(IMPORTANT_MODIFIER)) { baseClassName = baseClassNameWithImportantModifier.slice(1); hasImportantModifier = true; } const maybePostfixModifierPosition = postfixModifierPosition && postfixModifierPosition > modifierStart ? postfixModifierPosition - modifierStart : undefined; return createResultObject(modifiers, hasImportantModifier, baseClassName, maybePostfixModifierPosition); }; if (prefix) { const fullPrefix = prefix + MODIFIER_SEPARATOR; const parseClassNameOriginal = parseClassName; parseClassName = (className)=>className.startsWith(fullPrefix) ? parseClassNameOriginal(className.slice(fullPrefix.length)) : createResultObject(EMPTY_MODIFIERS, false, className, undefined, true); } if (experimentalParseClassName) { const parseClassNameOriginal = parseClassName; parseClassName = (className)=>experimentalParseClassName({ className, parseClassName: parseClassNameOriginal }); } return parseClassName; }; /** * Sorts modifiers according to following schema: * - Predefined modifiers are sorted alphabetically * - When an arbitrary variant appears, it must be preserved which modifiers are before and after it */ const createSortModifiers = (config)=>{ // Pre-compute weights for all known modifiers for O(1) comparison const modifierWeights = new Map(); // Assign weights to sensitive modifiers (highest priority, but preserve order) config.orderSensitiveModifiers.forEach((mod, index)=>{ modifierWeights.set(mod, 1000000 + index); // High weights for sensitive mods }); return (modifiers)=>{ const result = []; let currentSegment = []; // Process modifiers in one pass for(let i = 0; i < modifiers.length; i++){ const modifier = modifiers[i]; // Check if modifier is sensitive (starts with '[' or in orderSensitiveModifiers) const isArbitrary = modifier[0] === '['; const isOrderSensitive = modifierWeights.has(modifier); if (isArbitrary || isOrderSensitive) { // Sort and flush current segment alphabetically if (currentSegment.length > 0) { currentSegment.sort(); result.push(...currentSegment); currentSegment = []; } result.push(modifier); } else { // Regular modifier - add to current segment for batch sorting currentSegment.push(modifier); } } // Sort and add any remaining segment items if (currentSegment.length > 0) { currentSegment.sort(); result.push(...currentSegment); } return result; }; }; const createConfigUtils = (config)=>({ cache: createLruCache(config.cacheSize), parseClassName: createParseClassName(config), sortModifiers: createSortModifiers(config), ...createClassGroupUtils(config) }); const SPLIT_CLASSES_REGEX = /\s+/; const mergeClassList = (classList, configUtils)=>{ const { parseClassName, getClassGroupId, getConflictingClassGroupIds, sortModifiers } = configUtils; /** * Set of classGroupIds in following format: * `{importantModifier}{variantModifiers}{classGroupId}` * @example 'float' * @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 { isExternal, modifiers, hasImportantModifier, baseClassName, maybePostfixModifierPosition } = parseClassName(originalClassName); if (isExternal) { result = originalClassName + (result.length > 0 ? ' ' + result : result); continue; } let hasPostfixModifier = !!maybePostfixModifierPosition; let classGroupId = getClassGroupId(hasPostfixModifier ? baseClassName.substring(0, maybePostfixModifierPosition) : baseClassName); if (!classGroupId) { if (!hasPostfixModifier) { // Not a Tailwind class result = originalClassName + (result.length > 0 ? ' ' + result : result); continue; } classGroupId = getClassGroupId(baseClassName); if (!classGroupId) { // Not a Tailwind class result = originalClassName + (result.length > 0 ? ' ' + result : result); continue; } hasPostfixModifier = false; } // Fast path: skip sorting for empty or single modifier const variantModifier = modifiers.length === 0 ? '' : modifiers.length === 1 ? modifiers[0] : sortModifiers(modifiers).join(':'); const modifierId = hasImportantModifier ? variantModifier + IMPORTANT_MODIFIER : variantModifier; const classId = modifierId + classGroupId; if (classGroupsInConflict.indexOf(classId) > -1) { continue; } classGroupsInConflict.push(classId); const conflictGroups = getConflictingClassGroupIds(classGroupId, hasPostfixModifier); for(let i = 0; i < conflictGroups.length; ++i){ const group = conflictGroups[i]; classGroupsInConflict.push(modifierId + group); } // Tailwind class not in conflict result = originalClassName + (result.length > 0 ? ' ' + result : result); } return result; }; /** * The code in this file is copied from https://github.com/lukeed/clsx and modified to suit the needs of tailwind-merge better. * * Specifically: * - Runtime code from https://github.com/lukeed/clsx/blob/v1.2.1/src/index.js * - TypeScript types from https://github.com/lukeed/clsx/blob/v1.2.1/clsx.d.ts * * Original code has MIT license: Copyright (c) Luke Edwards (lukeed.com) */ const twJoin = (...classLists)=>{ let index = 0; let argument; let resolvedValue; let string = ''; while(index < classLists.length){ if (argument = classLists[index++]) { if (resolvedValue = toValue(argument)) { string && (string += ' '); string += resolvedValue; } } } return string; }; const toValue = (mix)=>{ // Fast path for strings if (typeof mix === 'string') { return mix; } let resolvedValue; let string = ''; for(let k = 0; k < mix.length; k++){ if (mix[k]) { if (resolvedValue = toValue(mix[k])) { string && (string += ' '); string += resolvedValue; } } } return string; }; const createTailwindMerge = (createConfigFirst, ...createConfigRest)=>{ let configUtils; let cacheGet; let cacheSet; let functionToCall; const initTailwindMerge = (classList)=>{ const config = createConfigRest.reduce((previousConfig, createConfigCurrent)=>createConfigCurrent(previousConfig), createConfigFirst()); configUtils = createConfigUtils(config); cacheGet = configUtils.cache.get; cacheSet = configUtils.cache.set; functionToCall = tailwindMerge; return tailwindMerge(classList); }; const tailwindMerge = (classList)=>{ const cachedResult = cacheGet(classList); if (cachedResult) { return cachedResult; } const result = mergeClassList(classList, configUtils); cacheSet(classList, result); return result; }; functionToCall = initTailwindMerge; return (...args)=>functionToCall(twJoin(...args)); }; const fallbackThemeArr = []; const fromTheme = (key)=>{ const themeGetter = (theme)=>theme[key] || fallbackThemeArr; themeGetter.isThemeGetter = true; return themeGetter; }; const arbitraryValueRegex = /^\[(?:(\w[\w-]*):)?(.+)\]$/i; const arbitraryVariableRegex = /^\((?:(\w[\w-]*):)?(.+)\)$/i; const fractionRegex = /^\d+\/\d+$/; 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)|color-mix)\(.+\)$/; // 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 isFraction = (value)=>fractionRegex.test(value); const isNumber = (value)=>!!value && !Number.isNaN(Number(value)); const isInteger = (value)=>!!value && Number.isInteger(Number(value)); const isPercent = (value)=>value.endsWith('%') && isNumber(value.slice(0, -1)); const isTshirtSize = (value)=>tshirtUnitRegex.test(value); const isAny = ()=>true; 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 isAnyNonArbitrary = (value)=>!isArbitraryValue(value) && !isArbitraryVariable(value); const isArbitrarySize = (value)=>getIsArbitraryValue(value, isLabelSize, isNever); const isArbitraryValue = (value)=>arbitraryValueRegex.test(value); const isArbitraryLength = (value)=>getIsArbitraryValue(value, isLabelLength, isLengthOnly); const isArbitraryNumber = (value)=>getIsArbitraryValue(value, isLabelNumber, isNumber); const isArbitraryPosition = (value)=>getIsArbitraryValue(value, isLabelPosition, isNever); const isArbitraryImage = (value)=>getIsArbitraryValue(value, isLabelImage, isImage); const isArbitraryShadow = (value)=>getIsArbitraryValue(value, isLabelShadow, isShadow); const isArbitraryVariable = (value)=>arbitraryVariableRegex.test(value); const isArbitraryVariableLength = (value)=>getIsArbitraryVariable(value, isLabelLength); const isArbitraryVariableFamilyName = (value)=>getIsArbitraryVariable(value, isLabelFamilyName); const isArbitraryVariablePosition = (value)=>getIsArbitraryVariable(value, isLabelPosition); const isArbitraryVariableSize = (value)=>getIsArbitraryVariable(value, isLabelSize); const isArbitraryVariableImage = (value)=>getIsArbitraryVariable(value, isLabelImage); const isArbitraryVariableShadow = (value)=>getIsArbitraryVariable(value, isLabelShadow, true); // Helpers const getIsArbitraryValue = (value, testLabel, testValue)=>{ const result = arbitraryValueRegex.exec(value); if (result) { if (result[1]) { return testLabel(result[1]); } return testValue(result[2]); } return false; }; const getIsArbitraryVariable = (value, testLabel, shouldMatchNoLabel = false)=>{ const result = arbitraryVariableRegex.exec(value); if (result) { if (result[1]) { return testLabel(result[1]); } return shouldMatchNoLabel; } return false; }; // Labels const isLabelPosition = (label)=>label === 'position' || label === 'percentage'; const isLabelImage = (label)=>label === 'image' || label === 'url'; const isLabelSize = (label)=>label === 'length' || label === 'size' || label === 'bg-size'; const isLabelLength = (label)=>label === 'length'; const isLabelNumber = (label)=>label === 'number'; const isLabelFamilyName = (label)=>label === 'family-name'; const isLabelShadow = (label)=>label === 'shadow'; const validators = /*#__PURE__*/ Object.defineProperty({ __proto__: null, isAny, isAnyNonArbitrary, isArbitraryImage, isArbitraryLength, isArbitraryNumber, isArbitraryPosition, isArbitraryShadow, isArbitrarySize, isArbitraryValue, isArbitraryVariable, isArbitraryVariableFamilyName, isArbitraryVariableImage, isArbitraryVariableLength, isArbitraryVariablePosition, isArbitraryVariableShadow, isArbitraryVariableSize, isFraction, isInteger, isNumber, isPercent, isTshirtSize }, Symbol.toStringTag, { value: 'Module' }); const getDefaultConfig = ()=>{ /** * Theme getters for theme variable namespaces * @see https://tailwindcss.com/docs/theme#theme-variable-namespaces */ /***/ const themeColor = fromTheme('color'); const themeFont = fromTheme('font'); const themeText = fromTheme('text'); const themeFontWeight = fromTheme('font-weight'); const themeTracking = fromTheme('tracking'); const themeLeading = fromTheme('leading'); const themeBreakpoint = fromTheme('breakpoint'); const themeContainer = fromTheme('container'); const themeSpacing = fromTheme('spacing'); const themeRadius = fromTheme('radius'); const themeShadow = fromTheme('shadow'); const themeInsetShadow = fromTheme('inset-shadow'); const themeTextShadow = fromTheme('text-shadow'); const themeDropShadow = fromTheme('drop-shadow'); const themeBlur = fromTheme('blur'); const themePerspective = fromTheme('perspective'); const themeAspect = fromTheme('aspect'); const themeEase = fromTheme('ease'); const themeAnimate = fromTheme('animate'); /** * Helpers to avoid repeating the same scales * * We use functions that create a new array every time they're called instead of static arrays. * This ensures that users who modify any scale by mutating the array (e.g. with `array.push(element)`) don't accidentally mutate arrays in other parts of the config. */ /***/ const scaleBreak = ()=>[ 'auto', 'avoid', 'all', 'avoid-page', 'page', 'left', 'right', 'column' ]; const scalePosition = ()=>[ 'center', 'top', 'bottom', 'left', 'right', 'top-left', // Deprecated since Tailwind CSS v4.1.0, see https://github.com/tailwindlabs/tailwindcss/pull/17378 'left-top', 'top-right', // Deprecated since Tailwind CSS v4.1.0, see https://github.com/tailwindlabs/tailwindcss/pull/17378 'right-top', 'bottom-right', // Deprecated since Tailwind CSS v4.1.0, see https://github.com/tailwindlabs/tailwindcss/pull/17378 'right-bottom', 'bottom-left', // Deprecated since Tailwind CSS v4.1.0, see https://github.com/tailwindlabs/tailwindcss/pull/17378 'left-bottom' ]; const scalePositionWithArbitrary = ()=>[ ...scalePosition(), isArbitraryVariable, isArbitraryValue ]; const scaleOverflow = ()=>[ 'auto', 'hidden', 'clip', 'visible', 'scroll' ]; const scaleOverscroll = ()=>[ 'auto', 'contain', 'none' ]; const scaleUnambiguousSpacing = ()=>[ isArbitraryVariable, isArbitraryValue, themeSpacing ]; const scaleInset = ()=>[ isFraction, 'full', 'auto', ...scaleUnambiguousSpacing() ]; const scaleGridTemplateColsRows = ()=>[ isInteger, 'none', 'subgrid', isArbitraryVariable, isArbitraryValue ]; const scaleGridColRowStartAndEnd = ()=>[ 'auto', { span: [ 'full', isInteger, isArbitraryVariable, isArbitraryValue ] }, isInteger, isArbitraryVariable, isArbitraryValue ]; const scaleGridColRowStartOrEnd = ()=>[ isInteger, 'auto', isArbitraryVariable, isArbitraryValue ]; const scaleGridAutoColsRows = ()=>[ 'auto', 'min', 'max', 'fr', isArbitraryVariable, isArbitraryValue ]; const scaleAlignPrimaryAxis = ()=>[ 'start', 'end', 'center', 'between', 'around', 'evenly', 'stretch', 'baseline', 'center-safe', 'end-safe' ]; const scaleAlignSecondaryAxis = ()=>[ 'start', 'end', 'center', 'stretch', 'center-safe', 'end-safe' ]; const scaleMargin = ()=>[ 'auto', ...scaleUnambiguousSpacing() ]; const scaleSizing = ()=>[ isFraction, 'auto', 'full', 'dvw', 'dvh', 'lvw', 'lvh', 'svw', 'svh', 'min', 'max', 'fit', ...scaleUnambiguousSpacing() ]; const scaleColor = ()=>[ themeColor, isArbitraryVariable, isArbitraryValue ]; const scaleBgPosition = ()=>[ ...scalePosition(), isArbitraryVariablePosition, isArbitraryPosition, { position: [ isArbitraryVariable, isArbitraryValue ] } ]; const scaleBgRepeat = ()=>[ 'no-repeat', { repeat: [ '', 'x', 'y', 'space', 'round' ] } ]; const scaleBgSize = ()=>[ 'auto', 'cover', 'contain', isArbitraryVariableSize, isArbitrarySize, { size: [ isArbitraryVariable, isArbitraryValue ] } ]; const scaleGradientStopPosition = ()=>[ isPercent, isArbitraryVariableLength, isArbitraryLength ]; const scaleRadius = ()=>[ // Deprecated since Tailwind CSS v4.0.0 '', 'none', 'full', themeRadius, isArbitraryVariable, isArbitraryValue ]; const scaleBorderWidth = ()=>[ '', isNumber, isArbitraryVariableLength, isArbitraryLength ]; const scaleLineStyle = ()=>[ 'solid', 'dashed', 'dotted', 'double' ]; const scaleBlendMode = ()=>[ 'normal', 'multiply', 'screen', 'overlay', 'darken', 'lighten', 'color-dodge', 'color-burn', 'hard-light', 'soft-light', 'difference', 'exclusion', 'hue', 'saturation', 'color', 'luminosity' ]; const scaleMaskImagePosition = ()=>[ isNumber, isPercent, isArbitraryVariablePosition, isArbitraryPosition ]; const scaleBlur = ()=>[ // Deprecated since Tailwind CSS v4.0.0 '', 'none', themeBlur, isArbitraryVariable, isArbitraryValue ]; const scaleRotate = ()=>[ 'none', isNumber, isArbitraryVariable, isArbitraryValue ]; const scaleScale = ()=>[ 'none', isNumber, isArbitraryVariable, isArbitraryValue ]; const scaleSkew = ()=>[ isNumber, isArbitraryVariable, isArbitraryValue ]; const scaleTranslate = ()=>[ isFraction, 'full', ...scaleUnambiguousSpacing() ]; return { cacheSize: 500, theme: { animate: [ 'spin', 'ping', 'pulse', 'bounce' ], aspect: [ 'video' ], blur: [ isTshirtSize ], breakpoint: [ isTshirtSize ], color: [ isAny ], container: [ isTshirtSize ], 'drop-shadow': [ isTshirtSize ], ease: [ 'in', 'out', 'in-out' ], font: [ isAnyNonArbitrary ], 'font-weight': [ 'thin', 'extralight', 'light', 'normal', 'medium', 'semibold', 'bold', 'extrabold', 'black' ], 'inset-shadow': [ isTshirtSize ], leading: [ 'none', 'tight', 'snug', 'normal', 'relaxed', 'loose' ], perspective: [ 'dramatic', 'near', 'normal', 'midrange', 'distant', 'none' ], radius: [ isTshirtSize ], shadow: [ isTshirtSize ], spacing: [ 'px', isNumber ], text: [ isTshirtSize ], 'text-shadow': [ isTshirtSize ], tracking: [ 'tighter', 'tight', 'normal', 'wide', 'wider', 'widest' ] }, classGroups: { // -------------- // --- Layout --- // -------------- /** * Aspect Ratio * @see https://tailwindcss.com/docs/aspect-ratio */ aspect: [ { aspect: [ 'auto', 'square', isFraction, isArbitraryValue, isArbitraryVariable, themeAspect ] } ], /** * Container * @see https://tailwindcss.com/docs/container * @deprecated since Tailwind CSS v4.0.0 */ container: [ 'container' ], /** * Columns * @see https://tailwindcss.com/docs/columns */ columns: [ { columns: [ isNumber, isArbitraryValue, isArbitraryVariable, themeContainer ] } ], /** * Break After * @see https://tailwindcss.com/docs/break-after */ 'break-after': [ { 'break-after': scaleBreak() } ], /** * Break Before * @see https://tailwindcss.com/docs/break-before */ 'break-before': [ { 'break-before': scaleBreak() } ], /** * Break Inside * @see https://tailwindcss.com/docs/break-inside */ 'break-inside': [ { 'break-inside': [ 'auto', 'avoid', 'avoid-page', 'avoid-column' ] } ], /** * Box Decoration Break * @see https://tailwindcss.com/docs/box-decoration-break */ 'box-decoration': [ { 'box-decoration': [ 'slice', 'clone' ] } ], /** * Box Sizing * @see https://tailwindcss.com/docs/box-sizing */ box: [ { box: [ 'border', 'content' ] } ], /** * Display * @see https://tailwindcss.com/docs/display */ display: [ 'block', 'inline-block', 'inline', 'flex', 'inline-flex', 'table', 'inline-table', 'table-caption', 'table-cell', 'table-column', 'table-column-group', 'table-footer-group', 'table-header-group', 'table-row-group', 'table-row', 'flow-root', 'grid', 'inline-grid', 'contents', 'list-item', 'hidden' ], /** * Screen Reader Only * @see https://tailwindcss.com/docs/display#screen-reader-only */ sr: [ 'sr-only', 'not-sr-only' ], /** * Floats * @see https://tailwindcss.com/docs/float */ float: [ { float: [ 'right', 'left', 'none', 'start', 'end' ] } ], /** * Clear * @see https://tailwindcss.com/docs/clear */ clear: [ { clear: [ 'left', 'right', 'both', 'none', 'start', 'end' ] } ], /** * Isolation * @see https://tailwindcss.com/docs/isolation */ isolation: [ 'isolate', 'isolation-auto' ], /** * Object Fit * @see https://tailwindcss.com/docs/object-fit */ 'object-fit': [ { object: [ 'contain', 'cover', 'fill', 'none', 'scale-down' ] } ], /** * Object Position * @see https://tailwindcss.com/docs/object-position */ 'object-position': [ { object: scalePositionWithArbitrary() } ], /** * Overflow * @see https://tailwindcss.com/docs/overflow */ overflow: [ { overflow: scaleOverflow() } ], /** * Overflow X * @see https://tailwindcss.com/docs/overflow */ 'overflow-x': [ { 'overflow-x': scaleOverflow() } ], /** * Overflow Y * @see https://tailwindcss.com/docs/overflow */ 'overflow-y': [ { 'overflow-y': scaleOverflow() } ], /** * Overscroll Behavior * @see https://tailwindcss.com/docs/overscroll-behavior */ overscroll: [ { overscroll: scaleOverscroll() } ], /** * Overscroll Behavior X * @see https://tailwindcss.com/docs/overscroll-behavior */ 'overscroll-x': [ { 'overscroll-x': scaleOverscroll() } ], /** * Overscroll Behavior Y * @see https://tailwindcss.com/docs/overscroll-behavior */ 'overscroll-y': [ { 'overscroll-y': scaleOverscroll() } ], /** * Position * @see https://tailwindcss.com/docs/position */ position: [ 'static', 'fixed', 'absolute', 'relative', 'sticky' ], /** * Top / Right / Bottom / Left * @see https://tailwindcss.com/docs/top-right-bottom-left */ inset: [ { inset: scaleInset() } ], /** * Right / Left * @see https://tailwindcss.com/docs/top-right-bottom-left */ 'inset-x': [ { 'inset-x': scaleInset() } ], /** * Top / Bottom * @see https://tailwindcss.com/docs/top-right-bottom-left */ 'inset-y': [ { 'inset-y': scaleInset() } ], /** * Start * @see https://tailwindcss.com/docs/top-right-bottom-left */ start: [ { start: scaleInset() } ], /** * End * @see https://tailwindcss.com/docs/top-right-bottom-left */ end: [ { end: scaleInset() } ], /** * Top * @see https://tailwindcss.com/docs/top-right-bottom-left */ top: [ { top: scaleInset() } ], /** * Right * @see https://tailwindcss.com/docs/top-right-bottom-left */ right: [ { right: scaleInset() } ], /** * Bottom * @see https://tailwindcss.com/docs/top-right-bottom-left */ bottom: [ { bottom: scaleInset() } ], /** * Left * @see https://tailwindcss.com/docs/top-right-bottom-left */ left: [ { left: scaleInset() } ], /** * Visibility * @see https://tailwindcss.com/docs/visibility */ visibility: [ 'visible', 'invisible', 'collapse' ], /** * Z-Index * @see https://tailwindcss.com/docs/z-index */ z: [ { z: [ isInteger, 'auto', isArbitraryVariable, isArbitraryValue ] } ], // ------------------------ // --- Flexbox and Grid --- // ------------------------ /** * Flex Basis * @see https://tailwindcss.com/docs/flex-basis */ basis: [ { basis: [ isFraction, 'full', 'auto', themeContainer, ...scaleUnambiguousSpacing() ] } ], /** * Flex Direction * @see https://tailwindcss.com/docs/flex-direction */ 'flex-direction': [ { flex: [ 'row', 'row-reverse', 'col', 'col-reverse' ] } ], /** * Flex Wrap * @see https://tailwindcss.com/docs/flex-wrap */ 'flex-wrap': [ { flex: [ 'nowrap', 'wrap', 'wrap-reverse' ] } ], /** * Flex * @see https://tailwindcss.com/docs/flex */ flex: [ { flex: [ isNumber, isFraction, 'auto', 'initial', 'none', isArbitraryValue ] } ], /** * Flex Grow * @see https://tailwindcss.com/docs/flex-grow */ grow: [ { grow: [ '', isNumber, isArbitraryVariable, isArbitraryValue ] } ], /** * Flex Shrink * @see https://tailwindcss.com/docs/flex-shrink */ shrink: [ { shrink: [ '', isNumber, isArbitraryVariable, isArbitraryValue ] } ], /** * Order * @see https://tailwindcss.com/docs/order */ order: [ { order: [ isInteger, 'first', 'last', 'none', isArbitraryVariable, isArbitraryValue ] } ], /** * Grid Template Columns * @see https://tailwindcss.com/docs/grid-template-columns */ 'grid-cols': [ { 'grid-cols': scaleGridTemplateColsRows() } ], /** * Grid Column Start / End * @see https://tailwindcss.com/docs/grid-column */ 'col-start-end': [ { col: scaleGridColRowStartAndEnd() } ], /** * Grid Column Start * @see https://tailwindcss.com/docs/grid-column */ 'col-start': [ { 'col-start': scaleGridColRowStartOrEnd() } ], /** * Grid Column End * @see https://tailwindcss.com/docs/grid-column */ 'col-end': [ { 'col-end': scaleGridColRowStartOrEnd() } ], /** * Grid Template Rows * @see https://tailwindcss.com/docs/grid-template-rows */ 'grid-rows': [ { 'grid-rows': scaleGridTemplateColsRows() } ], /** * Grid Row Start / End * @see https://tailwindcss.com/docs/grid-row */ 'row-start-end': [ { row: scaleGridColRowStartAndEnd() } ], /** * Grid Row Start * @see https://tailwindcss.com/docs/grid-row */ 'row-start': [ { 'row-start': scaleGridColRowStartOrEnd() } ], /** * Grid Row End * @see https://tailwindcss.com/docs/grid-row */ 'row-end': [ { 'row-end': scaleGridColRowStartOrEnd() } ], /** * Grid Auto Flow * @see https://tailwindcss.com/docs/grid-auto-flow */ 'grid-flow': [ { 'grid-flow': [ 'row', 'col', 'dense', 'row-dense', 'col-dense' ] } ], /** * Grid Auto Columns * @see https://tailwindcss.com/docs/grid-auto-columns */ 'auto-cols': [ { 'auto-cols': scaleGridAutoColsRows() } ], /** * Grid Auto Rows * @see https://tailwindcss.com/docs/grid-auto-rows */ 'auto-rows': [ { 'auto-rows': scaleGridAutoColsRows() } ], /** * Gap * @see https://tailwindcss.com/docs/gap */ gap: [ { gap: scaleUnambiguousSpacing() } ], /** * Gap X * @see https://tailwindcss.com/docs/gap */ 'gap-x': [ { 'gap-x': scaleUnambiguousSpacing() } ], /** * Gap Y * @see https://tailwindcss.com/docs/gap */ 'gap-y': [ { 'gap-y': scaleUnambiguousSpacing() } ], /** * Justify Content * @see https://tailwindcss.com/docs/justify-content */ 'justify-content': [ { justify: [ ...scaleAlignPrimaryAxis(), 'normal' ] } ], /** * Justify Items * @see https://tailwindcss.com/docs/justify-items */ 'justify-items': [ { 'justify-items': [ ...scaleAlignSecondaryAxis(), 'normal' ] } ], /** * Justify Self * @see https://tailwindcss.com/docs/justify-self */ 'justify-self': [ { 'justify-self': [ 'auto', ...scaleAlignSecondaryAxis() ] } ], /** * Align Content * @see https://tailwindcss.com/docs/align-content */ 'align-content': [ { content: [ 'normal', ...scaleAlignPrimaryAxis() ] } ], /** * Align Items * @see https://tailwindcss.com/docs/align-items */ 'align-items': [ { items: [ ...scaleAlignSecondaryAxis(), { baseline: [ '', 'last' ] } ] } ], /** * Align Self * @see https://tailwindcss.com/docs/align-self */ 'align-self': [ { self: [ 'auto', ...scaleAlignSecondaryAxis(), { baseline: [ '', 'last' ] } ] } ], /** * Place Content * @see https://tailwindcss.com/docs/place-content */ 'place-content': [ { 'place-content': scaleAlignPrimaryAxis() } ], /** * Place Items * @see https://tailwindcss.com/docs/place-items */ 'place-items': [ { 'place-items': [ ...scaleAlignSecondaryAxis(), 'baseline' ] } ], /** * Place Self * @see https://tailwindcss.com/docs/place-self */ 'place-self': [ { 'place-self': [ 'auto', ...scaleAlignSecondaryAxis() ] } ], // Spacing /** * Padding * @see https://tailwindcss.com/docs/padding */ p: [ { p: scaleUnambiguousSpacing() } ], /** * Padding X * @see https://tailwindcss.com/docs/padding */ px: [ { px: scaleUnambiguousSpacing() } ], /** * Padding Y * @see https://tailwindcss.com/docs/padding */ py: [ { py: scaleUnambiguousSpacing() } ], /** * Padding Start * @see https://tailwindcss.com/docs/padding */ ps: [ { ps: scaleUnambiguousSpacing() } ], /** * Padding End * @see https://tailwindcss.com/docs/padding */ pe: [ { pe: scaleUnambiguousSpacing() } ], /** * Padding Top * @see https://tailwindcss.com/docs/padding */ pt: [ { pt: scaleUnambiguousSpacing() } ], /** * Padding Right * @see https://tailwindcss.com/docs/padding */ pr: [ { pr: scaleUnambiguousSpacing() } ], /** * Padding Bottom * @see https://tailwindcss.com/docs/padding */ pb: [ { pb: scaleUnambiguousSpacing() } ], /** * Padding Left * @see https://tailwindcss.com/docs/padding */ pl: [ { pl: scaleUnambiguousSpacing() } ], /** * Margin * @see https://tailwindcss.com/docs/margin */ m: [ { m: scaleMargin() } ], /** * Margin X * @see https://tailwindcss.com/docs/margin */ mx: [ { mx: scaleMargin() } ], /** * Margin Y * @see https://tailwindcss.com/docs/margin */ my: [ { my: scaleMargin() } ], /** * Margin Start * @see https://tailwindcss.com/docs/margin */ ms: [ { ms: scaleMargin() } ], /** * Margin End * @see https://tailwindcss.com/docs/margin */ me: [ { me: scaleMargin() } ], /** * Margin Top * @see https://tailwindcss.com/docs/margin */ mt: [ { mt: scaleMargin() } ], /** * Margin Right * @see https://tailwindcss.com/docs/margin */ mr: [ { mr: scaleMargin() } ], /** * Margin Bottom * @see https://tailwindcss.com/docs/margin */ mb: [ { mb: scaleMargin() } ], /** * Margin Left * @see https://tailwindcss.com/docs/margin */ ml: [ { ml: scaleMargin() } ], /** * Space Between X * @see https://tailwindcss.com/docs/margin#adding-space-between-children */ 'space-x': [ { 'space-x': scaleUnambiguousSpacing() } ], /** * Space Between X Reverse * @see https://tailwindcss.com/docs/margin#adding-space-between-children */ 'space-x-reverse': [ 'space-x-reverse' ], /** * Space Between Y * @see https://tailwindcss.com/docs/margin#adding-space-between-children */ 'space-y': [ { 'space-y': scaleUnambiguousSpacing() } ], /** * Space Between Y Reverse * @see https://tailwindcss.com/docs/margin#adding-space-between-children */ 'space-y-reverse': [ 'space-y-reverse' ], // -------------- // --- Sizing --- // -------------- /** * Size * @see https://tailwindcss.com/docs/width#setting-both-width-and-height */ size: [ { size: scaleSizing() } ], /** * Width * @see https://tailwindcss.com/docs/width */ w: [ { w: [ themeContainer, 'screen', ...scaleSizing() ] } ], /** * Min-Width * @see https://tailwindcss.com/docs/min-width */ 'min-w': [ { 'min-w': [ themeContainer, 'screen', /** Deprecated. @see https://github.com/tailwindlabs/tailwindcss.com/issues/2027#issuecomment-2620152757 */ 'none', ...scaleSizing() ] } ], /** * Max-Width * @see https://tailwindcss.com/docs/max-width */ 'max-w': [ { 'max-w': [ themeContainer, 'screen', 'none', /** Deprecated since Tailwind CSS v4.0.0. @see https://github.com/tailwindlabs/tailwindcss.com/issues/2027#issuecomment-2620152757 */ 'prose', /** Deprecated since Tailwind CSS v4.0.0. @see https://github.com/tailwindlabs/tailwindcss.com/issues/2027#issuecomment-2620152757 */ { screen: [ themeBreakpoint ] }, ...scaleSizing() ] } ], /** * Height * @see https://tailwindcss.com/docs/height */ h: [ { h: [ 'screen', 'lh', ...scaleSizing() ] } ], /** * Min-Height * @see https://tailwindcss.com/docs/min-height */ 'min-h': [ { 'min-h': [ 'screen', 'lh', 'none', ...scaleSizing() ] } ], /** * Max-Height * @see https://tailwindcss.com/docs/max-height */ 'max-h': [ { 'max-h': [ 'screen', 'lh', ...scaleSizing() ] } ], // ------------------ // --- Typography --- // ------------------ /** * Font Size * @see https://tailwindcss.com/docs/font-size */ 'font-size': [ { text: [ 'base', themeText, isArbitraryVariableLength, isArbitraryLength ] } ], /** * Font Smoothing * @see https://tailwindcss.com/docs/font-smoothing */ 'font-smoothing': [ 'antialiased', 'subpixel-antialiased' ], /** * Font Style * @see https://tailwindcss.com/docs/font-style */ 'font-style': [ 'italic', 'not-italic' ], /** * Font Weight * @see https://tailwindcss.com/docs/font-weight */ 'font-weight': [ { font: [ themeFontWeight, isArbitraryVariable, isArbitraryNumber ] } ], /** * Font Stretch * @see https://tailwindcss.com/docs/font-stretch */ 'font-stretch': [ { 'font-stretch': [ 'ultra-condensed', 'extra-condensed', 'condensed', 'semi-condensed', 'normal', 'semi-expanded', 'expanded', 'extra-expanded', 'ultra-expanded', isPercent, isArbitraryValue ] } ], /** * Font Family * @see https://tailwindcss.com/docs/font-family */ 'font-family': [ { font: [ isArbitraryVariableFamilyName, isArbitraryValue, themeFont ] } ], /** * Font Variant Numeric * @see https://tailwindcss.com/docs/font-variant-numeric */ 'fvn-normal': [ 'normal-nums' ], /** * Font Variant Numeric * @see https://tailwindcss.com/docs/font-variant-numeric */ 'fvn-ordinal': [ 'ordinal' ], /** * Font Variant Numeric * @see https://tailwindcss.com/docs/font-variant-numeric */ 'fvn-slashed-zero': [ 'slashed-zero' ], /** * Font Variant Numeric * @see https://tailwindcss.com/docs/font-variant-numeric */ 'fvn-figure': [ 'lining-nums', 'oldstyle-nums' ], /** * Font Variant Numeric * @see https://tailwindcss.com/docs/font-variant-numeric */ 'fvn-spacing': [ 'proportional-nums', 'tabular-nums' ], /** * Font Variant Numeric * @see https://tailwindcss.com/docs/font-variant-numeric */ 'fvn-fraction': [ 'diagonal-fractions', 'stacked-fractions' ], /** * Letter Spacing * @see https://tailwindcss.com/docs/letter-spacing */ tracking: [ { tracking: [ themeTracking, isArbitraryVariable, isArbitraryValue ] } ], /** * Line Clamp * @see https://tailwindcss.com/docs/line-clamp */ 'line-clamp': [ { 'line-clamp': [ isNumber, 'none', isArbitraryVariable, isArbitraryNumber ] } ], /** * Line Height * @see https://tailwindcss.com/docs/line-height */ leading: [ { leading: [ /** Deprecated since Tailwind CSS v4.0.0. @see https://github.com/tailwindlabs/tailwindcss.com/issues/2027#issuecomment-2620152757 */ themeLeading, ...scaleUnambiguousSpacing() ] } ], /** * List Style Image * @see https://tailwindcss.com/docs/list-style-image */ 'list-image': [ { 'list-image': [ 'none', isArbitraryVariable, isArbitraryValue ] } ], /** * List Style Position * @see https://tailwindcss.com/docs/list-style-position */ 'list-style-position': [ { list: [ 'inside', 'outside' ] } ], /** * List Style Type * @see https://tailwindcss.com/docs/list-style-type */ 'list-style-type': [ { list: [ 'disc', 'decimal', 'none', isArbitraryVariable, isArbitraryValue ] } ], /** * Text Alignment * @see https://tailwindcss.com/docs/text-align */ 'text-alignment': [ { text: [ 'left', 'center', 'right', 'justify', 'start', 'end' ] } ], /** * Placeholder Color * @deprecated since Tailwind CSS v3.0.0 * @see https://v3.tailwindcss.com/docs/placeholder-color */ 'placeholder-color': [ { placeholder: scaleColor() } ], /** * Text Color * @see https://tailwindcss.com/docs/text-color */ 'text-color': [ { text: scaleColor() } ], /** * Text Decoration * @see https://tailwindcss.com/docs/text-decoration */ 'text-decoration': [ 'underline', 'overline', 'line-through', 'no-underline' ], /** * Text Decoration Style * @see https://tailwindcss.com/docs/text-decoration-style */ 'text-decoration-style': [ { decoration: [ ...scaleLineStyle(), 'wavy' ] } ], /** * Text Decoration Thickness * @see https://tailwindcss.com/docs/text-decoration-thickness */ 'text-decoration-thickness': [ { decoration: [ isNumber, 'from-font', 'auto', isArbitraryVariable, isArbitraryLength ] } ], /** * Text Decoration Color * @see https://tailwindcss.com/docs/text-decoration-color */ 'text-decoration-color': [ { decoration: scaleColor() } ], /** * Text Underline Offset * @see https://tailwindcss.com/docs/text-underline-offset */ 'underline-offset': [ { 'underline-offset': [ isNumber, 'auto', isArbitraryVariable, isArbitraryValue ] } ], /** * Text Transform * @see https://tailwindcss.com/docs/text-transform */ 'text-transform': [ 'uppercase', 'lowercase', 'capitalize', 'normal-case' ], /** * Text Overflow * @see https://tailwindcss.com/docs/text-overflow */ 'text-overflow': [ 'truncate', 'text-ellipsis', 'text-clip' ], /** * Text Wrap * @see https://tailwindcss.com/docs/text-wrap */ 'text-wrap': [ { text: [ 'wrap', 'nowrap', 'balance', 'pretty' ] } ], /** * Text Indent * @see https://tailwindcss.com/docs/text-indent */ indent: [ { indent: scaleUnambiguousSpacing() } ], /** * Vertical Alignment * @see https://tailwindcss.com/docs/vertical-align */ 'vertical-align': [ { align: [ 'baseline', 'top', 'middle', 'bottom', 'text-top', 'text-bottom', 'sub', 'super', isArbitraryVariable, isArbitraryValue ] } ], /** * Whitespace * @see https://tailwindcss.com/docs/whitespace */ whitespace: [ { whitespace: [ 'normal', 'nowrap', 'pre', 'pre-line', 'pre-wrap', 'break-spaces' ] } ], /** * Word Break * @see https://tailwindcss.com/docs/word-break */ break: [ { break: [ 'normal', 'words', 'all', 'keep' ] } ], /** * Overflow Wrap * @see https://tailwindcss.com/docs/overflow-wrap */ wrap: [ { wrap: [ 'break-word', 'anywhere', 'normal' ] } ], /** * Hyphens * @see https://tailwindcss.com/docs/hyphens */ hyphens: [ { hyphens: [ 'none', 'manual', 'auto' ] } ], /** * Content * @see https://tailwindcss.com/docs/content */ content: [ { content: [ 'none', isArbitraryVariable, isArbitraryValue ] } ], // ------------------- // --- Backgrounds --- // ------------------- /** * Background Attachment * @see https://tailwindcss.com/docs/background-attachment */ 'bg-attachment': [ { bg: [ 'fixed', 'local', 'scroll' ] } ], /** * Background Clip * @see https://tailwindcss.com/docs/background-clip */ 'bg-clip': [ { 'bg-clip': [ 'border', 'padding', 'content', 'text' ] } ], /** * Background Origin * @see https://tailwindcss.com/docs/background-origin */ 'bg-origin': [ { 'bg-origin': [ 'border', 'padding', 'content' ] } ], /** * Background Position * @see https://tailwindcss.com/docs/background-position */ 'bg-position': [ { bg: scaleBgPosition() } ], /** * Background Repeat * @see https://tailwindcss.com/docs/background-repeat */ 'bg-repeat': [ { bg: scaleBgRepeat() } ], /** * Background Size * @see https://tailwindcss.com/docs/background-size */ 'bg-size': [ { bg: scaleBgSize() } ], /** * Background Image * @see https://tailwindcss.com/docs/background-image */ 'bg-image': [ { bg: [ 'none', { linear: [ { to: [ 't', 'tr', 'r', 'br', 'b', 'bl', 'l', 'tl' ] }, isInteger, isArbitraryVariable, isArbitraryValue ], radial: [ '', isArbitraryVariable, isArbitraryValue ], conic: [ isInteger, isArbitraryVariable, isArbitraryValue ] }, isArbitraryVariableImage, isArbitraryImage ] } ], /** * Background Color * @see https://tailwindcss.com/docs/background-color */ 'bg-color': [ { bg: scaleColor() } ], /** * Gradient Color Stops From Position * @see https://tailwindcss.com/docs/gradient-color-stops */ 'gradient-from-pos': [ { from: scaleGradientStopPosition() } ], /** * Gradient Color Stops Via Position * @see https://tailwindcss.com/docs/gradient-color-stops */ 'gradient-via-pos': [ { via: scaleGradientStopPosition() } ], /** * Gradient Color Stops To Position * @see https://tailwindcss.com/docs/gradient-color-stops */ 'gradient-to-pos': [ { to: scaleGradientStopPosition() } ], /** * Gradient Color Stops From * @see https://tailwindcss.com/docs/gradient-color-stops */ 'gradient-from': [ { from: scaleColor() } ], /** * Gradient Color Stops Via * @see https://tailwindcss.com/docs/gradient-color-stops */ 'gradient-via': [ { via: scaleColor() } ], /** * Gradient Color Stops To * @see https://tailwindcss.com/docs/gradient-color-stops */ 'gradient-to': [ { to: scaleColor() } ], // --------------- // --- Borders --- // --------------- /** * Border Radius * @see https://tailwindcss.com/docs/border-radius */ rounded: [ { rounded: scaleRadius() } ], /** * Border Radius Start * @see https://tailwindcss.com/docs/border-radius */ 'rounded-s': [ { 'rounded-s': scaleRadius() } ], /** * Border Radius End * @see https://tailwindcss.com/docs/border-radius */ 'rounded-e': [ { 'rounded-e': scaleRadius() } ], /** * Border Radius Top * @see https://tailwindcss.com/docs/border-radius */ 'rounded-t': [ { 'rounded-t': scaleRadius() } ], /** * Border Radius Right * @see https://tailwindcss.com/docs/border-radius */ 'rounded-r': [ { 'rounded-r': scaleRadius() } ], /** * Border Radius Bottom * @see https://tailwindcss.com/docs/border-radius */ 'rounded-b': [ { 'rounded-b': scaleRadius() } ], /** * Border Radius Left * @see https://tailwindcss.com/docs/border-radius */ 'rounded-l': [ { 'rounded-l': scaleRadius() } ], /** * Border Radius Start Start * @see https://tailwindcss.com/docs/border-radius */ 'rounded-ss': [ { 'rounded-ss': scaleRadius() } ], /** * Border Radius Start End * @see https://tailwindcss.com/docs/border-radius */ 'rounded-se': [ { 'rounded-se': scaleRadius() } ], /** * Border Radius End End * @see https://tailwindcss.com/docs/border-radius */ 'rounded-ee': [ { 'rounded-ee': scaleRadius() } ], /** * Border Radius End Start * @see https://tailwindcss.com/docs/border-radius */ 'rounded-es': [ { 'rounded-es': scaleRadius() } ], /** * Border Radius Top Left * @see https://tailwindcss.com/docs/border-radius */ 'rounded-tl': [ { 'rounded-tl': scaleRadius() } ], /** * Border Radius Top Right * @see https://tailwindcss.com/docs/border-radius */ 'rounded-tr': [ { 'rounded-tr': scaleRadius() } ], /** * Border Radius Bottom Right * @see https://tailwindcss.com/docs/border-radius */ 'rounded-br': [ { 'rounded-br': scaleRadius() } ], /** * Border Radius Bottom Left * @see https://tailwindcss.com/docs/border-radius */ 'rounded-bl': [ { 'rounded-bl': scaleRadius() } ], /** * Border Width * @see https://tailwindcss.com/docs/border-width */ 'border-w': [ { border: scaleBorderWidth() } ], /** * Border Width X * @see https://tailwindcss.com/docs/border-width */ 'border-w-x': [ { 'border-x': scaleBorderWidth() } ], /** * Border Width Y * @see https://tailwindcss.com/docs/border-width */ 'border-w-y': [ { 'border-y': scaleBorderWidth() } ], /** * Border Width Start * @see https://tailwindcss.com/docs/border-width */ 'border-w-s': [ { 'border-s': scaleBorderWidth() } ], /** * Border Width End * @see https://tailwindcss.com/docs/border-width */ 'border-w-e': [ { 'border-e': scaleBorderWidth() } ], /** * Border Width Top * @see https://tailwindcss.com/docs/border-width */ 'border-w-t': [ { 'border-t': scaleBorderWidth() } ], /** * Border Width Right * @see https://tailwindcss.com/docs/border-width */ 'border-w-r': [ { 'border-r': scaleBorderWidth() } ], /** * Border Width Bottom * @see https://tailwindcss.com/docs/border-width */ 'border-w-b': [ { 'border-b': scaleBorderWidth() } ], /** * Border Width Left * @see https://tailwindcss.com/docs/border-width */ 'border-w-l': [ { 'border-l': scaleBorderWidth() } ], /** * Divide Width X * @see https://tailwindcss.com/docs/border-width#between-children */ 'divide-x': [ { 'divide-x': scaleBorderWidth() } ], /** * Divide Width X Reverse * @see https://tailwindcss.com/docs/border-width#between-children */ 'divide-x-reverse': [ 'divide-x-reverse' ], /** * Divide Width Y * @see https://tailwindcss.com/docs/border-width#between-children */ 'divide-y': [ { 'divide-y': scaleBorderWidth() } ], /** * Divide Width Y Reverse * @see https://tailwindcss.com/docs/border-width#between-children */ 'divide-y-reverse': [ 'divide-y-reverse' ], /** * Border Style * @see https://tailwindcss.com/docs/border-style */ 'border-style': [ { border: [ ...scaleLineStyle(), 'hidden', 'none' ] } ], /** * Divide Style * @see https://tailwindcss.com/docs/border-style#setting-the-divider-style */ 'divide-style': [ { divide: [ ...scaleLineStyle(), 'hidden', 'none' ] } ], /** * Border Color * @see https://tailwindcss.com/docs/border-color */ 'border-color': [ { border: scaleColor() } ], /** * Border Color X * @see https://tailwindcss.com/docs/border-color */ 'border-color-x': [ { 'border-x': scaleColor() } ], /** * Border Color Y * @see https://tailwindcss.com/docs/border-color */ 'border-color-y': [ { 'border-y': scaleColor() } ], /** * Border Color S * @see https://tailwindcss.com/docs/border-color */ 'border-color-s': [ { 'border-s': scaleColor() } ], /** * Border Color E * @see https://tailwindcss.com/docs/border-color */ 'border-color-e': [ { 'border-e': scaleColor() } ], /** * Border Color Top * @see https://tailwindcss.com/docs/border-color */ 'border-color-t': [ { 'border-t': scaleColor() } ], /** * Border Color Right * @see https://tailwindcss.com/docs/border-color */ 'border-color-r': [ { 'border-r': scaleColor() } ], /** * Border Color Bottom * @see https://tailwindcss.com/docs/border-color */ 'border-color-b': [ { 'border-b': scaleColor() } ], /** * Border Color Left * @see https://tailwindcss.com/docs/border-color */ 'border-color-l': [ { 'border-l': scaleColor() } ], /** * Divide Color * @see https://tailwindcss.com/docs/divide-color */ 'divide-color': [ { divide: scaleColor() } ], /** * Outline Style * @see https://tailwindcss.com/docs/outline-style */ 'outline-style': [ { outline: [ ...scaleLineStyle(), 'none', 'hidden' ] } ], /** * Outline Offset * @see https://tailwindcss.com/docs/outline-offset */ 'outline-offset': [ { 'outline-offset': [ isNumber, isArbitraryVariable, isArbitraryValue ] } ], /** * Outline Width * @see https://tailwindcss.com/docs/outline-width */ 'outline-w': [ { outline: [ '', isNumber, isArbitraryVariableLength, isArbitraryLength ] } ], /** * Outline Color * @see https://tailwindcss.com/docs/outline-color */ 'outline-color': [ { outline: scaleColor() } ], // --------------- // --- Effects --- // --------------- /** * Box Shadow * @see https://tailwindcss.com/docs/box-shadow */ shadow: [ { shadow: [ // Deprecated since Tailwind CSS v4.0.0 '', 'none', themeShadow, isArbitraryVariableShadow, isArbitraryShadow ] } ], /** * Box Shadow Color * @see https://tailwindcss.com/docs/box-shadow#setting-the-shadow-color */ 'shadow-color': [ { shadow: scaleColor() } ], /** * Inset Box Shadow * @see https://tailwindcss.com/docs/box-shadow#adding-an-inset-shadow */ 'inset-shadow': [ { 'inset-shadow': [ 'none', themeInsetShadow, isArbitraryVariableShadow, isArbitraryShadow ] } ], /** * Inset Box Shadow Color * @see https://tailwindcss.com/docs/box-shadow#setting-the-inset-shadow-color */ 'inset-shadow-color': [ { 'inset-shadow': scaleColor() } ], /** * Ring Width * @see https://tailwindcss.com/docs/box-shadow#adding-a-ring */ 'ring-w': [ { ring: scaleBorderWidth() } ], /** * Ring Width Inset * @see https://v3.tailwindcss.com/docs/ring-width#inset-rings * @deprecated since Tailwind CSS v4.0.0 * @see https://github.com/tailwindlabs/tailwindcss/blob/v4.0.0/packages/tailwindcss/src/utilities.ts#L4158 */ 'ring-w-inset': [ 'ring-inset' ], /** * Ring Color * @see https://tailwindcss.com/docs/box-shadow#setting-the-ring-color */ 'ring-color': [ { ring: scaleColor() } ], /** * Ring Offset Width * @see https://v3.tailwindcss.com/docs/ring-offset-width * @deprecated since Tailwind CSS v4.0.0 * @see https://github.com/tailwindlabs/tailwindcss/blob/v4.0.0/packages/tailwindcss/src/utilities.ts#L4158 */ 'ring-offset-w': [ { 'ring-offset': [ isNumber, isArbitraryLength ] } ], /** * Ring Offset Color * @see https://v3.tailwindcss.com/docs/ring-offset-color * @deprecated since Tailwind CSS v4.0.0 * @see https://github.com/tailwindlabs/tailwindcss/blob/v4.0.0/packages/tailwindcss/src/utilities.ts#L4158 */ 'ring-offset-color': [ { 'ring-offset': scaleColor() } ], /** * Inset Ring Width * @see https://tailwindcss.com/docs/box-shadow#adding-an-inset-ring */ 'inset-ring-w': [ { 'inset-ring': scaleBorderWidth() } ], /** * Inset Ring Color * @see https://tailwindcss.com/docs/box-shadow#setting-the-inset-ring-color */ 'inset-ring-color': [ { 'inset-ring': scaleColor() } ], /** * Text Shadow * @see https://tailwindcss.com/docs/text-shadow */ 'text-shadow': [ { 'text-shadow': [ 'none', themeTextShadow, isArbitraryVariableShadow, isArbitraryShadow ] } ], /** * Text Shadow Color * @see https://tailwindcss.com/docs/text-shadow#setting-the-shadow-color */ 'text-shadow-color': [ { 'text-shadow': scaleColor() } ], /** * Opacity * @see https://tailwindcss.com/docs/opacity */ opacity: [ { opacity: [ isNumber, isArbitraryVariable, isArbitraryValue ] } ], /** * Mix Blend Mode * @see https://tailwindcss.com/docs/mix-blend-mode */ 'mix-blend': [ { 'mix-blend': [ ...scaleBlendMode(), 'plus-darker', 'plus-lighter' ] } ], /** * Background Blend Mode * @see https://tailwindcss.com/docs/background-blend-mode */ 'bg-blend': [ { 'bg-blend': scaleBlendMode() } ], /** * Mask Clip * @see https://tailwindcss.com/docs/mask-clip */ 'mask-clip': [ { 'mask-clip': [ 'border', 'padding', 'content', 'fill', 'stroke', 'view' ] }, 'mask-no-clip' ], /** * Mask Composite * @see https://tailwindcss.com/docs/mask-composite */ 'mask-composite': [ { mask: [ 'add', 'subtract', 'intersect', 'exclude' ] } ], /** * Mask Image * @see https://tailwindcss.com/docs/mask-image */ 'mask-image-linear-pos': [ { 'mask-linear': [ isNumber ] } ], 'mask-image-linear-from-pos': [ { 'mask-linear-from': scaleMaskImagePosition() } ], 'mask-image-linear-to-pos': [ { 'mask-linear-to': scaleMaskImagePosition() } ], 'mask-image-linear-from-color': [ { 'mask-linear-from': scaleColor() } ], 'mask-image-linear-to-color': [ { 'mask-linear-to': scaleColor() } ], 'mask-image-t-from-pos': [ { 'mask-t-from': scaleMaskImagePosition() } ], 'mask-image-t-to-pos': [ { 'mask-t-to': scaleMaskImagePosition() } ], 'mask-image-t-from-color': [ { 'mask-t-from': scaleColor() } ], 'mask-image-t-to-color': [ { 'mask-t-to': scaleColor() } ], 'mask-image-r-from-pos': [ { 'mask-r-from': scaleMaskImagePosition() } ], 'mask-image-r-to-pos': [ { 'mask-r-to': scaleMaskImagePosition() } ], 'mask-image-r-from-color': [ { 'mask-r-from': scaleColor() } ], 'mask-image-r-to-color': [ { 'mask-r-to': scaleColor() } ], 'mask-image-b-from-pos': [ { 'mask-b-from': scaleMaskImagePosition() } ], 'mask-image-b-to-pos': [ { 'mask-b-to': scaleMaskImagePosition() } ], 'mask-image-b-from-color': [ { 'mask-b-from': scaleColor() } ], 'mask-image-b-to-color': [ { 'mask-b-to': scaleColor() } ], 'mask-image-l-from-pos': [ { 'mask-l-from': scaleMaskImagePosition() } ], 'mask-image-l-to-pos': [ { 'mask-l-to': scaleMaskImagePosition() } ], 'mask-image-l-from-color': [ { 'mask-l-from': scaleColor() } ], 'mask-image-l-to-color': [ { 'mask-l-to': scaleColor() } ], 'mask-image-x-from-pos': [ { 'mask-x-from': scaleMaskImagePosition() } ], 'mask-image-x-to-pos': [ { 'mask-x-to': scaleMaskImagePosition() } ], 'mask-image-x-from-color': [ { 'mask-x-from': scaleColor() } ], 'mask-image-x-to-color': [ { 'mask-x-to': scaleColor() } ], 'mask-image-y-from-pos': [ { 'mask-y-from': scaleMaskImagePosition() } ], 'mask-image-y-to-pos': [ { 'mask-y-to': scaleMaskImagePosition() } ], 'mask-image-y-from-color': [ { 'mask-y-from': scaleColor() } ], 'mask-image-y-to-color': [ { 'mask-y-to': scaleColor() } ], 'mask-image-radial': [ { 'mask-radial': [ isArbitraryVariable, isArbitraryValue ] } ], 'mask-image-radial-from-pos': [ { 'mask-radial-from': scaleMaskImagePosition() } ], 'mask-image-radial-to-pos': [ { 'mask-radial-to': scaleMaskImagePosition() } ], 'mask-image-radial-from-color': [ { 'mask-radial-from': scaleColor() } ], 'mask-image-radial-to-color': [ { 'mask-radial-to': scaleColor() } ], 'mask-image-radial-shape': [ { 'mask-radial': [ 'circle', 'ellipse' ] } ], 'mask-image-radial-size': [ { 'mask-radial': [ { closest: [ 'side', 'corner' ], farthest: [ 'side', 'corner' ] } ] } ], 'mask-image-radial-pos': [ { 'mask-radial-at': scalePosition() } ], 'mask-image-conic-pos': [ { 'mask-conic': [ isNumber ] } ], 'mask-image-conic-from-pos': [ { 'mask-conic-from': scaleMaskImagePosition() } ], 'mask-image-conic-to-pos': [ { 'mask-conic-to': scaleMaskImagePosition() } ], 'mask-image-conic-from-color': [ { 'mask-conic-from': scaleColor() } ], 'mask-image-conic-to-color': [ { 'mask-conic-to': scaleColor() } ], /** * Mask Mode * @see https://tailwindcss.com/docs/mask-mode */ 'mask-mode': [ { mask: [ 'alpha', 'luminance', 'match' ] } ], /** * Mask Origin * @see https://tailwindcss.com/docs/mask-origin */ 'mask-origin': [ { 'mask-origin': [ 'border', 'padding', 'content', 'fill', 'stroke', 'view' ] } ], /** * Mask Position * @see https://tailwindcss.com/docs/mask-position */ 'mask-position': [ { mask: scaleBgPosition() } ], /** * Mask Repeat * @see https://tailwindcss.com/docs/mask-repeat */ 'mask-repeat': [ { mask: scaleBgRepeat() } ], /** * Mask Size * @see https://tailwindcss.com/docs/mask-size */ 'mask-size': [ { mask: scaleBgSize() } ], /** * Mask Type * @see https://tailwindcss.com/docs/mask-type */ 'mask-type': [ { 'mask-type': [ 'alpha', 'luminance' ] } ], /** * Mask Image * @see https://tailwindcss.com/docs/mask-image */ 'mask-image': [ { mask: [ 'none', isArbitraryVariable, isArbitraryValue ] } ], // --------------- // --- Filters --- // --------------- /** * Filter * @see https://tailwindcss.com/docs/filter */ filter: [ { filter: [ // Deprecated since Tailwind CSS v3.0.0 '', 'none', isArbitraryVariable, isArbitraryValue ] } ], /** * Blur * @see https://tailwindcss.com/docs/blur */ blur: [ { blur: scaleBlur() } ], /** * Brightness * @see https://tailwindcss.com/docs/brightness */ brightness: [ { brightness: [ isNumber, isArbitraryVariable, isArbitraryValue ] } ], /** * Contrast * @see https://tailwindcss.com/docs/contrast */ contrast: [ { contrast: [ isNumber, isArbitraryVariable, isArbitraryValue ] } ], /** * Drop Shadow * @see https://tailwindcss.com/docs/drop-shadow */ 'drop-shadow': [ { 'drop-shadow': [ // Deprecated since Tailwind CSS v4.0.0 '', 'none', themeDropShadow, isArbitraryVariableShadow, isArbitraryShadow ] } ], /** * Drop Shadow Color * @see https://tailwindcss.com/docs/filter-drop-shadow#setting-the-shadow-color */ 'drop-shadow-color': [ { 'drop-shadow': scaleColor() } ], /** * Grayscale * @see https://tailwindcss.com/docs/grayscale */ grayscale: [ { grayscale: [ '', isNumber, isArbitraryVariable, isArbitraryValue ] } ], /** * Hue Rotate * @see https://tailwindcss.com/docs/hue-rotate */ 'hue-rotate': [ { 'hue-rotate': [ isNumber, isArbitraryVariable, isArbitraryValue ] } ], /** * Invert * @see https://tailwindcss.com/docs/invert */ invert: [ { invert: [ '', isNumber, isArbitraryVariable, isArbitraryValue ] } ], /** * Saturate * @see https://tailwindcss.com/docs/saturate */ saturate: [ { saturate: [ isNumber, isArbitraryVariable, isArbitraryValue ] } ], /** * Sepia * @see https://tailwindcss.com/docs/sepia */ sepia: [ { sepia: [ '', isNumber, isArbitraryVariable, isArbitraryValue ] } ], /** * Backdrop Filter * @see https://tailwindcss.com/docs/backdrop-filter */ 'backdrop-filter': [ { 'backdrop-filter': [ // Deprecated since Tailwind CSS v3.0.0 '', 'none', isArbitraryVariable, isArbitraryValue ] } ], /** * Backdrop Blur * @see https://tailwindcss.com/docs/backdrop-blur */ 'backdrop-blur': [ { 'backdrop-blur': scaleBlur() } ], /** * Backdrop Brightness * @see https://tailwindcss.com/docs/backdrop-brightness */ 'backdrop-brightness': [ { 'backdrop-brightness': [ isNumber, isArbitraryVariable, isArbitraryValue ] } ], /** * Backdrop Contrast * @see https://tailwindcss.com/docs/backdrop-contrast */ 'backdrop-contrast': [ { 'backdrop-contrast': [ isNumber, isArbitraryVariable, isArbitraryValue ] } ], /** * Backdrop Grayscale * @see https://tailwindcss.com/docs/backdrop-grayscale */ 'backdrop-grayscale': [ { 'backdrop-grayscale': [ '', isNumber, isArbitraryVariable, isArbitraryValue ] } ], /** * Backdrop Hue Rotate * @see https://tailwindcss.com/docs/backdrop-hue-rotate */ 'backdrop-hue-rotate': [ { 'backdrop-hue-rotate': [ isNumber, isArbitraryVariable, isArbitraryValue ] } ], /** * Backdrop Invert * @see https://tailwindcss.com/docs/backdrop-invert */ 'backdrop-invert': [ { 'backdrop-invert': [ '', isNumber, isArbitraryVariable, isArbitraryValue ] } ], /** * Backdrop Opacity * @see https://tailwindcss.com/docs/backdrop-opacity */ 'backdrop-opacity': [ { 'backdrop-opacity': [ isNumber, isArbitraryVariable, isArbitraryValue ] } ], /** * Backdrop Saturate * @see https://tailwindcss.com/docs/backdrop-saturate */ 'backdrop-saturate': [ { 'backdrop-saturate': [ isNumber, isArbitraryVariable, isArbitraryValue ] } ], /** * Backdrop Sepia * @see https://tailwindcss.com/docs/backdrop-sepia */ 'backdrop-sepia': [ { 'backdrop-sepia': [ '', isNumber, isArbitraryVariable, isArbitraryValue ] } ], // -------------- // --- Tables --- // -------------- /** * Border Collapse * @see https://tailwindcss.com/docs/border-collapse */ 'border-collapse': [ { border: [ 'collapse', 'separate' ] } ], /** * Border Spacing * @see https://tailwindcss.com/docs/border-spacing */ 'border-spacing': [ { 'border-spacing': scaleUnambiguousSpacing() } ], /** * Border Spacing X * @see https://tailwindcss.com/docs/border-spacing */ 'border-spacing-x': [ { 'border-spacing-x': scaleUnambiguousSpacing() } ], /** * Border Spacing Y * @see https://tailwindcss.com/docs/border-spacing */ 'border-spacing-y': [ { 'border-spacing-y': scaleUnambiguousSpacing() } ], /** * Table Layout * @see https://tailwindcss.com/docs/table-layout */ 'table-layout': [ { table: [ 'auto', 'fixed' ] } ], /** * Caption Side * @see https://tailwindcss.com/docs/caption-side */ caption: [ { caption: [ 'top', 'bottom' ] } ], // --------------------------------- // --- Transitions and Animation --- // --------------------------------- /** * Transition Property * @see https://tailwindcss.com/docs/transition-property */ transition: [ { transition: [ '', 'all', 'colors', 'opacity', 'shadow', 'transform', 'none', isArbitraryVariable, isArbitraryValue ] } ], /** * Transition Behavior * @see https://tailwindcss.com/docs/transition-behavior */ 'transition-behavior': [ { transition: [ 'normal', 'discrete' ] } ], /** * Transition Duration * @see https://tailwindcss.com/docs/transition-duration */ duration: [ { duration: [ isNumber, 'initial', isArbitraryVariable, isArbitraryValue ] } ], /** * Transition Timing Function * @see https://tailwindcss.com/docs/transition-timing-function */ ease: [ { ease: [ 'linear', 'initial', themeEase, isArbitraryVariable, isArbitraryValue ] } ], /** * Transition Delay * @see https://tailwindcss.com/docs/transition-delay */ delay: [ { delay: [ isNumber, isArbitraryVariable, isArbitraryValue ] } ], /** * Animation * @see https://tailwindcss.com/docs/animation */ animate: [ { animate: [ 'none', themeAnimate, isArbitraryVariable, isArbitraryValue ] } ], // ------------------ // --- Transforms --- // ------------------ /** * Backface Visibility * @see https://tailwindcss.com/docs/backface-visibility */ backface: [ { backface: [ 'hidden', 'visible' ] } ], /** * Perspective * @see https://tailwindcss.com/docs/perspective */ perspective: [ { perspective: [ themePerspective, isArbitraryVariable, isArbitraryValue ] } ], /** * Perspective Origin * @see https://tailwindcss.com/docs/perspective-origin */ 'perspective-origin': [ { 'perspective-origin': scalePositionWithArbitrary() } ], /** * Rotate * @see https://tailwindcss.com/docs/rotate */ rotate: [ { rotate: scaleRotate() } ], /** * Rotate X * @see https://tailwindcss.com/docs/rotate */ 'rotate-x': [ { 'rotate-x': scaleRotate() } ], /** * Rotate Y * @see https://tailwindcss.com/docs/rotate */ 'rotate-y': [ { 'rotate-y': scaleRotate() } ], /** * Rotate Z * @see https://tailwindcss.com/docs/rotate */ 'rotate-z': [ { 'rotate-z': scaleRotate() } ], /** * Scale * @see https://tailwindcss.com/docs/scale */ scale: [ { scale: scaleScale() } ], /** * Scale X * @see https://tailwindcss.com/docs/scale */ 'scale-x': [ { 'scale-x': scaleScale() } ], /** * Scale Y * @see https://tailwindcss.com/docs/scale */ 'scale-y': [ { 'scale-y': scaleScale() } ], /** * Scale Z * @see https://tailwindcss.com/docs/scale */ 'scale-z': [ { 'scale-z': scaleScale() } ], /** * Scale 3D * @see https://tailwindcss.com/docs/scale */ 'scale-3d': [ 'scale-3d' ], /** * Skew * @see https://tailwindcss.com/docs/skew */ skew: [ { skew: scaleSkew() } ], /** * Skew X * @see https://tailwindcss.com/docs/skew */ 'skew-x': [ { 'skew-x': scaleSkew() } ], /** * Skew Y * @see https://tailwindcss.com/docs/skew */ 'skew-y': [ { 'skew-y': scaleSkew() } ], /** * Transform * @see https://tailwindcss.com/docs/transform */ transform: [ { transform: [ isArbitraryVariable, isArbitraryValue, '', 'none', 'gpu', 'cpu' ] } ], /** * Transform Origin * @see https://tailwindcss.com/docs/transform-origin */ 'transform-origin': [ { origin: scalePositionWithArbitrary() } ], /** * Transform Style * @see https://tailwindcss.com/docs/transform-style */ 'transform-style': [ { transform: [ '3d', 'flat' ] } ], /** * Translate * @see https://tailwindcss.com/docs/translate */ translate: [ { translate: scaleTranslate() } ], /** * Translate X * @see https://tailwindcss.com/docs/translate */ 'translate-x': [ { 'translate-x': scaleTranslate() } ], /** * Translate Y * @see https://tailwindcss.com/docs/translate */ 'translate-y': [ { 'translate-y': scaleTranslate() } ], /** * Translate Z * @see https://tailwindcss.com/docs/translate */ 'translate-z': [ { 'translate-z': scaleTranslate() } ], /** * Translate None * @see https://tailwindcss.com/docs/translate */ 'translate-none': [ 'translate-none' ], // --------------------- // --- Interactivity --- // --------------------- /** * Accent Color * @see https://tailwindcss.com/docs/accent-color */ accent: [ { accent: scaleColor() } ], /** * Appearance * @see https://tailwindcss.com/docs/appearance */ appearance: [ { appearance: [ 'none', 'auto' ] } ], /** * Caret Color * @see https://tailwindcss.com/docs/just-in-time-mode#caret-color-utilities */ 'caret-color': [ { caret: scaleColor() } ], /** * Color Scheme * @see https://tailwindcss.com/docs/color-scheme */ 'color-scheme': [ { scheme: [ 'normal', 'dark', 'light', 'light-dark', 'only-dark', 'only-light' ] } ], /** * Cursor * @see https://tailwindcss.com/docs/cursor */ cursor: [ { cursor: [ 'auto', 'default', 'pointer', 'wait', 'text', 'move', 'help', 'not-allowed', 'none', 'context-menu', 'progress', 'cell', 'crosshair', 'vertical-text', 'alias', 'copy', 'no-drop', 'grab', 'grabbing', 'all-scroll', 'col-resize', 'row-resize', 'n-resize', 'e-resize', 's-resize', 'w-resize', 'ne-resize', 'nw-resize', 'se-resize', 'sw-resize', 'ew-resize', 'ns-resize', 'nesw-resize', 'nwse-resize', 'zoom-in', 'zoom-out', isArbitraryVariable, isArbitraryValue ] } ], /** * Field Sizing * @see https://tailwindcss.com/docs/field-sizing */ 'field-sizing': [ { 'field-sizing': [ 'fixed', 'content' ] } ], /** * Pointer Events * @see https://tailwindcss.com/docs/pointer-events */ 'pointer-events': [ { 'pointer-events': [ 'auto', 'none' ] } ], /** * Resize * @see https://tailwindcss.com/docs/resize */ resize: [ { resize: [ 'none', '', 'y', 'x' ] } ], /** * Scroll Behavior * @see https://tailwindcss.com/docs/scroll-behavior */ 'scroll-behavior': [ { scroll: [ 'auto', 'smooth' ] } ], /** * Scroll Margin * @see https://tailwindcss.com/docs/scroll-margin */ 'scroll-m': [ { 'scroll-m': scaleUnambiguousSpacing() } ], /** * Scroll Margin X * @see https://tailwindcss.com/docs/scroll-margin */ 'scroll-mx': [ { 'scroll-mx': scaleUnambiguousSpacing() } ], /** * Scroll Margin Y * @see https://tailwindcss.com/docs/scroll-margin */ 'scroll-my': [ { 'scroll-my': scaleUnambiguousSpacing() } ], /** * Scroll Margin Start * @see https://tailwindcss.com/docs/scroll-margin */ 'scroll-ms': [ { 'scroll-ms': scaleUnambiguousSpacing() } ], /** * Scroll Margin End * @see https://tailwindcss.com/docs/scroll-margin */ 'scroll-me': [ { 'scroll-me': scaleUnambiguousSpacing() } ], /** * Scroll Margin Top * @see https://tailwindcss.com/docs/scroll-margin */ 'scroll-mt': [ { 'scroll-mt': scaleUnambiguousSpacing() } ], /** * Scroll Margin Right * @see https://tailwindcss.com/docs/scroll-margin */ 'scroll-mr': [ { 'scroll-mr': scaleUnambiguousSpacing() } ], /** * Scroll Margin Bottom * @see https://tailwindcss.com/docs/scroll-margin */ 'scroll-mb': [ { 'scroll-mb': scaleUnambiguousSpacing() } ], /** * Scroll Margin Left * @see https://tailwindcss.com/docs/scroll-margin */ 'scroll-ml': [ { 'scroll-ml': scaleUnambiguousSpacing() } ], /** * Scroll Padding * @see https://tailwindcss.com/docs/scroll-padding */ 'scroll-p': [ { 'scroll-p': scaleUnambiguousSpacing() } ], /** * Scroll Padding X * @see https://tailwindcss.com/docs/scroll-padding */ 'scroll-px': [ { 'scroll-px': scaleUnambiguousSpacing() } ], /** * Scroll Padding Y * @see https://tailwindcss.com/docs/scroll-padding */ 'scroll-py': [ { 'scroll-py': scaleUnambiguousSpacing() } ], /** * Scroll Padding Start * @see https://tailwindcss.com/docs/scroll-padding */ 'scroll-ps': [ { 'scroll-ps': scaleUnambiguousSpacing() } ], /** * Scroll Padding End * @see https://tailwindcss.com/docs/scroll-padding */ 'scroll-pe': [ { 'scroll-pe': scaleUnambiguousSpacing() } ], /** * Scroll Padding Top * @see https://tailwindcss.com/docs/scroll-padding */ 'scroll-pt': [ { 'scroll-pt': scaleUnambiguousSpacing() } ], /** * Scroll Padding Right * @see https://tailwindcss.com/docs/scroll-padding */ 'scroll-pr': [ { 'scroll-pr': scaleUnambiguousSpacing() } ], /** * Scroll Padding Bottom * @see https://tailwindcss.com/docs/scroll-padding */ 'scroll-pb': [ { 'scroll-pb': scaleUnambiguousSpacing() } ], /** * Scroll Padding Left * @see https://tailwindcss.com/docs/scroll-padding */ 'scroll-pl': [ { 'scroll-pl': scaleUnambiguousSpacing() } ], /** * Scroll Snap Align * @see https://tailwindcss.com/docs/scroll-snap-align */ 'snap-align': [ { snap: [ 'start', 'end', 'center', 'align-none' ] } ], /** * Scroll Snap Stop * @see https://tailwindcss.com/docs/scroll-snap-stop */ 'snap-stop': [ { snap: [ 'normal', 'always' ] } ], /** * Scroll Snap Type * @see https://tailwindcss.com/docs/scroll-snap-type */ 'snap-type': [ { snap: [ 'none', 'x', 'y', 'both' ] } ], /** * Scroll Snap Type Strictness * @see https://tailwindcss.com/docs/scroll-snap-type */ 'snap-strictness': [ { snap: [ 'mandatory', 'proximity' ] } ], /** * Touch Action * @see https://tailwindcss.com/docs/touch-action */ touch: [ { touch: [ 'auto', 'none', 'manipulation' ] } ], /** * Touch Action X * @see https://tailwindcss.com/docs/touch-action */ 'touch-x': [ { 'touch-pan': [ 'x', 'left', 'right' ] } ], /** * Touch Action Y * @see https://tailwindcss.com/docs/touch-action */ 'touch-y': [ { 'touch-pan': [ 'y', 'up', 'down' ] } ], /** * Touch Action Pinch Zoom * @see https://tailwindcss.com/docs/touch-action */ 'touch-pz': [ 'touch-pinch-zoom' ], /** * User Select * @see https://tailwindcss.com/docs/user-select */ select: [ { select: [ 'none', 'text', 'all', 'auto' ] } ], /** * Will Change * @see https://tailwindcss.com/docs/will-change */ 'will-change': [ { 'will-change': [ 'auto', 'scroll', 'contents', 'transform', isArbitraryVariable, isArbitraryValue ] } ], // ----------- // --- SVG --- // ----------- /** * Fill * @see https://tailwindcss.com/docs/fill */ fill: [ { fill: [ 'none', ...scaleColor() ] } ], /** * Stroke Width * @see https://tailwindcss.com/docs/stroke-width */ 'stroke-w': [ { stroke: [ isNumber, isArbitraryVariableLength, isArbitraryLength, isArbitraryNumber ] } ], /** * Stroke * @see https://tailwindcss.com/docs/stroke */ stroke: [ { stroke: [ 'none', ...scaleColor() ] } ], // --------------------- // --- Accessibility --- // --------------------- /** * Forced Color Adjust * @see https://tailwindcss.com/docs/forced-color-adjust */ 'forced-color-adjust': [ { 'forced-color-adjust': [ 'auto', 'none' ] } ] }, conflictingClassGroups: { overflow: [ 'overflow-x', 'overflow-y' ], overscroll: [ 'overscroll-x', 'overscroll-y' ], inset: [ 'inset-x', 'inset-y', 'start', 'end', 'top', 'right', 'bottom', 'left' ], 'inset-x': [ 'right', 'left' ], 'inset-y': [ 'top', 'bottom' ], flex: [ 'basis', 'grow', 'shrink' ], gap: [ 'gap-x', 'gap-y' ], p: [ 'px', 'py', 'ps', 'pe', 'pt', 'pr', 'pb', 'pl' ], px: [ 'pr', 'pl' ], py: [ 'pt', 'pb' ], m: [ 'mx', 'my', 'ms', 'me', 'mt', 'mr', 'mb', 'ml' ], mx: [ 'mr', 'ml' ], my: [ 'mt', 'mb' ], size: [ 'w', 'h' ], 'font-size': [ 'leading' ], 'fvn-normal': [ 'fvn-ordinal', 'fvn-slashed-zero', 'fvn-figure', 'fvn-spacing', 'fvn-fraction' ], 'fvn-ordinal': [ 'fvn-normal' ], 'fvn-slashed-zero': [ 'fvn-normal' ], 'fvn-figure': [ 'fvn-normal' ], 'fvn-spacing': [ 'fvn-normal' ], 'fvn-fraction': [ 'fvn-normal' ], 'line-clamp': [ 'display', 'overflow' ], rounded: [ 'rounded-s', 'rounded-e', 'rounded-t', 'rounded-r', 'rounded-b', 'rounded-l', 'rounded-ss', 'rounded-se', 'rounded-ee', 'rounded-es', 'rounded-tl', 'rounded-tr', 'rounded-br', 'rounded-bl' ], 'rounded-s': [ 'rounded-ss', 'rounded-es' ], 'rounded-e': [ 'rounded-se', 'rounded-ee' ], 'rounded-t': [ 'rounded-tl', 'rounded-tr' ], 'rounded-r': [ 'rounded-tr', 'rounded-br' ], 'rounded-b': [ 'rounded-br', 'rounded-bl' ], 'rounded-l': [ 'rounded-tl', 'rounded-bl' ], 'border-spacing': [ 'border-spacing-x', 'border-spacing-y' ], 'border-w': [ 'border-w-x', 'border-w-y', 'border-w-s', 'border-w-e', 'border-w-t', 'border-w-r', 'border-w-b', 'border-w-l' ], 'border-w-x': [ 'border-w-r', 'border-w-l' ], 'border-w-y': [ 'border-w-t', 'border-w-b' ], 'border-color': [ 'border-color-x', 'border-color-y', 'border-color-s', 'border-color-e', 'border-color-t', 'border-color-r', 'border-color-b', 'border-color-l' ], 'border-color-x': [ 'border-color-r', 'border-color-l' ], 'border-color-y': [ 'border-color-t', 'border-color-b' ], translate: [ 'translate-x', 'translate-y', 'translate-none' ], 'translate-none': [ 'translate', 'translate-x', 'translate-y', 'translate-z' ], 'scroll-m': [ 'scroll-mx', 'scroll-my', 'scroll-ms', 'scroll-me', 'scroll-mt', 'scroll-mr', 'scroll-mb', 'scroll-ml' ], 'scroll-mx': [ 'scroll-mr', 'scroll-ml' ], 'scroll-my': [ 'scroll-mt', 'scroll-mb' ], 'scroll-p': [ 'scroll-px', 'scroll-py', 'scroll-ps', 'scroll-pe', 'scroll-pt', 'scroll-pr', 'scroll-pb', 'scroll-pl' ], 'scroll-px': [ 'scroll-pr', 'scroll-pl' ], 'scroll-py': [ 'scroll-pt', 'scroll-pb' ], touch: [ 'touch-x', 'touch-y', 'touch-pz' ], 'touch-x': [ 'touch' ], 'touch-y': [ 'touch' ], 'touch-pz': [ 'touch' ] }, conflictingClassGroupModifiers: { 'font-size': [ 'leading' ] }, orderSensitiveModifiers: [ '*', '**', 'after', 'backdrop', 'before', 'details-content', 'file', 'first-letter', 'first-line', 'marker', 'placeholder', 'selection' ] }; }; /** * @param baseConfig Config where other config will be merged into. This object will be mutated. * @param configExtension Partial config to merge into the `baseConfig`. */ const mergeConfigs = (baseConfig, { cacheSize, prefix, experimentalParseClassName, extend = {}, override = {} })=>{ overrideProperty(baseConfig, 'cacheSize', cacheSize); overrideProperty(baseConfig, 'prefix', prefix); overrideProperty(baseConfig, 'experimentalParseClassName', experimentalParseClassName); overrideConfigProperties(baseConfig.theme, override.theme); overrideConfigProperties(baseConfig.classGroups, override.classGroups); overrideConfigProperties(baseConfig.conflictingClassGroups, override.conflictingClassGroups); overrideConfigProperties(baseConfig.conflictingClassGroupModifiers, override.conflictingClassGroupModifiers); overrideProperty(baseConfig, 'orderSensitiveModifiers', override.orderSensitiveModifiers); mergeConfigProperties(baseConfig.theme, extend.theme); mergeConfigProperties(baseConfig.classGroups, extend.classGroups); mergeConfigProperties(baseConfig.conflictingClassGroups, extend.conflictingClassGroups); mergeConfigProperties(baseConfig.conflictingClassGroupModifiers, extend.conflictingClassGroupModifiers); mergeArrayProperties(baseConfig, extend, 'orderSensitiveModifiers'); return baseConfig; }; const overrideProperty = (baseObject, overrideKey, overrideValue)=>{ if (overrideValue !== undefined) { baseObject[overrideKey] = overrideValue; } }; const overrideConfigProperties = (baseObject, overrideObject)=>{ if (overrideObject) { for(const key in overrideObject){ overrideProperty(baseObject, key, overrideObject[key]); } } }; const mergeConfigProperties = (baseObject, mergeObject)=>{ if (mergeObject) { for(const key in mergeObject){ mergeArrayProperties(baseObject, mergeObject, key); } } }; const mergeArrayProperties = (baseObject, mergeObject, key)=>{ const mergeValue = mergeObject[key]; if (mergeValue !== undefined) { baseObject[key] = baseObject[key] ? baseObject[key].concat(mergeValue) : mergeValue; } }; const extendTailwindMerge = (configExtension, ...createConfig)=>typeof configExtension === 'function' ? createTailwindMerge(getDefaultConfig, configExtension, ...createConfig) : createTailwindMerge(()=>mergeConfigs(getDefaultConfig(), configExtension), ...createConfig); const twMerge = /*#__PURE__*/ createTailwindMerge(getDefaultConfig); ; //# sourceMappingURL=bundle-mjs.mjs.map }), ]; //# sourceMappingURL=a2e30_cf6abf9c._.js.map