drupal-canvas 0.1.1 → 0.1.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -1,1915 +0,0 @@
1
- //#region ../../node_modules/clsx/dist/clsx.mjs
2
- function r(e) {
3
- var t, f, n = "";
4
- if ("string" == typeof e || "number" == typeof e) n += e;
5
- else if ("object" == typeof e) if (Array.isArray(e)) {
6
- var o = e.length;
7
- for (t = 0; t < o; t++) e[t] && (f = r(e[t])) && (n && (n += " "), n += f);
8
- } else for (f in e) e[f] && (n && (n += " "), n += f);
9
- return n;
10
- }
11
- function clsx() {
12
- for (var e, t, f = 0, n = "", o = arguments.length; f < o; f++) (e = arguments[f]) && (t = r(e)) && (n && (n += " "), n += t);
13
- return n;
14
- }
15
-
16
- //#endregion
17
- //#region ../../node_modules/tailwind-merge/dist/bundle-mjs.mjs
18
- /**
19
- * Concatenates two arrays faster than the array spread operator.
20
- */
21
- const concatArrays = (array1, array2) => {
22
- const combinedArray = new Array(array1.length + array2.length);
23
- for (let i = 0; i < array1.length; i++) combinedArray[i] = array1[i];
24
- for (let i = 0; i < array2.length; i++) combinedArray[array1.length + i] = array2[i];
25
- return combinedArray;
26
- };
27
- const createClassValidatorObject = (classGroupId, validator) => ({
28
- classGroupId,
29
- validator
30
- });
31
- const createClassPartObject = (nextPart = /* @__PURE__ */ new Map(), validators = null, classGroupId) => ({
32
- nextPart,
33
- validators,
34
- classGroupId
35
- });
36
- const CLASS_PART_SEPARATOR = "-";
37
- const EMPTY_CONFLICTS = [];
38
- const ARBITRARY_PROPERTY_PREFIX = "arbitrary..";
39
- const createClassGroupUtils = (config) => {
40
- const classMap = createClassMap(config);
41
- const { conflictingClassGroups, conflictingClassGroupModifiers } = config;
42
- const getClassGroupId = (className) => {
43
- if (className.startsWith("[") && className.endsWith("]")) return getGroupIdForArbitraryProperty(className);
44
- const classParts = className.split(CLASS_PART_SEPARATOR);
45
- return getGroupRecursive(classParts, classParts[0] === "" && classParts.length > 1 ? 1 : 0, classMap);
46
- };
47
- const getConflictingClassGroupIds = (classGroupId, hasPostfixModifier) => {
48
- if (hasPostfixModifier) {
49
- const modifierConflicts = conflictingClassGroupModifiers[classGroupId];
50
- const baseConflicts = conflictingClassGroups[classGroupId];
51
- if (modifierConflicts) {
52
- if (baseConflicts) return concatArrays(baseConflicts, modifierConflicts);
53
- return modifierConflicts;
54
- }
55
- return baseConflicts || EMPTY_CONFLICTS;
56
- }
57
- return conflictingClassGroups[classGroupId] || EMPTY_CONFLICTS;
58
- };
59
- return {
60
- getClassGroupId,
61
- getConflictingClassGroupIds
62
- };
63
- };
64
- const getGroupRecursive = (classParts, startIndex, classPartObject) => {
65
- if (classParts.length - startIndex === 0) return classPartObject.classGroupId;
66
- const currentClassPart = classParts[startIndex];
67
- const nextClassPartObject = classPartObject.nextPart.get(currentClassPart);
68
- if (nextClassPartObject) {
69
- const result = getGroupRecursive(classParts, startIndex + 1, nextClassPartObject);
70
- if (result) return result;
71
- }
72
- const validators = classPartObject.validators;
73
- if (validators === null) return;
74
- const classRest = startIndex === 0 ? classParts.join(CLASS_PART_SEPARATOR) : classParts.slice(startIndex).join(CLASS_PART_SEPARATOR);
75
- const validatorsLength = validators.length;
76
- for (let i = 0; i < validatorsLength; i++) {
77
- const validatorObj = validators[i];
78
- if (validatorObj.validator(classRest)) return validatorObj.classGroupId;
79
- }
80
- };
81
- /**
82
- * Get the class group ID for an arbitrary property.
83
- *
84
- * @param className - The class name to get the group ID for. Is expected to be string starting with `[` and ending with `]`.
85
- */
86
- const getGroupIdForArbitraryProperty = (className) => className.slice(1, -1).indexOf(":") === -1 ? void 0 : (() => {
87
- const content = className.slice(1, -1);
88
- const colonIndex = content.indexOf(":");
89
- const property = content.slice(0, colonIndex);
90
- return property ? ARBITRARY_PROPERTY_PREFIX + property : void 0;
91
- })();
92
- /**
93
- * Exported for testing only
94
- */
95
- const createClassMap = (config) => {
96
- const { theme, classGroups } = config;
97
- return processClassGroups(classGroups, theme);
98
- };
99
- const processClassGroups = (classGroups, theme) => {
100
- const classMap = createClassPartObject();
101
- for (const classGroupId in classGroups) {
102
- const group = classGroups[classGroupId];
103
- processClassesRecursively(group, classMap, classGroupId, theme);
104
- }
105
- return classMap;
106
- };
107
- const processClassesRecursively = (classGroup, classPartObject, classGroupId, theme) => {
108
- const len = classGroup.length;
109
- for (let i = 0; i < len; i++) {
110
- const classDefinition = classGroup[i];
111
- processClassDefinition(classDefinition, classPartObject, classGroupId, theme);
112
- }
113
- };
114
- const processClassDefinition = (classDefinition, classPartObject, classGroupId, theme) => {
115
- if (typeof classDefinition === "string") {
116
- processStringDefinition(classDefinition, classPartObject, classGroupId);
117
- return;
118
- }
119
- if (typeof classDefinition === "function") {
120
- processFunctionDefinition(classDefinition, classPartObject, classGroupId, theme);
121
- return;
122
- }
123
- processObjectDefinition(classDefinition, classPartObject, classGroupId, theme);
124
- };
125
- const processStringDefinition = (classDefinition, classPartObject, classGroupId) => {
126
- const classPartObjectToEdit = classDefinition === "" ? classPartObject : getPart(classPartObject, classDefinition);
127
- classPartObjectToEdit.classGroupId = classGroupId;
128
- };
129
- const processFunctionDefinition = (classDefinition, classPartObject, classGroupId, theme) => {
130
- if (isThemeGetter(classDefinition)) {
131
- processClassesRecursively(classDefinition(theme), classPartObject, classGroupId, theme);
132
- return;
133
- }
134
- if (classPartObject.validators === null) classPartObject.validators = [];
135
- classPartObject.validators.push(createClassValidatorObject(classGroupId, classDefinition));
136
- };
137
- const processObjectDefinition = (classDefinition, classPartObject, classGroupId, theme) => {
138
- const entries = Object.entries(classDefinition);
139
- const len = entries.length;
140
- for (let i = 0; i < len; i++) {
141
- const [key, value] = entries[i];
142
- processClassesRecursively(value, getPart(classPartObject, key), classGroupId, theme);
143
- }
144
- };
145
- const getPart = (classPartObject, path) => {
146
- let current = classPartObject;
147
- const parts = path.split(CLASS_PART_SEPARATOR);
148
- const len = parts.length;
149
- for (let i = 0; i < len; i++) {
150
- const part = parts[i];
151
- let next = current.nextPart.get(part);
152
- if (!next) {
153
- next = createClassPartObject();
154
- current.nextPart.set(part, next);
155
- }
156
- current = next;
157
- }
158
- return current;
159
- };
160
- const isThemeGetter = (func) => "isThemeGetter" in func && func.isThemeGetter === true;
161
- const createLruCache = (maxCacheSize) => {
162
- if (maxCacheSize < 1) return {
163
- get: () => void 0,
164
- set: () => {}
165
- };
166
- let cacheSize = 0;
167
- let cache = Object.create(null);
168
- let previousCache = Object.create(null);
169
- const update = (key, value) => {
170
- cache[key] = value;
171
- cacheSize++;
172
- if (cacheSize > maxCacheSize) {
173
- cacheSize = 0;
174
- previousCache = cache;
175
- cache = Object.create(null);
176
- }
177
- };
178
- return {
179
- get(key) {
180
- let value = cache[key];
181
- if (value !== void 0) return value;
182
- if ((value = previousCache[key]) !== void 0) {
183
- update(key, value);
184
- return value;
185
- }
186
- },
187
- set(key, value) {
188
- if (key in cache) cache[key] = value;
189
- else update(key, value);
190
- }
191
- };
192
- };
193
- const IMPORTANT_MODIFIER = "!";
194
- const MODIFIER_SEPARATOR = ":";
195
- const EMPTY_MODIFIERS = [];
196
- const createResultObject = (modifiers, hasImportantModifier, baseClassName, maybePostfixModifierPosition, isExternal) => ({
197
- modifiers,
198
- hasImportantModifier,
199
- baseClassName,
200
- maybePostfixModifierPosition,
201
- isExternal
202
- });
203
- const createParseClassName = (config) => {
204
- const { prefix, experimentalParseClassName } = config;
205
- /**
206
- * Parse class name into parts.
207
- *
208
- * Inspired by `splitAtTopLevelOnly` used in Tailwind CSS
209
- * @see https://github.com/tailwindlabs/tailwindcss/blob/v3.2.2/src/util/splitAtTopLevelOnly.js
210
- */
211
- let parseClassName = (className) => {
212
- const modifiers = [];
213
- let bracketDepth = 0;
214
- let parenDepth = 0;
215
- let modifierStart = 0;
216
- let postfixModifierPosition;
217
- const len = className.length;
218
- for (let index = 0; index < len; index++) {
219
- const currentCharacter = className[index];
220
- if (bracketDepth === 0 && parenDepth === 0) {
221
- if (currentCharacter === MODIFIER_SEPARATOR) {
222
- modifiers.push(className.slice(modifierStart, index));
223
- modifierStart = index + 1;
224
- continue;
225
- }
226
- if (currentCharacter === "/") {
227
- postfixModifierPosition = index;
228
- continue;
229
- }
230
- }
231
- if (currentCharacter === "[") bracketDepth++;
232
- else if (currentCharacter === "]") bracketDepth--;
233
- else if (currentCharacter === "(") parenDepth++;
234
- else if (currentCharacter === ")") parenDepth--;
235
- }
236
- const baseClassNameWithImportantModifier = modifiers.length === 0 ? className : className.slice(modifierStart);
237
- let baseClassName = baseClassNameWithImportantModifier;
238
- let hasImportantModifier = false;
239
- if (baseClassNameWithImportantModifier.endsWith(IMPORTANT_MODIFIER)) {
240
- baseClassName = baseClassNameWithImportantModifier.slice(0, -1);
241
- hasImportantModifier = true;
242
- } else if (baseClassNameWithImportantModifier.startsWith(IMPORTANT_MODIFIER)) {
243
- baseClassName = baseClassNameWithImportantModifier.slice(1);
244
- hasImportantModifier = true;
245
- }
246
- const maybePostfixModifierPosition = postfixModifierPosition && postfixModifierPosition > modifierStart ? postfixModifierPosition - modifierStart : void 0;
247
- return createResultObject(modifiers, hasImportantModifier, baseClassName, maybePostfixModifierPosition);
248
- };
249
- if (prefix) {
250
- const fullPrefix = prefix + MODIFIER_SEPARATOR;
251
- const parseClassNameOriginal = parseClassName;
252
- parseClassName = (className) => className.startsWith(fullPrefix) ? parseClassNameOriginal(className.slice(fullPrefix.length)) : createResultObject(EMPTY_MODIFIERS, false, className, void 0, true);
253
- }
254
- if (experimentalParseClassName) {
255
- const parseClassNameOriginal = parseClassName;
256
- parseClassName = (className) => experimentalParseClassName({
257
- className,
258
- parseClassName: parseClassNameOriginal
259
- });
260
- }
261
- return parseClassName;
262
- };
263
- /**
264
- * Sorts modifiers according to following schema:
265
- * - Predefined modifiers are sorted alphabetically
266
- * - When an arbitrary variant appears, it must be preserved which modifiers are before and after it
267
- */
268
- const createSortModifiers = (config) => {
269
- const modifierWeights = /* @__PURE__ */ new Map();
270
- config.orderSensitiveModifiers.forEach((mod, index) => {
271
- modifierWeights.set(mod, 1e6 + index);
272
- });
273
- return (modifiers) => {
274
- const result = [];
275
- let currentSegment = [];
276
- for (let i = 0; i < modifiers.length; i++) {
277
- const modifier = modifiers[i];
278
- const isArbitrary = modifier[0] === "[";
279
- const isOrderSensitive = modifierWeights.has(modifier);
280
- if (isArbitrary || isOrderSensitive) {
281
- if (currentSegment.length > 0) {
282
- currentSegment.sort();
283
- result.push(...currentSegment);
284
- currentSegment = [];
285
- }
286
- result.push(modifier);
287
- } else currentSegment.push(modifier);
288
- }
289
- if (currentSegment.length > 0) {
290
- currentSegment.sort();
291
- result.push(...currentSegment);
292
- }
293
- return result;
294
- };
295
- };
296
- const createConfigUtils = (config) => ({
297
- cache: createLruCache(config.cacheSize),
298
- parseClassName: createParseClassName(config),
299
- sortModifiers: createSortModifiers(config),
300
- ...createClassGroupUtils(config)
301
- });
302
- const SPLIT_CLASSES_REGEX = /\s+/;
303
- const mergeClassList = (classList, configUtils) => {
304
- const { parseClassName, getClassGroupId, getConflictingClassGroupIds, sortModifiers } = configUtils;
305
- /**
306
- * Set of classGroupIds in following format:
307
- * `{importantModifier}{variantModifiers}{classGroupId}`
308
- * @example 'float'
309
- * @example 'hover:focus:bg-color'
310
- * @example 'md:!pr'
311
- */
312
- const classGroupsInConflict = [];
313
- const classNames = classList.trim().split(SPLIT_CLASSES_REGEX);
314
- let result = "";
315
- for (let index = classNames.length - 1; index >= 0; index -= 1) {
316
- const originalClassName = classNames[index];
317
- const { isExternal, modifiers, hasImportantModifier, baseClassName, maybePostfixModifierPosition } = parseClassName(originalClassName);
318
- if (isExternal) {
319
- result = originalClassName + (result.length > 0 ? " " + result : result);
320
- continue;
321
- }
322
- let hasPostfixModifier = !!maybePostfixModifierPosition;
323
- let classGroupId = getClassGroupId(hasPostfixModifier ? baseClassName.substring(0, maybePostfixModifierPosition) : baseClassName);
324
- if (!classGroupId) {
325
- if (!hasPostfixModifier) {
326
- result = originalClassName + (result.length > 0 ? " " + result : result);
327
- continue;
328
- }
329
- classGroupId = getClassGroupId(baseClassName);
330
- if (!classGroupId) {
331
- result = originalClassName + (result.length > 0 ? " " + result : result);
332
- continue;
333
- }
334
- hasPostfixModifier = false;
335
- }
336
- const variantModifier = modifiers.length === 0 ? "" : modifiers.length === 1 ? modifiers[0] : sortModifiers(modifiers).join(":");
337
- const modifierId = hasImportantModifier ? variantModifier + IMPORTANT_MODIFIER : variantModifier;
338
- const classId = modifierId + classGroupId;
339
- if (classGroupsInConflict.indexOf(classId) > -1) continue;
340
- classGroupsInConflict.push(classId);
341
- const conflictGroups = getConflictingClassGroupIds(classGroupId, hasPostfixModifier);
342
- for (let i = 0; i < conflictGroups.length; ++i) {
343
- const group = conflictGroups[i];
344
- classGroupsInConflict.push(modifierId + group);
345
- }
346
- result = originalClassName + (result.length > 0 ? " " + result : result);
347
- }
348
- return result;
349
- };
350
- /**
351
- * The code in this file is copied from https://github.com/lukeed/clsx and modified to suit the needs of tailwind-merge better.
352
- *
353
- * Specifically:
354
- * - Runtime code from https://github.com/lukeed/clsx/blob/v1.2.1/src/index.js
355
- * - TypeScript types from https://github.com/lukeed/clsx/blob/v1.2.1/clsx.d.ts
356
- *
357
- * Original code has MIT license: Copyright (c) Luke Edwards <luke.edwards05@gmail.com> (lukeed.com)
358
- */
359
- const twJoin = (...classLists) => {
360
- let index = 0;
361
- let argument;
362
- let resolvedValue;
363
- let string = "";
364
- while (index < classLists.length) if (argument = classLists[index++]) {
365
- if (resolvedValue = toValue(argument)) {
366
- string && (string += " ");
367
- string += resolvedValue;
368
- }
369
- }
370
- return string;
371
- };
372
- const toValue = (mix) => {
373
- if (typeof mix === "string") return mix;
374
- let resolvedValue;
375
- let string = "";
376
- for (let k = 0; k < mix.length; k++) if (mix[k]) {
377
- if (resolvedValue = toValue(mix[k])) {
378
- string && (string += " ");
379
- string += resolvedValue;
380
- }
381
- }
382
- return string;
383
- };
384
- const createTailwindMerge = (createConfigFirst, ...createConfigRest) => {
385
- let configUtils;
386
- let cacheGet;
387
- let cacheSet;
388
- let functionToCall;
389
- const initTailwindMerge = (classList) => {
390
- configUtils = createConfigUtils(createConfigRest.reduce((previousConfig, createConfigCurrent) => createConfigCurrent(previousConfig), createConfigFirst()));
391
- cacheGet = configUtils.cache.get;
392
- cacheSet = configUtils.cache.set;
393
- functionToCall = tailwindMerge;
394
- return tailwindMerge(classList);
395
- };
396
- const tailwindMerge = (classList) => {
397
- const cachedResult = cacheGet(classList);
398
- if (cachedResult) return cachedResult;
399
- const result = mergeClassList(classList, configUtils);
400
- cacheSet(classList, result);
401
- return result;
402
- };
403
- functionToCall = initTailwindMerge;
404
- return (...args) => functionToCall(twJoin(...args));
405
- };
406
- const fallbackThemeArr = [];
407
- const fromTheme = (key) => {
408
- const themeGetter = (theme) => theme[key] || fallbackThemeArr;
409
- themeGetter.isThemeGetter = true;
410
- return themeGetter;
411
- };
412
- const arbitraryValueRegex = /^\[(?:(\w[\w-]*):)?(.+)\]$/i;
413
- const arbitraryVariableRegex = /^\((?:(\w[\w-]*):)?(.+)\)$/i;
414
- const fractionRegex = /^\d+\/\d+$/;
415
- const tshirtUnitRegex = /^(\d+(\.\d+)?)?(xs|sm|md|lg|xl)$/;
416
- 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$/;
417
- const colorFunctionRegex = /^(rgba?|hsla?|hwb|(ok)?(lab|lch)|color-mix)\(.+\)$/;
418
- const shadowRegex = /^(inset_)?-?((\d+)?\.?(\d+)[a-z]+|0)_-?((\d+)?\.?(\d+)[a-z]+|0)/;
419
- const imageRegex = /^(url|image|image-set|cross-fade|element|(repeating-)?(linear|radial|conic)-gradient)\(.+\)$/;
420
- const isFraction = (value) => fractionRegex.test(value);
421
- const isNumber = (value) => !!value && !Number.isNaN(Number(value));
422
- const isInteger = (value) => !!value && Number.isInteger(Number(value));
423
- const isPercent = (value) => value.endsWith("%") && isNumber(value.slice(0, -1));
424
- const isTshirtSize = (value) => tshirtUnitRegex.test(value);
425
- const isAny = () => true;
426
- const isLengthOnly = (value) => lengthUnitRegex.test(value) && !colorFunctionRegex.test(value);
427
- const isNever = () => false;
428
- const isShadow = (value) => shadowRegex.test(value);
429
- const isImage = (value) => imageRegex.test(value);
430
- const isAnyNonArbitrary = (value) => !isArbitraryValue(value) && !isArbitraryVariable(value);
431
- const isArbitrarySize = (value) => getIsArbitraryValue(value, isLabelSize, isNever);
432
- const isArbitraryValue = (value) => arbitraryValueRegex.test(value);
433
- const isArbitraryLength = (value) => getIsArbitraryValue(value, isLabelLength, isLengthOnly);
434
- const isArbitraryNumber = (value) => getIsArbitraryValue(value, isLabelNumber, isNumber);
435
- const isArbitraryPosition = (value) => getIsArbitraryValue(value, isLabelPosition, isNever);
436
- const isArbitraryImage = (value) => getIsArbitraryValue(value, isLabelImage, isImage);
437
- const isArbitraryShadow = (value) => getIsArbitraryValue(value, isLabelShadow, isShadow);
438
- const isArbitraryVariable = (value) => arbitraryVariableRegex.test(value);
439
- const isArbitraryVariableLength = (value) => getIsArbitraryVariable(value, isLabelLength);
440
- const isArbitraryVariableFamilyName = (value) => getIsArbitraryVariable(value, isLabelFamilyName);
441
- const isArbitraryVariablePosition = (value) => getIsArbitraryVariable(value, isLabelPosition);
442
- const isArbitraryVariableSize = (value) => getIsArbitraryVariable(value, isLabelSize);
443
- const isArbitraryVariableImage = (value) => getIsArbitraryVariable(value, isLabelImage);
444
- const isArbitraryVariableShadow = (value) => getIsArbitraryVariable(value, isLabelShadow, true);
445
- const getIsArbitraryValue = (value, testLabel, testValue) => {
446
- const result = arbitraryValueRegex.exec(value);
447
- if (result) {
448
- if (result[1]) return testLabel(result[1]);
449
- return testValue(result[2]);
450
- }
451
- return false;
452
- };
453
- const getIsArbitraryVariable = (value, testLabel, shouldMatchNoLabel = false) => {
454
- const result = arbitraryVariableRegex.exec(value);
455
- if (result) {
456
- if (result[1]) return testLabel(result[1]);
457
- return shouldMatchNoLabel;
458
- }
459
- return false;
460
- };
461
- const isLabelPosition = (label) => label === "position" || label === "percentage";
462
- const isLabelImage = (label) => label === "image" || label === "url";
463
- const isLabelSize = (label) => label === "length" || label === "size" || label === "bg-size";
464
- const isLabelLength = (label) => label === "length";
465
- const isLabelNumber = (label) => label === "number";
466
- const isLabelFamilyName = (label) => label === "family-name";
467
- const isLabelShadow = (label) => label === "shadow";
468
- const getDefaultConfig = () => {
469
- /**
470
- * Theme getters for theme variable namespaces
471
- * @see https://tailwindcss.com/docs/theme#theme-variable-namespaces
472
- */
473
- const themeColor = fromTheme("color");
474
- const themeFont = fromTheme("font");
475
- const themeText = fromTheme("text");
476
- const themeFontWeight = fromTheme("font-weight");
477
- const themeTracking = fromTheme("tracking");
478
- const themeLeading = fromTheme("leading");
479
- const themeBreakpoint = fromTheme("breakpoint");
480
- const themeContainer = fromTheme("container");
481
- const themeSpacing = fromTheme("spacing");
482
- const themeRadius = fromTheme("radius");
483
- const themeShadow = fromTheme("shadow");
484
- const themeInsetShadow = fromTheme("inset-shadow");
485
- const themeTextShadow = fromTheme("text-shadow");
486
- const themeDropShadow = fromTheme("drop-shadow");
487
- const themeBlur = fromTheme("blur");
488
- const themePerspective = fromTheme("perspective");
489
- const themeAspect = fromTheme("aspect");
490
- const themeEase = fromTheme("ease");
491
- const themeAnimate = fromTheme("animate");
492
- /**
493
- * Helpers to avoid repeating the same scales
494
- *
495
- * We use functions that create a new array every time they're called instead of static arrays.
496
- * 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.
497
- */
498
- const scaleBreak = () => [
499
- "auto",
500
- "avoid",
501
- "all",
502
- "avoid-page",
503
- "page",
504
- "left",
505
- "right",
506
- "column"
507
- ];
508
- const scalePosition = () => [
509
- "center",
510
- "top",
511
- "bottom",
512
- "left",
513
- "right",
514
- "top-left",
515
- "left-top",
516
- "top-right",
517
- "right-top",
518
- "bottom-right",
519
- "right-bottom",
520
- "bottom-left",
521
- "left-bottom"
522
- ];
523
- const scalePositionWithArbitrary = () => [
524
- ...scalePosition(),
525
- isArbitraryVariable,
526
- isArbitraryValue
527
- ];
528
- const scaleOverflow = () => [
529
- "auto",
530
- "hidden",
531
- "clip",
532
- "visible",
533
- "scroll"
534
- ];
535
- const scaleOverscroll = () => [
536
- "auto",
537
- "contain",
538
- "none"
539
- ];
540
- const scaleUnambiguousSpacing = () => [
541
- isArbitraryVariable,
542
- isArbitraryValue,
543
- themeSpacing
544
- ];
545
- const scaleInset = () => [
546
- isFraction,
547
- "full",
548
- "auto",
549
- ...scaleUnambiguousSpacing()
550
- ];
551
- const scaleGridTemplateColsRows = () => [
552
- isInteger,
553
- "none",
554
- "subgrid",
555
- isArbitraryVariable,
556
- isArbitraryValue
557
- ];
558
- const scaleGridColRowStartAndEnd = () => [
559
- "auto",
560
- { span: [
561
- "full",
562
- isInteger,
563
- isArbitraryVariable,
564
- isArbitraryValue
565
- ] },
566
- isInteger,
567
- isArbitraryVariable,
568
- isArbitraryValue
569
- ];
570
- const scaleGridColRowStartOrEnd = () => [
571
- isInteger,
572
- "auto",
573
- isArbitraryVariable,
574
- isArbitraryValue
575
- ];
576
- const scaleGridAutoColsRows = () => [
577
- "auto",
578
- "min",
579
- "max",
580
- "fr",
581
- isArbitraryVariable,
582
- isArbitraryValue
583
- ];
584
- const scaleAlignPrimaryAxis = () => [
585
- "start",
586
- "end",
587
- "center",
588
- "between",
589
- "around",
590
- "evenly",
591
- "stretch",
592
- "baseline",
593
- "center-safe",
594
- "end-safe"
595
- ];
596
- const scaleAlignSecondaryAxis = () => [
597
- "start",
598
- "end",
599
- "center",
600
- "stretch",
601
- "center-safe",
602
- "end-safe"
603
- ];
604
- const scaleMargin = () => ["auto", ...scaleUnambiguousSpacing()];
605
- const scaleSizing = () => [
606
- isFraction,
607
- "auto",
608
- "full",
609
- "dvw",
610
- "dvh",
611
- "lvw",
612
- "lvh",
613
- "svw",
614
- "svh",
615
- "min",
616
- "max",
617
- "fit",
618
- ...scaleUnambiguousSpacing()
619
- ];
620
- const scaleColor = () => [
621
- themeColor,
622
- isArbitraryVariable,
623
- isArbitraryValue
624
- ];
625
- const scaleBgPosition = () => [
626
- ...scalePosition(),
627
- isArbitraryVariablePosition,
628
- isArbitraryPosition,
629
- { position: [isArbitraryVariable, isArbitraryValue] }
630
- ];
631
- const scaleBgRepeat = () => ["no-repeat", { repeat: [
632
- "",
633
- "x",
634
- "y",
635
- "space",
636
- "round"
637
- ] }];
638
- const scaleBgSize = () => [
639
- "auto",
640
- "cover",
641
- "contain",
642
- isArbitraryVariableSize,
643
- isArbitrarySize,
644
- { size: [isArbitraryVariable, isArbitraryValue] }
645
- ];
646
- const scaleGradientStopPosition = () => [
647
- isPercent,
648
- isArbitraryVariableLength,
649
- isArbitraryLength
650
- ];
651
- const scaleRadius = () => [
652
- "",
653
- "none",
654
- "full",
655
- themeRadius,
656
- isArbitraryVariable,
657
- isArbitraryValue
658
- ];
659
- const scaleBorderWidth = () => [
660
- "",
661
- isNumber,
662
- isArbitraryVariableLength,
663
- isArbitraryLength
664
- ];
665
- const scaleLineStyle = () => [
666
- "solid",
667
- "dashed",
668
- "dotted",
669
- "double"
670
- ];
671
- const scaleBlendMode = () => [
672
- "normal",
673
- "multiply",
674
- "screen",
675
- "overlay",
676
- "darken",
677
- "lighten",
678
- "color-dodge",
679
- "color-burn",
680
- "hard-light",
681
- "soft-light",
682
- "difference",
683
- "exclusion",
684
- "hue",
685
- "saturation",
686
- "color",
687
- "luminosity"
688
- ];
689
- const scaleMaskImagePosition = () => [
690
- isNumber,
691
- isPercent,
692
- isArbitraryVariablePosition,
693
- isArbitraryPosition
694
- ];
695
- const scaleBlur = () => [
696
- "",
697
- "none",
698
- themeBlur,
699
- isArbitraryVariable,
700
- isArbitraryValue
701
- ];
702
- const scaleRotate = () => [
703
- "none",
704
- isNumber,
705
- isArbitraryVariable,
706
- isArbitraryValue
707
- ];
708
- const scaleScale = () => [
709
- "none",
710
- isNumber,
711
- isArbitraryVariable,
712
- isArbitraryValue
713
- ];
714
- const scaleSkew = () => [
715
- isNumber,
716
- isArbitraryVariable,
717
- isArbitraryValue
718
- ];
719
- const scaleTranslate = () => [
720
- isFraction,
721
- "full",
722
- ...scaleUnambiguousSpacing()
723
- ];
724
- return {
725
- cacheSize: 500,
726
- theme: {
727
- animate: [
728
- "spin",
729
- "ping",
730
- "pulse",
731
- "bounce"
732
- ],
733
- aspect: ["video"],
734
- blur: [isTshirtSize],
735
- breakpoint: [isTshirtSize],
736
- color: [isAny],
737
- container: [isTshirtSize],
738
- "drop-shadow": [isTshirtSize],
739
- ease: [
740
- "in",
741
- "out",
742
- "in-out"
743
- ],
744
- font: [isAnyNonArbitrary],
745
- "font-weight": [
746
- "thin",
747
- "extralight",
748
- "light",
749
- "normal",
750
- "medium",
751
- "semibold",
752
- "bold",
753
- "extrabold",
754
- "black"
755
- ],
756
- "inset-shadow": [isTshirtSize],
757
- leading: [
758
- "none",
759
- "tight",
760
- "snug",
761
- "normal",
762
- "relaxed",
763
- "loose"
764
- ],
765
- perspective: [
766
- "dramatic",
767
- "near",
768
- "normal",
769
- "midrange",
770
- "distant",
771
- "none"
772
- ],
773
- radius: [isTshirtSize],
774
- shadow: [isTshirtSize],
775
- spacing: ["px", isNumber],
776
- text: [isTshirtSize],
777
- "text-shadow": [isTshirtSize],
778
- tracking: [
779
- "tighter",
780
- "tight",
781
- "normal",
782
- "wide",
783
- "wider",
784
- "widest"
785
- ]
786
- },
787
- classGroups: {
788
- aspect: [{ aspect: [
789
- "auto",
790
- "square",
791
- isFraction,
792
- isArbitraryValue,
793
- isArbitraryVariable,
794
- themeAspect
795
- ] }],
796
- container: ["container"],
797
- columns: [{ columns: [
798
- isNumber,
799
- isArbitraryValue,
800
- isArbitraryVariable,
801
- themeContainer
802
- ] }],
803
- "break-after": [{ "break-after": scaleBreak() }],
804
- "break-before": [{ "break-before": scaleBreak() }],
805
- "break-inside": [{ "break-inside": [
806
- "auto",
807
- "avoid",
808
- "avoid-page",
809
- "avoid-column"
810
- ] }],
811
- "box-decoration": [{ "box-decoration": ["slice", "clone"] }],
812
- box: [{ box: ["border", "content"] }],
813
- display: [
814
- "block",
815
- "inline-block",
816
- "inline",
817
- "flex",
818
- "inline-flex",
819
- "table",
820
- "inline-table",
821
- "table-caption",
822
- "table-cell",
823
- "table-column",
824
- "table-column-group",
825
- "table-footer-group",
826
- "table-header-group",
827
- "table-row-group",
828
- "table-row",
829
- "flow-root",
830
- "grid",
831
- "inline-grid",
832
- "contents",
833
- "list-item",
834
- "hidden"
835
- ],
836
- sr: ["sr-only", "not-sr-only"],
837
- float: [{ float: [
838
- "right",
839
- "left",
840
- "none",
841
- "start",
842
- "end"
843
- ] }],
844
- clear: [{ clear: [
845
- "left",
846
- "right",
847
- "both",
848
- "none",
849
- "start",
850
- "end"
851
- ] }],
852
- isolation: ["isolate", "isolation-auto"],
853
- "object-fit": [{ object: [
854
- "contain",
855
- "cover",
856
- "fill",
857
- "none",
858
- "scale-down"
859
- ] }],
860
- "object-position": [{ object: scalePositionWithArbitrary() }],
861
- overflow: [{ overflow: scaleOverflow() }],
862
- "overflow-x": [{ "overflow-x": scaleOverflow() }],
863
- "overflow-y": [{ "overflow-y": scaleOverflow() }],
864
- overscroll: [{ overscroll: scaleOverscroll() }],
865
- "overscroll-x": [{ "overscroll-x": scaleOverscroll() }],
866
- "overscroll-y": [{ "overscroll-y": scaleOverscroll() }],
867
- position: [
868
- "static",
869
- "fixed",
870
- "absolute",
871
- "relative",
872
- "sticky"
873
- ],
874
- inset: [{ inset: scaleInset() }],
875
- "inset-x": [{ "inset-x": scaleInset() }],
876
- "inset-y": [{ "inset-y": scaleInset() }],
877
- start: [{ start: scaleInset() }],
878
- end: [{ end: scaleInset() }],
879
- top: [{ top: scaleInset() }],
880
- right: [{ right: scaleInset() }],
881
- bottom: [{ bottom: scaleInset() }],
882
- left: [{ left: scaleInset() }],
883
- visibility: [
884
- "visible",
885
- "invisible",
886
- "collapse"
887
- ],
888
- z: [{ z: [
889
- isInteger,
890
- "auto",
891
- isArbitraryVariable,
892
- isArbitraryValue
893
- ] }],
894
- basis: [{ basis: [
895
- isFraction,
896
- "full",
897
- "auto",
898
- themeContainer,
899
- ...scaleUnambiguousSpacing()
900
- ] }],
901
- "flex-direction": [{ flex: [
902
- "row",
903
- "row-reverse",
904
- "col",
905
- "col-reverse"
906
- ] }],
907
- "flex-wrap": [{ flex: [
908
- "nowrap",
909
- "wrap",
910
- "wrap-reverse"
911
- ] }],
912
- flex: [{ flex: [
913
- isNumber,
914
- isFraction,
915
- "auto",
916
- "initial",
917
- "none",
918
- isArbitraryValue
919
- ] }],
920
- grow: [{ grow: [
921
- "",
922
- isNumber,
923
- isArbitraryVariable,
924
- isArbitraryValue
925
- ] }],
926
- shrink: [{ shrink: [
927
- "",
928
- isNumber,
929
- isArbitraryVariable,
930
- isArbitraryValue
931
- ] }],
932
- order: [{ order: [
933
- isInteger,
934
- "first",
935
- "last",
936
- "none",
937
- isArbitraryVariable,
938
- isArbitraryValue
939
- ] }],
940
- "grid-cols": [{ "grid-cols": scaleGridTemplateColsRows() }],
941
- "col-start-end": [{ col: scaleGridColRowStartAndEnd() }],
942
- "col-start": [{ "col-start": scaleGridColRowStartOrEnd() }],
943
- "col-end": [{ "col-end": scaleGridColRowStartOrEnd() }],
944
- "grid-rows": [{ "grid-rows": scaleGridTemplateColsRows() }],
945
- "row-start-end": [{ row: scaleGridColRowStartAndEnd() }],
946
- "row-start": [{ "row-start": scaleGridColRowStartOrEnd() }],
947
- "row-end": [{ "row-end": scaleGridColRowStartOrEnd() }],
948
- "grid-flow": [{ "grid-flow": [
949
- "row",
950
- "col",
951
- "dense",
952
- "row-dense",
953
- "col-dense"
954
- ] }],
955
- "auto-cols": [{ "auto-cols": scaleGridAutoColsRows() }],
956
- "auto-rows": [{ "auto-rows": scaleGridAutoColsRows() }],
957
- gap: [{ gap: scaleUnambiguousSpacing() }],
958
- "gap-x": [{ "gap-x": scaleUnambiguousSpacing() }],
959
- "gap-y": [{ "gap-y": scaleUnambiguousSpacing() }],
960
- "justify-content": [{ justify: [...scaleAlignPrimaryAxis(), "normal"] }],
961
- "justify-items": [{ "justify-items": [...scaleAlignSecondaryAxis(), "normal"] }],
962
- "justify-self": [{ "justify-self": ["auto", ...scaleAlignSecondaryAxis()] }],
963
- "align-content": [{ content: ["normal", ...scaleAlignPrimaryAxis()] }],
964
- "align-items": [{ items: [...scaleAlignSecondaryAxis(), { baseline: ["", "last"] }] }],
965
- "align-self": [{ self: [
966
- "auto",
967
- ...scaleAlignSecondaryAxis(),
968
- { baseline: ["", "last"] }
969
- ] }],
970
- "place-content": [{ "place-content": scaleAlignPrimaryAxis() }],
971
- "place-items": [{ "place-items": [...scaleAlignSecondaryAxis(), "baseline"] }],
972
- "place-self": [{ "place-self": ["auto", ...scaleAlignSecondaryAxis()] }],
973
- p: [{ p: scaleUnambiguousSpacing() }],
974
- px: [{ px: scaleUnambiguousSpacing() }],
975
- py: [{ py: scaleUnambiguousSpacing() }],
976
- ps: [{ ps: scaleUnambiguousSpacing() }],
977
- pe: [{ pe: scaleUnambiguousSpacing() }],
978
- pt: [{ pt: scaleUnambiguousSpacing() }],
979
- pr: [{ pr: scaleUnambiguousSpacing() }],
980
- pb: [{ pb: scaleUnambiguousSpacing() }],
981
- pl: [{ pl: scaleUnambiguousSpacing() }],
982
- m: [{ m: scaleMargin() }],
983
- mx: [{ mx: scaleMargin() }],
984
- my: [{ my: scaleMargin() }],
985
- ms: [{ ms: scaleMargin() }],
986
- me: [{ me: scaleMargin() }],
987
- mt: [{ mt: scaleMargin() }],
988
- mr: [{ mr: scaleMargin() }],
989
- mb: [{ mb: scaleMargin() }],
990
- ml: [{ ml: scaleMargin() }],
991
- "space-x": [{ "space-x": scaleUnambiguousSpacing() }],
992
- "space-x-reverse": ["space-x-reverse"],
993
- "space-y": [{ "space-y": scaleUnambiguousSpacing() }],
994
- "space-y-reverse": ["space-y-reverse"],
995
- size: [{ size: scaleSizing() }],
996
- w: [{ w: [
997
- themeContainer,
998
- "screen",
999
- ...scaleSizing()
1000
- ] }],
1001
- "min-w": [{ "min-w": [
1002
- themeContainer,
1003
- "screen",
1004
- "none",
1005
- ...scaleSizing()
1006
- ] }],
1007
- "max-w": [{ "max-w": [
1008
- themeContainer,
1009
- "screen",
1010
- "none",
1011
- "prose",
1012
- { screen: [themeBreakpoint] },
1013
- ...scaleSizing()
1014
- ] }],
1015
- h: [{ h: [
1016
- "screen",
1017
- "lh",
1018
- ...scaleSizing()
1019
- ] }],
1020
- "min-h": [{ "min-h": [
1021
- "screen",
1022
- "lh",
1023
- "none",
1024
- ...scaleSizing()
1025
- ] }],
1026
- "max-h": [{ "max-h": [
1027
- "screen",
1028
- "lh",
1029
- ...scaleSizing()
1030
- ] }],
1031
- "font-size": [{ text: [
1032
- "base",
1033
- themeText,
1034
- isArbitraryVariableLength,
1035
- isArbitraryLength
1036
- ] }],
1037
- "font-smoothing": ["antialiased", "subpixel-antialiased"],
1038
- "font-style": ["italic", "not-italic"],
1039
- "font-weight": [{ font: [
1040
- themeFontWeight,
1041
- isArbitraryVariable,
1042
- isArbitraryNumber
1043
- ] }],
1044
- "font-stretch": [{ "font-stretch": [
1045
- "ultra-condensed",
1046
- "extra-condensed",
1047
- "condensed",
1048
- "semi-condensed",
1049
- "normal",
1050
- "semi-expanded",
1051
- "expanded",
1052
- "extra-expanded",
1053
- "ultra-expanded",
1054
- isPercent,
1055
- isArbitraryValue
1056
- ] }],
1057
- "font-family": [{ font: [
1058
- isArbitraryVariableFamilyName,
1059
- isArbitraryValue,
1060
- themeFont
1061
- ] }],
1062
- "fvn-normal": ["normal-nums"],
1063
- "fvn-ordinal": ["ordinal"],
1064
- "fvn-slashed-zero": ["slashed-zero"],
1065
- "fvn-figure": ["lining-nums", "oldstyle-nums"],
1066
- "fvn-spacing": ["proportional-nums", "tabular-nums"],
1067
- "fvn-fraction": ["diagonal-fractions", "stacked-fractions"],
1068
- tracking: [{ tracking: [
1069
- themeTracking,
1070
- isArbitraryVariable,
1071
- isArbitraryValue
1072
- ] }],
1073
- "line-clamp": [{ "line-clamp": [
1074
- isNumber,
1075
- "none",
1076
- isArbitraryVariable,
1077
- isArbitraryNumber
1078
- ] }],
1079
- leading: [{ leading: [themeLeading, ...scaleUnambiguousSpacing()] }],
1080
- "list-image": [{ "list-image": [
1081
- "none",
1082
- isArbitraryVariable,
1083
- isArbitraryValue
1084
- ] }],
1085
- "list-style-position": [{ list: ["inside", "outside"] }],
1086
- "list-style-type": [{ list: [
1087
- "disc",
1088
- "decimal",
1089
- "none",
1090
- isArbitraryVariable,
1091
- isArbitraryValue
1092
- ] }],
1093
- "text-alignment": [{ text: [
1094
- "left",
1095
- "center",
1096
- "right",
1097
- "justify",
1098
- "start",
1099
- "end"
1100
- ] }],
1101
- "placeholder-color": [{ placeholder: scaleColor() }],
1102
- "text-color": [{ text: scaleColor() }],
1103
- "text-decoration": [
1104
- "underline",
1105
- "overline",
1106
- "line-through",
1107
- "no-underline"
1108
- ],
1109
- "text-decoration-style": [{ decoration: [...scaleLineStyle(), "wavy"] }],
1110
- "text-decoration-thickness": [{ decoration: [
1111
- isNumber,
1112
- "from-font",
1113
- "auto",
1114
- isArbitraryVariable,
1115
- isArbitraryLength
1116
- ] }],
1117
- "text-decoration-color": [{ decoration: scaleColor() }],
1118
- "underline-offset": [{ "underline-offset": [
1119
- isNumber,
1120
- "auto",
1121
- isArbitraryVariable,
1122
- isArbitraryValue
1123
- ] }],
1124
- "text-transform": [
1125
- "uppercase",
1126
- "lowercase",
1127
- "capitalize",
1128
- "normal-case"
1129
- ],
1130
- "text-overflow": [
1131
- "truncate",
1132
- "text-ellipsis",
1133
- "text-clip"
1134
- ],
1135
- "text-wrap": [{ text: [
1136
- "wrap",
1137
- "nowrap",
1138
- "balance",
1139
- "pretty"
1140
- ] }],
1141
- indent: [{ indent: scaleUnambiguousSpacing() }],
1142
- "vertical-align": [{ align: [
1143
- "baseline",
1144
- "top",
1145
- "middle",
1146
- "bottom",
1147
- "text-top",
1148
- "text-bottom",
1149
- "sub",
1150
- "super",
1151
- isArbitraryVariable,
1152
- isArbitraryValue
1153
- ] }],
1154
- whitespace: [{ whitespace: [
1155
- "normal",
1156
- "nowrap",
1157
- "pre",
1158
- "pre-line",
1159
- "pre-wrap",
1160
- "break-spaces"
1161
- ] }],
1162
- break: [{ break: [
1163
- "normal",
1164
- "words",
1165
- "all",
1166
- "keep"
1167
- ] }],
1168
- wrap: [{ wrap: [
1169
- "break-word",
1170
- "anywhere",
1171
- "normal"
1172
- ] }],
1173
- hyphens: [{ hyphens: [
1174
- "none",
1175
- "manual",
1176
- "auto"
1177
- ] }],
1178
- content: [{ content: [
1179
- "none",
1180
- isArbitraryVariable,
1181
- isArbitraryValue
1182
- ] }],
1183
- "bg-attachment": [{ bg: [
1184
- "fixed",
1185
- "local",
1186
- "scroll"
1187
- ] }],
1188
- "bg-clip": [{ "bg-clip": [
1189
- "border",
1190
- "padding",
1191
- "content",
1192
- "text"
1193
- ] }],
1194
- "bg-origin": [{ "bg-origin": [
1195
- "border",
1196
- "padding",
1197
- "content"
1198
- ] }],
1199
- "bg-position": [{ bg: scaleBgPosition() }],
1200
- "bg-repeat": [{ bg: scaleBgRepeat() }],
1201
- "bg-size": [{ bg: scaleBgSize() }],
1202
- "bg-image": [{ bg: [
1203
- "none",
1204
- {
1205
- linear: [
1206
- { to: [
1207
- "t",
1208
- "tr",
1209
- "r",
1210
- "br",
1211
- "b",
1212
- "bl",
1213
- "l",
1214
- "tl"
1215
- ] },
1216
- isInteger,
1217
- isArbitraryVariable,
1218
- isArbitraryValue
1219
- ],
1220
- radial: [
1221
- "",
1222
- isArbitraryVariable,
1223
- isArbitraryValue
1224
- ],
1225
- conic: [
1226
- isInteger,
1227
- isArbitraryVariable,
1228
- isArbitraryValue
1229
- ]
1230
- },
1231
- isArbitraryVariableImage,
1232
- isArbitraryImage
1233
- ] }],
1234
- "bg-color": [{ bg: scaleColor() }],
1235
- "gradient-from-pos": [{ from: scaleGradientStopPosition() }],
1236
- "gradient-via-pos": [{ via: scaleGradientStopPosition() }],
1237
- "gradient-to-pos": [{ to: scaleGradientStopPosition() }],
1238
- "gradient-from": [{ from: scaleColor() }],
1239
- "gradient-via": [{ via: scaleColor() }],
1240
- "gradient-to": [{ to: scaleColor() }],
1241
- rounded: [{ rounded: scaleRadius() }],
1242
- "rounded-s": [{ "rounded-s": scaleRadius() }],
1243
- "rounded-e": [{ "rounded-e": scaleRadius() }],
1244
- "rounded-t": [{ "rounded-t": scaleRadius() }],
1245
- "rounded-r": [{ "rounded-r": scaleRadius() }],
1246
- "rounded-b": [{ "rounded-b": scaleRadius() }],
1247
- "rounded-l": [{ "rounded-l": scaleRadius() }],
1248
- "rounded-ss": [{ "rounded-ss": scaleRadius() }],
1249
- "rounded-se": [{ "rounded-se": scaleRadius() }],
1250
- "rounded-ee": [{ "rounded-ee": scaleRadius() }],
1251
- "rounded-es": [{ "rounded-es": scaleRadius() }],
1252
- "rounded-tl": [{ "rounded-tl": scaleRadius() }],
1253
- "rounded-tr": [{ "rounded-tr": scaleRadius() }],
1254
- "rounded-br": [{ "rounded-br": scaleRadius() }],
1255
- "rounded-bl": [{ "rounded-bl": scaleRadius() }],
1256
- "border-w": [{ border: scaleBorderWidth() }],
1257
- "border-w-x": [{ "border-x": scaleBorderWidth() }],
1258
- "border-w-y": [{ "border-y": scaleBorderWidth() }],
1259
- "border-w-s": [{ "border-s": scaleBorderWidth() }],
1260
- "border-w-e": [{ "border-e": scaleBorderWidth() }],
1261
- "border-w-t": [{ "border-t": scaleBorderWidth() }],
1262
- "border-w-r": [{ "border-r": scaleBorderWidth() }],
1263
- "border-w-b": [{ "border-b": scaleBorderWidth() }],
1264
- "border-w-l": [{ "border-l": scaleBorderWidth() }],
1265
- "divide-x": [{ "divide-x": scaleBorderWidth() }],
1266
- "divide-x-reverse": ["divide-x-reverse"],
1267
- "divide-y": [{ "divide-y": scaleBorderWidth() }],
1268
- "divide-y-reverse": ["divide-y-reverse"],
1269
- "border-style": [{ border: [
1270
- ...scaleLineStyle(),
1271
- "hidden",
1272
- "none"
1273
- ] }],
1274
- "divide-style": [{ divide: [
1275
- ...scaleLineStyle(),
1276
- "hidden",
1277
- "none"
1278
- ] }],
1279
- "border-color": [{ border: scaleColor() }],
1280
- "border-color-x": [{ "border-x": scaleColor() }],
1281
- "border-color-y": [{ "border-y": scaleColor() }],
1282
- "border-color-s": [{ "border-s": scaleColor() }],
1283
- "border-color-e": [{ "border-e": scaleColor() }],
1284
- "border-color-t": [{ "border-t": scaleColor() }],
1285
- "border-color-r": [{ "border-r": scaleColor() }],
1286
- "border-color-b": [{ "border-b": scaleColor() }],
1287
- "border-color-l": [{ "border-l": scaleColor() }],
1288
- "divide-color": [{ divide: scaleColor() }],
1289
- "outline-style": [{ outline: [
1290
- ...scaleLineStyle(),
1291
- "none",
1292
- "hidden"
1293
- ] }],
1294
- "outline-offset": [{ "outline-offset": [
1295
- isNumber,
1296
- isArbitraryVariable,
1297
- isArbitraryValue
1298
- ] }],
1299
- "outline-w": [{ outline: [
1300
- "",
1301
- isNumber,
1302
- isArbitraryVariableLength,
1303
- isArbitraryLength
1304
- ] }],
1305
- "outline-color": [{ outline: scaleColor() }],
1306
- shadow: [{ shadow: [
1307
- "",
1308
- "none",
1309
- themeShadow,
1310
- isArbitraryVariableShadow,
1311
- isArbitraryShadow
1312
- ] }],
1313
- "shadow-color": [{ shadow: scaleColor() }],
1314
- "inset-shadow": [{ "inset-shadow": [
1315
- "none",
1316
- themeInsetShadow,
1317
- isArbitraryVariableShadow,
1318
- isArbitraryShadow
1319
- ] }],
1320
- "inset-shadow-color": [{ "inset-shadow": scaleColor() }],
1321
- "ring-w": [{ ring: scaleBorderWidth() }],
1322
- "ring-w-inset": ["ring-inset"],
1323
- "ring-color": [{ ring: scaleColor() }],
1324
- "ring-offset-w": [{ "ring-offset": [isNumber, isArbitraryLength] }],
1325
- "ring-offset-color": [{ "ring-offset": scaleColor() }],
1326
- "inset-ring-w": [{ "inset-ring": scaleBorderWidth() }],
1327
- "inset-ring-color": [{ "inset-ring": scaleColor() }],
1328
- "text-shadow": [{ "text-shadow": [
1329
- "none",
1330
- themeTextShadow,
1331
- isArbitraryVariableShadow,
1332
- isArbitraryShadow
1333
- ] }],
1334
- "text-shadow-color": [{ "text-shadow": scaleColor() }],
1335
- opacity: [{ opacity: [
1336
- isNumber,
1337
- isArbitraryVariable,
1338
- isArbitraryValue
1339
- ] }],
1340
- "mix-blend": [{ "mix-blend": [
1341
- ...scaleBlendMode(),
1342
- "plus-darker",
1343
- "plus-lighter"
1344
- ] }],
1345
- "bg-blend": [{ "bg-blend": scaleBlendMode() }],
1346
- "mask-clip": [{ "mask-clip": [
1347
- "border",
1348
- "padding",
1349
- "content",
1350
- "fill",
1351
- "stroke",
1352
- "view"
1353
- ] }, "mask-no-clip"],
1354
- "mask-composite": [{ mask: [
1355
- "add",
1356
- "subtract",
1357
- "intersect",
1358
- "exclude"
1359
- ] }],
1360
- "mask-image-linear-pos": [{ "mask-linear": [isNumber] }],
1361
- "mask-image-linear-from-pos": [{ "mask-linear-from": scaleMaskImagePosition() }],
1362
- "mask-image-linear-to-pos": [{ "mask-linear-to": scaleMaskImagePosition() }],
1363
- "mask-image-linear-from-color": [{ "mask-linear-from": scaleColor() }],
1364
- "mask-image-linear-to-color": [{ "mask-linear-to": scaleColor() }],
1365
- "mask-image-t-from-pos": [{ "mask-t-from": scaleMaskImagePosition() }],
1366
- "mask-image-t-to-pos": [{ "mask-t-to": scaleMaskImagePosition() }],
1367
- "mask-image-t-from-color": [{ "mask-t-from": scaleColor() }],
1368
- "mask-image-t-to-color": [{ "mask-t-to": scaleColor() }],
1369
- "mask-image-r-from-pos": [{ "mask-r-from": scaleMaskImagePosition() }],
1370
- "mask-image-r-to-pos": [{ "mask-r-to": scaleMaskImagePosition() }],
1371
- "mask-image-r-from-color": [{ "mask-r-from": scaleColor() }],
1372
- "mask-image-r-to-color": [{ "mask-r-to": scaleColor() }],
1373
- "mask-image-b-from-pos": [{ "mask-b-from": scaleMaskImagePosition() }],
1374
- "mask-image-b-to-pos": [{ "mask-b-to": scaleMaskImagePosition() }],
1375
- "mask-image-b-from-color": [{ "mask-b-from": scaleColor() }],
1376
- "mask-image-b-to-color": [{ "mask-b-to": scaleColor() }],
1377
- "mask-image-l-from-pos": [{ "mask-l-from": scaleMaskImagePosition() }],
1378
- "mask-image-l-to-pos": [{ "mask-l-to": scaleMaskImagePosition() }],
1379
- "mask-image-l-from-color": [{ "mask-l-from": scaleColor() }],
1380
- "mask-image-l-to-color": [{ "mask-l-to": scaleColor() }],
1381
- "mask-image-x-from-pos": [{ "mask-x-from": scaleMaskImagePosition() }],
1382
- "mask-image-x-to-pos": [{ "mask-x-to": scaleMaskImagePosition() }],
1383
- "mask-image-x-from-color": [{ "mask-x-from": scaleColor() }],
1384
- "mask-image-x-to-color": [{ "mask-x-to": scaleColor() }],
1385
- "mask-image-y-from-pos": [{ "mask-y-from": scaleMaskImagePosition() }],
1386
- "mask-image-y-to-pos": [{ "mask-y-to": scaleMaskImagePosition() }],
1387
- "mask-image-y-from-color": [{ "mask-y-from": scaleColor() }],
1388
- "mask-image-y-to-color": [{ "mask-y-to": scaleColor() }],
1389
- "mask-image-radial": [{ "mask-radial": [isArbitraryVariable, isArbitraryValue] }],
1390
- "mask-image-radial-from-pos": [{ "mask-radial-from": scaleMaskImagePosition() }],
1391
- "mask-image-radial-to-pos": [{ "mask-radial-to": scaleMaskImagePosition() }],
1392
- "mask-image-radial-from-color": [{ "mask-radial-from": scaleColor() }],
1393
- "mask-image-radial-to-color": [{ "mask-radial-to": scaleColor() }],
1394
- "mask-image-radial-shape": [{ "mask-radial": ["circle", "ellipse"] }],
1395
- "mask-image-radial-size": [{ "mask-radial": [{
1396
- closest: ["side", "corner"],
1397
- farthest: ["side", "corner"]
1398
- }] }],
1399
- "mask-image-radial-pos": [{ "mask-radial-at": scalePosition() }],
1400
- "mask-image-conic-pos": [{ "mask-conic": [isNumber] }],
1401
- "mask-image-conic-from-pos": [{ "mask-conic-from": scaleMaskImagePosition() }],
1402
- "mask-image-conic-to-pos": [{ "mask-conic-to": scaleMaskImagePosition() }],
1403
- "mask-image-conic-from-color": [{ "mask-conic-from": scaleColor() }],
1404
- "mask-image-conic-to-color": [{ "mask-conic-to": scaleColor() }],
1405
- "mask-mode": [{ mask: [
1406
- "alpha",
1407
- "luminance",
1408
- "match"
1409
- ] }],
1410
- "mask-origin": [{ "mask-origin": [
1411
- "border",
1412
- "padding",
1413
- "content",
1414
- "fill",
1415
- "stroke",
1416
- "view"
1417
- ] }],
1418
- "mask-position": [{ mask: scaleBgPosition() }],
1419
- "mask-repeat": [{ mask: scaleBgRepeat() }],
1420
- "mask-size": [{ mask: scaleBgSize() }],
1421
- "mask-type": [{ "mask-type": ["alpha", "luminance"] }],
1422
- "mask-image": [{ mask: [
1423
- "none",
1424
- isArbitraryVariable,
1425
- isArbitraryValue
1426
- ] }],
1427
- filter: [{ filter: [
1428
- "",
1429
- "none",
1430
- isArbitraryVariable,
1431
- isArbitraryValue
1432
- ] }],
1433
- blur: [{ blur: scaleBlur() }],
1434
- brightness: [{ brightness: [
1435
- isNumber,
1436
- isArbitraryVariable,
1437
- isArbitraryValue
1438
- ] }],
1439
- contrast: [{ contrast: [
1440
- isNumber,
1441
- isArbitraryVariable,
1442
- isArbitraryValue
1443
- ] }],
1444
- "drop-shadow": [{ "drop-shadow": [
1445
- "",
1446
- "none",
1447
- themeDropShadow,
1448
- isArbitraryVariableShadow,
1449
- isArbitraryShadow
1450
- ] }],
1451
- "drop-shadow-color": [{ "drop-shadow": scaleColor() }],
1452
- grayscale: [{ grayscale: [
1453
- "",
1454
- isNumber,
1455
- isArbitraryVariable,
1456
- isArbitraryValue
1457
- ] }],
1458
- "hue-rotate": [{ "hue-rotate": [
1459
- isNumber,
1460
- isArbitraryVariable,
1461
- isArbitraryValue
1462
- ] }],
1463
- invert: [{ invert: [
1464
- "",
1465
- isNumber,
1466
- isArbitraryVariable,
1467
- isArbitraryValue
1468
- ] }],
1469
- saturate: [{ saturate: [
1470
- isNumber,
1471
- isArbitraryVariable,
1472
- isArbitraryValue
1473
- ] }],
1474
- sepia: [{ sepia: [
1475
- "",
1476
- isNumber,
1477
- isArbitraryVariable,
1478
- isArbitraryValue
1479
- ] }],
1480
- "backdrop-filter": [{ "backdrop-filter": [
1481
- "",
1482
- "none",
1483
- isArbitraryVariable,
1484
- isArbitraryValue
1485
- ] }],
1486
- "backdrop-blur": [{ "backdrop-blur": scaleBlur() }],
1487
- "backdrop-brightness": [{ "backdrop-brightness": [
1488
- isNumber,
1489
- isArbitraryVariable,
1490
- isArbitraryValue
1491
- ] }],
1492
- "backdrop-contrast": [{ "backdrop-contrast": [
1493
- isNumber,
1494
- isArbitraryVariable,
1495
- isArbitraryValue
1496
- ] }],
1497
- "backdrop-grayscale": [{ "backdrop-grayscale": [
1498
- "",
1499
- isNumber,
1500
- isArbitraryVariable,
1501
- isArbitraryValue
1502
- ] }],
1503
- "backdrop-hue-rotate": [{ "backdrop-hue-rotate": [
1504
- isNumber,
1505
- isArbitraryVariable,
1506
- isArbitraryValue
1507
- ] }],
1508
- "backdrop-invert": [{ "backdrop-invert": [
1509
- "",
1510
- isNumber,
1511
- isArbitraryVariable,
1512
- isArbitraryValue
1513
- ] }],
1514
- "backdrop-opacity": [{ "backdrop-opacity": [
1515
- isNumber,
1516
- isArbitraryVariable,
1517
- isArbitraryValue
1518
- ] }],
1519
- "backdrop-saturate": [{ "backdrop-saturate": [
1520
- isNumber,
1521
- isArbitraryVariable,
1522
- isArbitraryValue
1523
- ] }],
1524
- "backdrop-sepia": [{ "backdrop-sepia": [
1525
- "",
1526
- isNumber,
1527
- isArbitraryVariable,
1528
- isArbitraryValue
1529
- ] }],
1530
- "border-collapse": [{ border: ["collapse", "separate"] }],
1531
- "border-spacing": [{ "border-spacing": scaleUnambiguousSpacing() }],
1532
- "border-spacing-x": [{ "border-spacing-x": scaleUnambiguousSpacing() }],
1533
- "border-spacing-y": [{ "border-spacing-y": scaleUnambiguousSpacing() }],
1534
- "table-layout": [{ table: ["auto", "fixed"] }],
1535
- caption: [{ caption: ["top", "bottom"] }],
1536
- transition: [{ transition: [
1537
- "",
1538
- "all",
1539
- "colors",
1540
- "opacity",
1541
- "shadow",
1542
- "transform",
1543
- "none",
1544
- isArbitraryVariable,
1545
- isArbitraryValue
1546
- ] }],
1547
- "transition-behavior": [{ transition: ["normal", "discrete"] }],
1548
- duration: [{ duration: [
1549
- isNumber,
1550
- "initial",
1551
- isArbitraryVariable,
1552
- isArbitraryValue
1553
- ] }],
1554
- ease: [{ ease: [
1555
- "linear",
1556
- "initial",
1557
- themeEase,
1558
- isArbitraryVariable,
1559
- isArbitraryValue
1560
- ] }],
1561
- delay: [{ delay: [
1562
- isNumber,
1563
- isArbitraryVariable,
1564
- isArbitraryValue
1565
- ] }],
1566
- animate: [{ animate: [
1567
- "none",
1568
- themeAnimate,
1569
- isArbitraryVariable,
1570
- isArbitraryValue
1571
- ] }],
1572
- backface: [{ backface: ["hidden", "visible"] }],
1573
- perspective: [{ perspective: [
1574
- themePerspective,
1575
- isArbitraryVariable,
1576
- isArbitraryValue
1577
- ] }],
1578
- "perspective-origin": [{ "perspective-origin": scalePositionWithArbitrary() }],
1579
- rotate: [{ rotate: scaleRotate() }],
1580
- "rotate-x": [{ "rotate-x": scaleRotate() }],
1581
- "rotate-y": [{ "rotate-y": scaleRotate() }],
1582
- "rotate-z": [{ "rotate-z": scaleRotate() }],
1583
- scale: [{ scale: scaleScale() }],
1584
- "scale-x": [{ "scale-x": scaleScale() }],
1585
- "scale-y": [{ "scale-y": scaleScale() }],
1586
- "scale-z": [{ "scale-z": scaleScale() }],
1587
- "scale-3d": ["scale-3d"],
1588
- skew: [{ skew: scaleSkew() }],
1589
- "skew-x": [{ "skew-x": scaleSkew() }],
1590
- "skew-y": [{ "skew-y": scaleSkew() }],
1591
- transform: [{ transform: [
1592
- isArbitraryVariable,
1593
- isArbitraryValue,
1594
- "",
1595
- "none",
1596
- "gpu",
1597
- "cpu"
1598
- ] }],
1599
- "transform-origin": [{ origin: scalePositionWithArbitrary() }],
1600
- "transform-style": [{ transform: ["3d", "flat"] }],
1601
- translate: [{ translate: scaleTranslate() }],
1602
- "translate-x": [{ "translate-x": scaleTranslate() }],
1603
- "translate-y": [{ "translate-y": scaleTranslate() }],
1604
- "translate-z": [{ "translate-z": scaleTranslate() }],
1605
- "translate-none": ["translate-none"],
1606
- accent: [{ accent: scaleColor() }],
1607
- appearance: [{ appearance: ["none", "auto"] }],
1608
- "caret-color": [{ caret: scaleColor() }],
1609
- "color-scheme": [{ scheme: [
1610
- "normal",
1611
- "dark",
1612
- "light",
1613
- "light-dark",
1614
- "only-dark",
1615
- "only-light"
1616
- ] }],
1617
- cursor: [{ cursor: [
1618
- "auto",
1619
- "default",
1620
- "pointer",
1621
- "wait",
1622
- "text",
1623
- "move",
1624
- "help",
1625
- "not-allowed",
1626
- "none",
1627
- "context-menu",
1628
- "progress",
1629
- "cell",
1630
- "crosshair",
1631
- "vertical-text",
1632
- "alias",
1633
- "copy",
1634
- "no-drop",
1635
- "grab",
1636
- "grabbing",
1637
- "all-scroll",
1638
- "col-resize",
1639
- "row-resize",
1640
- "n-resize",
1641
- "e-resize",
1642
- "s-resize",
1643
- "w-resize",
1644
- "ne-resize",
1645
- "nw-resize",
1646
- "se-resize",
1647
- "sw-resize",
1648
- "ew-resize",
1649
- "ns-resize",
1650
- "nesw-resize",
1651
- "nwse-resize",
1652
- "zoom-in",
1653
- "zoom-out",
1654
- isArbitraryVariable,
1655
- isArbitraryValue
1656
- ] }],
1657
- "field-sizing": [{ "field-sizing": ["fixed", "content"] }],
1658
- "pointer-events": [{ "pointer-events": ["auto", "none"] }],
1659
- resize: [{ resize: [
1660
- "none",
1661
- "",
1662
- "y",
1663
- "x"
1664
- ] }],
1665
- "scroll-behavior": [{ scroll: ["auto", "smooth"] }],
1666
- "scroll-m": [{ "scroll-m": scaleUnambiguousSpacing() }],
1667
- "scroll-mx": [{ "scroll-mx": scaleUnambiguousSpacing() }],
1668
- "scroll-my": [{ "scroll-my": scaleUnambiguousSpacing() }],
1669
- "scroll-ms": [{ "scroll-ms": scaleUnambiguousSpacing() }],
1670
- "scroll-me": [{ "scroll-me": scaleUnambiguousSpacing() }],
1671
- "scroll-mt": [{ "scroll-mt": scaleUnambiguousSpacing() }],
1672
- "scroll-mr": [{ "scroll-mr": scaleUnambiguousSpacing() }],
1673
- "scroll-mb": [{ "scroll-mb": scaleUnambiguousSpacing() }],
1674
- "scroll-ml": [{ "scroll-ml": scaleUnambiguousSpacing() }],
1675
- "scroll-p": [{ "scroll-p": scaleUnambiguousSpacing() }],
1676
- "scroll-px": [{ "scroll-px": scaleUnambiguousSpacing() }],
1677
- "scroll-py": [{ "scroll-py": scaleUnambiguousSpacing() }],
1678
- "scroll-ps": [{ "scroll-ps": scaleUnambiguousSpacing() }],
1679
- "scroll-pe": [{ "scroll-pe": scaleUnambiguousSpacing() }],
1680
- "scroll-pt": [{ "scroll-pt": scaleUnambiguousSpacing() }],
1681
- "scroll-pr": [{ "scroll-pr": scaleUnambiguousSpacing() }],
1682
- "scroll-pb": [{ "scroll-pb": scaleUnambiguousSpacing() }],
1683
- "scroll-pl": [{ "scroll-pl": scaleUnambiguousSpacing() }],
1684
- "snap-align": [{ snap: [
1685
- "start",
1686
- "end",
1687
- "center",
1688
- "align-none"
1689
- ] }],
1690
- "snap-stop": [{ snap: ["normal", "always"] }],
1691
- "snap-type": [{ snap: [
1692
- "none",
1693
- "x",
1694
- "y",
1695
- "both"
1696
- ] }],
1697
- "snap-strictness": [{ snap: ["mandatory", "proximity"] }],
1698
- touch: [{ touch: [
1699
- "auto",
1700
- "none",
1701
- "manipulation"
1702
- ] }],
1703
- "touch-x": [{ "touch-pan": [
1704
- "x",
1705
- "left",
1706
- "right"
1707
- ] }],
1708
- "touch-y": [{ "touch-pan": [
1709
- "y",
1710
- "up",
1711
- "down"
1712
- ] }],
1713
- "touch-pz": ["touch-pinch-zoom"],
1714
- select: [{ select: [
1715
- "none",
1716
- "text",
1717
- "all",
1718
- "auto"
1719
- ] }],
1720
- "will-change": [{ "will-change": [
1721
- "auto",
1722
- "scroll",
1723
- "contents",
1724
- "transform",
1725
- isArbitraryVariable,
1726
- isArbitraryValue
1727
- ] }],
1728
- fill: [{ fill: ["none", ...scaleColor()] }],
1729
- "stroke-w": [{ stroke: [
1730
- isNumber,
1731
- isArbitraryVariableLength,
1732
- isArbitraryLength,
1733
- isArbitraryNumber
1734
- ] }],
1735
- stroke: [{ stroke: ["none", ...scaleColor()] }],
1736
- "forced-color-adjust": [{ "forced-color-adjust": ["auto", "none"] }]
1737
- },
1738
- conflictingClassGroups: {
1739
- overflow: ["overflow-x", "overflow-y"],
1740
- overscroll: ["overscroll-x", "overscroll-y"],
1741
- inset: [
1742
- "inset-x",
1743
- "inset-y",
1744
- "start",
1745
- "end",
1746
- "top",
1747
- "right",
1748
- "bottom",
1749
- "left"
1750
- ],
1751
- "inset-x": ["right", "left"],
1752
- "inset-y": ["top", "bottom"],
1753
- flex: [
1754
- "basis",
1755
- "grow",
1756
- "shrink"
1757
- ],
1758
- gap: ["gap-x", "gap-y"],
1759
- p: [
1760
- "px",
1761
- "py",
1762
- "ps",
1763
- "pe",
1764
- "pt",
1765
- "pr",
1766
- "pb",
1767
- "pl"
1768
- ],
1769
- px: ["pr", "pl"],
1770
- py: ["pt", "pb"],
1771
- m: [
1772
- "mx",
1773
- "my",
1774
- "ms",
1775
- "me",
1776
- "mt",
1777
- "mr",
1778
- "mb",
1779
- "ml"
1780
- ],
1781
- mx: ["mr", "ml"],
1782
- my: ["mt", "mb"],
1783
- size: ["w", "h"],
1784
- "font-size": ["leading"],
1785
- "fvn-normal": [
1786
- "fvn-ordinal",
1787
- "fvn-slashed-zero",
1788
- "fvn-figure",
1789
- "fvn-spacing",
1790
- "fvn-fraction"
1791
- ],
1792
- "fvn-ordinal": ["fvn-normal"],
1793
- "fvn-slashed-zero": ["fvn-normal"],
1794
- "fvn-figure": ["fvn-normal"],
1795
- "fvn-spacing": ["fvn-normal"],
1796
- "fvn-fraction": ["fvn-normal"],
1797
- "line-clamp": ["display", "overflow"],
1798
- rounded: [
1799
- "rounded-s",
1800
- "rounded-e",
1801
- "rounded-t",
1802
- "rounded-r",
1803
- "rounded-b",
1804
- "rounded-l",
1805
- "rounded-ss",
1806
- "rounded-se",
1807
- "rounded-ee",
1808
- "rounded-es",
1809
- "rounded-tl",
1810
- "rounded-tr",
1811
- "rounded-br",
1812
- "rounded-bl"
1813
- ],
1814
- "rounded-s": ["rounded-ss", "rounded-es"],
1815
- "rounded-e": ["rounded-se", "rounded-ee"],
1816
- "rounded-t": ["rounded-tl", "rounded-tr"],
1817
- "rounded-r": ["rounded-tr", "rounded-br"],
1818
- "rounded-b": ["rounded-br", "rounded-bl"],
1819
- "rounded-l": ["rounded-tl", "rounded-bl"],
1820
- "border-spacing": ["border-spacing-x", "border-spacing-y"],
1821
- "border-w": [
1822
- "border-w-x",
1823
- "border-w-y",
1824
- "border-w-s",
1825
- "border-w-e",
1826
- "border-w-t",
1827
- "border-w-r",
1828
- "border-w-b",
1829
- "border-w-l"
1830
- ],
1831
- "border-w-x": ["border-w-r", "border-w-l"],
1832
- "border-w-y": ["border-w-t", "border-w-b"],
1833
- "border-color": [
1834
- "border-color-x",
1835
- "border-color-y",
1836
- "border-color-s",
1837
- "border-color-e",
1838
- "border-color-t",
1839
- "border-color-r",
1840
- "border-color-b",
1841
- "border-color-l"
1842
- ],
1843
- "border-color-x": ["border-color-r", "border-color-l"],
1844
- "border-color-y": ["border-color-t", "border-color-b"],
1845
- translate: [
1846
- "translate-x",
1847
- "translate-y",
1848
- "translate-none"
1849
- ],
1850
- "translate-none": [
1851
- "translate",
1852
- "translate-x",
1853
- "translate-y",
1854
- "translate-z"
1855
- ],
1856
- "scroll-m": [
1857
- "scroll-mx",
1858
- "scroll-my",
1859
- "scroll-ms",
1860
- "scroll-me",
1861
- "scroll-mt",
1862
- "scroll-mr",
1863
- "scroll-mb",
1864
- "scroll-ml"
1865
- ],
1866
- "scroll-mx": ["scroll-mr", "scroll-ml"],
1867
- "scroll-my": ["scroll-mt", "scroll-mb"],
1868
- "scroll-p": [
1869
- "scroll-px",
1870
- "scroll-py",
1871
- "scroll-ps",
1872
- "scroll-pe",
1873
- "scroll-pt",
1874
- "scroll-pr",
1875
- "scroll-pb",
1876
- "scroll-pl"
1877
- ],
1878
- "scroll-px": ["scroll-pr", "scroll-pl"],
1879
- "scroll-py": ["scroll-pt", "scroll-pb"],
1880
- touch: [
1881
- "touch-x",
1882
- "touch-y",
1883
- "touch-pz"
1884
- ],
1885
- "touch-x": ["touch"],
1886
- "touch-y": ["touch"],
1887
- "touch-pz": ["touch"]
1888
- },
1889
- conflictingClassGroupModifiers: { "font-size": ["leading"] },
1890
- orderSensitiveModifiers: [
1891
- "*",
1892
- "**",
1893
- "after",
1894
- "backdrop",
1895
- "before",
1896
- "details-content",
1897
- "file",
1898
- "first-letter",
1899
- "first-line",
1900
- "marker",
1901
- "placeholder",
1902
- "selection"
1903
- ]
1904
- };
1905
- };
1906
- const twMerge = /* @__PURE__ */ createTailwindMerge(getDefaultConfig);
1907
-
1908
- //#endregion
1909
- //#region src/utils.ts
1910
- function cn(...inputs) {
1911
- return twMerge(clsx(inputs));
1912
- }
1913
-
1914
- //#endregion
1915
- export { cn as t };