"use strict";
Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.corePlugins = exports.variantPlugins = void 0;
var _fs = _interopRequireDefault(require("fs"));
var path = _interopRequireWildcard(require("path"));
var _postcss = _interopRequireDefault(require("postcss"));
var _createUtilityPlugin = _interopRequireDefault(require("./util/createUtilityPlugin"));
var _buildMediaQuery = _interopRequireDefault(require("./util/buildMediaQuery"));
var _parseAnimationValue = _interopRequireDefault(require("./util/parseAnimationValue"));
var _flattenColorPalette = _interopRequireDefault(require("./util/flattenColorPalette"));
var _withAlphaVariable = _interopRequireWildcard(require("./util/withAlphaVariable"));
var _toColorValue = _interopRequireDefault(require("./util/toColorValue"));
var _isPlainObject = _interopRequireDefault(require("./util/isPlainObject"));
var _transformThemeValue = _interopRequireDefault(require("./util/transformThemeValue"));
var _packageJson = require("../package.json");
var _log = _interopRequireDefault(require("./util/log"));
var _normalizeScreens = require("./util/normalizeScreens");
var _parseBoxShadowValue = require("./util/parseBoxShadowValue");
function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
        default: obj
    };
}
function _interopRequireWildcard(obj) {
    if (obj && obj.__esModule) {
        return obj;
    } else {
        var newObj = {};
        if (obj != null) {
            for(var key in obj){
                if (Object.prototype.hasOwnProperty.call(obj, key)) {
                    var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {};
                    if (desc.get || desc.set) {
                        Object.defineProperty(newObj, key, desc);
                    } else {
                        newObj[key] = obj[key];
                    }
                }
            }
        }
        newObj.default = obj;
        return newObj;
    }
}
let variantPlugins = {
    pseudoElementVariants: ({ addVariant  })=>{
        addVariant('first-letter', '&::first-letter');
        addVariant('first-line', '&::first-line');
        addVariant('marker', [
            '& *::marker',
            '&::marker'
        ]);
        addVariant('selection', [
            '& *::selection',
            '&::selection'
        ]);
        addVariant('file', '&::file-selector-button');
        addVariant('placeholder', '&::placeholder');
        addVariant('before', ({ container  })=>{
            container.walkRules((rule)=>{
                let foundContent = false;
                rule.walkDecls('content', ()=>{
                    foundContent = true;
                });
                if (!foundContent) {
                    rule.prepend(_postcss.default.decl({
                        prop: 'content',
                        value: 'var(--tw-content)'
                    }));
                }
            });
            return '&::before';
        });
        addVariant('after', ({ container  })=>{
            container.walkRules((rule)=>{
                let foundContent = false;
                rule.walkDecls('content', ()=>{
                    foundContent = true;
                });
                if (!foundContent) {
                    rule.prepend(_postcss.default.decl({
                        prop: 'content',
                        value: 'var(--tw-content)'
                    }));
                }
            });
            return '&::after';
        });
    },
    pseudoClassVariants: ({ addVariant  })=>{
        let pseudoVariants = [
            // Positional
            [
                'first',
                ':first-child'
            ],
            [
                'last',
                ':last-child'
            ],
            [
                'only',
                ':only-child'
            ],
            [
                'odd',
                ':nth-child(odd)'
            ],
            [
                'even',
                ':nth-child(even)'
            ],
            'first-of-type',
            'last-of-type',
            'only-of-type',
            // State
            [
                'visited',
                ({ container  })=>{
                    let toRemove = [
                        '--tw-text-opacity',
                        '--tw-border-opacity',
                        '--tw-bg-opacity'
                    ];
                    container.walkDecls((decl)=>{
                        if (toRemove.includes(decl.prop)) {
                            decl.remove();
                            return;
                        }
                        for (const varName of toRemove){
                            if (decl.value.includes(`/ var(${varName})`)) {
                                decl.value = decl.value.replace(`/ var(${varName})`, '');
                            }
                        }
                    });
                    return ':visited';
                }, 
            ],
            'target',
            [
                'open',
                '[open]'
            ],
            // Forms
            'default',
            'checked',
            'indeterminate',
            'placeholder-shown',
            'autofill',
            'required',
            'valid',
            'invalid',
            'in-range',
            'out-of-range',
            'read-only',
            // Content
            'empty',
            // Interactive
            'focus-within',
            'hover',
            'focus',
            'focus-visible',
            'active',
            'disabled', 
        ].map((variant)=>Array.isArray(variant) ? variant : [
                variant,
                `:${variant}`
            ]
        );
        for (let [variantName, state] of pseudoVariants){
            addVariant(variantName, (ctx)=>{
                let result = typeof state === 'function' ? state(ctx) : state;
                return `&${result}`;
            });
        }
        for (let [variantName1, state1] of pseudoVariants){
            addVariant(`group-${variantName1}`, (ctx)=>{
                let result = typeof state1 === 'function' ? state1(ctx) : state1;
                return `:merge(.group)${result} &`;
            });
        }
        for (let [variantName2, state2] of pseudoVariants){
            addVariant(`peer-${variantName2}`, (ctx)=>{
                let result = typeof state2 === 'function' ? state2(ctx) : state2;
                return `:merge(.peer)${result} ~ &`;
            });
        }
    },
    directionVariants: ({ addVariant  })=>{
        addVariant('ltr', ()=>{
            _log.default.warn('rtl-experimental', [
                'The RTL features in Tailwind CSS are currently in preview.',
                'Preview features are not covered by semver, and may be improved in breaking ways at any time.', 
            ]);
            return '[dir="ltr"] &';
        });
        addVariant('rtl', ()=>{
            _log.default.warn('rtl-experimental', [
                'The RTL features in Tailwind CSS are currently in preview.',
                'Preview features are not covered by semver, and may be improved in breaking ways at any time.', 
            ]);
            return '[dir="rtl"] &';
        });
    },
    reducedMotionVariants: ({ addVariant  })=>{
        addVariant('motion-safe', '@media (prefers-reduced-motion: no-preference)');
        addVariant('motion-reduce', '@media (prefers-reduced-motion: reduce)');
    },
    darkVariants: ({ config , addVariant  })=>{
        let mode = config('darkMode', 'media');
        if (mode === false) {
            mode = 'media';
            _log.default.warn('darkmode-false', [
                'The `darkMode` option in your Tailwind CSS configuration is set to `false`, which now behaves the same as `media`.',
                'Change `darkMode` to `media` or remove it entirely.',
                'https://tailwindcss.com/docs/upgrade-guide#remove-dark-mode-configuration', 
            ]);
        }
        if (mode === 'class') {
            addVariant('dark', '.dark &');
        } else if (mode === 'media') {
            addVariant('dark', '@media (prefers-color-scheme: dark)');
        }
    },
    printVariant: ({ addVariant  })=>{
        addVariant('print', '@media print');
    },
    screenVariants: ({ theme , addVariant  })=>{
        for (let screen of (0, _normalizeScreens).normalizeScreens(theme('screens'))){
            let query = (0, _buildMediaQuery).default(screen);
            addVariant(screen.name, `@media ${query}`);
        }
    },
    orientationVariants: ({ addVariant  })=>{
        addVariant('portrait', '@media (orientation: portrait)');
        addVariant('landscape', '@media (orientation: landscape)');
    }
};
exports.variantPlugins = variantPlugins;
let cssTransformValue = [
    'translate(var(--tw-translate-x), var(--tw-translate-y))',
    'rotate(var(--tw-rotate))',
    'skewX(var(--tw-skew-x))',
    'skewY(var(--tw-skew-y))',
    'scaleX(var(--tw-scale-x))',
    'scaleY(var(--tw-scale-y))', 
].join(' ');
let cssFilterValue = [
    'var(--tw-blur)',
    'var(--tw-brightness)',
    'var(--tw-contrast)',
    'var(--tw-grayscale)',
    'var(--tw-hue-rotate)',
    'var(--tw-invert)',
    'var(--tw-saturate)',
    'var(--tw-sepia)',
    'var(--tw-drop-shadow)', 
].join(' ');
let cssBackdropFilterValue = [
    'var(--tw-backdrop-blur)',
    'var(--tw-backdrop-brightness)',
    'var(--tw-backdrop-contrast)',
    'var(--tw-backdrop-grayscale)',
    'var(--tw-backdrop-hue-rotate)',
    'var(--tw-backdrop-invert)',
    'var(--tw-backdrop-opacity)',
    'var(--tw-backdrop-saturate)',
    'var(--tw-backdrop-sepia)', 
].join(' ');
let corePlugins = {
    preflight: ({ addBase  })=>{
        let preflightStyles = _postcss.default.parse(_fs.default.readFileSync(path.join(__dirname, './css/preflight.css'), 'utf8'));
        addBase([
            _postcss.default.comment({
                text: `! tailwindcss v${_packageJson.version} | MIT License | https://tailwindcss.com`
            }),
            ...preflightStyles.nodes, 
        ]);
    },
    container: (()=>{
        function extractMinWidths(breakpoints = []) {
            return breakpoints.flatMap((breakpoint1)=>breakpoint1.values.map((breakpoint)=>breakpoint.min
                )
            ).filter((v)=>v !== undefined
            );
        }
        function mapMinWidthsToPadding(minWidths, screens, paddings) {
            if (typeof paddings === 'undefined') {
                return [];
            }
            if (!(typeof paddings === 'object' && paddings !== null)) {
                return [
                    {
                        screen: 'DEFAULT',
                        minWidth: 0,
                        padding: paddings
                    }, 
                ];
            }
            let mapping = [];
            if (paddings.DEFAULT) {
                mapping.push({
                    screen: 'DEFAULT',
                    minWidth: 0,
                    padding: paddings.DEFAULT
                });
            }
            for (let minWidth of minWidths){
                for (let screen of screens){
                    for (let { min  } of screen.values){
                        if (min === minWidth) {
                            mapping.push({
                                minWidth,
                                padding: paddings[screen.name]
                            });
                        }
                    }
                }
            }
            return mapping;
        }
        return function({ addComponents , theme  }) {
            let screens = (0, _normalizeScreens).normalizeScreens(theme('container.screens', theme('screens')));
            let minWidths = extractMinWidths(screens);
            let paddings = mapMinWidthsToPadding(minWidths, screens, theme('container.padding'));
            let generatePaddingFor = (minWidth)=>{
                let paddingConfig = paddings.find((padding)=>padding.minWidth === minWidth
                );
                if (!paddingConfig) {
                    return {};
                }
                return {
                    paddingRight: paddingConfig.padding,
                    paddingLeft: paddingConfig.padding
                };
            };
            let atRules = Array.from(new Set(minWidths.slice().sort((a, z)=>parseInt(a) - parseInt(z)
            ))).map((minWidth)=>({
                    [`@media (min-width: ${minWidth})`]: {
                        '.container': {
                            'max-width': minWidth,
                            ...generatePaddingFor(minWidth)
                        }
                    }
                })
            );
            addComponents([
                {
                    '.container': Object.assign({
                        width: '100%'
                    }, theme('container.center', false) ? {
                        marginRight: 'auto',
                        marginLeft: 'auto'
                    } : {}, generatePaddingFor(0))
                },
                ...atRules, 
            ]);
        };
    })(),
    accessibility: ({ addUtilities  })=>{
        addUtilities({
            '.sr-only': {
                position: 'absolute',
                width: '1px',
                height: '1px',
                padding: '0',
                margin: '-1px',
                overflow: 'hidden',
                clip: 'rect(0, 0, 0, 0)',
                whiteSpace: 'nowrap',
                borderWidth: '0'
            },
            '.not-sr-only': {
                position: 'static',
                width: 'auto',
                height: 'auto',
                padding: '0',
                margin: '0',
                overflow: 'visible',
                clip: 'auto',
                whiteSpace: 'normal'
            }
        });
    },
    pointerEvents: ({ addUtilities  })=>{
        addUtilities({
            '.pointer-events-none': {
                'pointer-events': 'none'
            },
            '.pointer-events-auto': {
                'pointer-events': 'auto'
            }
        });
    },
    visibility: ({ addUtilities  })=>{
        addUtilities({
            '.visible': {
                visibility: 'visible'
            },
            '.invisible': {
                visibility: 'hidden'
            }
        });
    },
    position: ({ addUtilities  })=>{
        addUtilities({
            '.static': {
                position: 'static'
            },
            '.fixed': {
                position: 'fixed'
            },
            '.absolute': {
                position: 'absolute'
            },
            '.relative': {
                position: 'relative'
            },
            '.sticky': {
                position: 'sticky'
            }
        });
    },
    inset: (0, _createUtilityPlugin).default('inset', [
        [
            'inset',
            [
                'top',
                'right',
                'bottom',
                'left'
            ]
        ],
        [
            [
                'inset-x',
                [
                    'left',
                    'right'
                ]
            ],
            [
                'inset-y',
                [
                    'top',
                    'bottom'
                ]
            ], 
        ],
        [
            [
                'top',
                [
                    'top'
                ]
            ],
            [
                'right',
                [
                    'right'
                ]
            ],
            [
                'bottom',
                [
                    'bottom'
                ]
            ],
            [
                'left',
                [
                    'left'
                ]
            ], 
        ], 
    ], {
        supportsNegativeValues: true
    }),
    isolation: ({ addUtilities  })=>{
        addUtilities({
            '.isolate': {
                isolation: 'isolate'
            },
            '.isolation-auto': {
                isolation: 'auto'
            }
        });
    },
    zIndex: (0, _createUtilityPlugin).default('zIndex', [
        [
            'z',
            [
                'zIndex'
            ]
        ]
    ], {
        supportsNegativeValues: true
    }),
    order: (0, _createUtilityPlugin).default('order', undefined, {
        supportsNegativeValues: true
    }),
    gridColumn: (0, _createUtilityPlugin).default('gridColumn', [
        [
            'col',
            [
                'gridColumn'
            ]
        ]
    ]),
    gridColumnStart: (0, _createUtilityPlugin).default('gridColumnStart', [
        [
            'col-start',
            [
                'gridColumnStart'
            ]
        ]
    ]),
    gridColumnEnd: (0, _createUtilityPlugin).default('gridColumnEnd', [
        [
            'col-end',
            [
                'gridColumnEnd'
            ]
        ]
    ]),
    gridRow: (0, _createUtilityPlugin).default('gridRow', [
        [
            'row',
            [
                'gridRow'
            ]
        ]
    ]),
    gridRowStart: (0, _createUtilityPlugin).default('gridRowStart', [
        [
            'row-start',
            [
                'gridRowStart'
            ]
        ]
    ]),
    gridRowEnd: (0, _createUtilityPlugin).default('gridRowEnd', [
        [
            'row-end',
            [
                'gridRowEnd'
            ]
        ]
    ]),
    float: ({ addUtilities  })=>{
        addUtilities({
            '.float-right': {
                float: 'right'
            },
            '.float-left': {
                float: 'left'
            },
            '.float-none': {
                float: 'none'
            }
        });
    },
    clear: ({ addUtilities  })=>{
        addUtilities({
            '.clear-left': {
                clear: 'left'
            },
            '.clear-right': {
                clear: 'right'
            },
            '.clear-both': {
                clear: 'both'
            },
            '.clear-none': {
                clear: 'none'
            }
        });
    },
    margin: (0, _createUtilityPlugin).default('margin', [
        [
            'm',
            [
                'margin'
            ]
        ],
        [
            [
                'mx',
                [
                    'margin-left',
                    'margin-right'
                ]
            ],
            [
                'my',
                [
                    'margin-top',
                    'margin-bottom'
                ]
            ], 
        ],
        [
            [
                'mt',
                [
                    'margin-top'
                ]
            ],
            [
                'mr',
                [
                    'margin-right'
                ]
            ],
            [
                'mb',
                [
                    'margin-bottom'
                ]
            ],
            [
                'ml',
                [
                    'margin-left'
                ]
            ], 
        ], 
    ], {
        supportsNegativeValues: true
    }),
    boxSizing: ({ addUtilities  })=>{
        addUtilities({
            '.box-border': {
                'box-sizing': 'border-box'
            },
            '.box-content': {
                'box-sizing': 'content-box'
            }
        });
    },
    display: ({ addUtilities  })=>{
        addUtilities({
            '.block': {
                display: 'block'
            },
            '.inline-block': {
                display: 'inline-block'
            },
            '.inline': {
                display: 'inline'
            },
            '.flex': {
                display: 'flex'
            },
            '.inline-flex': {
                display: 'inline-flex'
            },
            '.table': {
                display: 'table'
            },
            '.inline-table': {
                display: 'inline-table'
            },
            '.table-caption': {
                display: 'table-caption'
            },
            '.table-cell': {
                display: 'table-cell'
            },
            '.table-column': {
                display: 'table-column'
            },
            '.table-column-group': {
                display: 'table-column-group'
            },
            '.table-footer-group': {
                display: 'table-footer-group'
            },
            '.table-header-group': {
                display: 'table-header-group'
            },
            '.table-row-group': {
                display: 'table-row-group'
            },
            '.table-row': {
                display: 'table-row'
            },
            '.flow-root': {
                display: 'flow-root'
            },
            '.grid': {
                display: 'grid'
            },
            '.inline-grid': {
                display: 'inline-grid'
            },
            '.contents': {
                display: 'contents'
            },
            '.list-item': {
                display: 'list-item'
            },
            '.hidden': {
                display: 'none'
            }
        });
    },
    aspectRatio: (0, _createUtilityPlugin).default('aspectRatio', [
        [
            'aspect',
            [
                'aspect-ratio'
            ]
        ]
    ]),
    height: (0, _createUtilityPlugin).default('height', [
        [
            'h',
            [
                'height'
            ]
        ]
    ]),
    maxHeight: (0, _createUtilityPlugin).default('maxHeight', [
        [
            'max-h',
            [
                'maxHeight'
            ]
        ]
    ]),
    minHeight: (0, _createUtilityPlugin).default('minHeight', [
        [
            'min-h',
            [
                'minHeight'
            ]
        ]
    ]),
    width: (0, _createUtilityPlugin).default('width', [
        [
            'w',
            [
                'width'
            ]
        ]
    ]),
    minWidth: (0, _createUtilityPlugin).default('minWidth', [
        [
            'min-w',
            [
                'minWidth'
            ]
        ]
    ]),
    maxWidth: (0, _createUtilityPlugin).default('maxWidth', [
        [
            'max-w',
            [
                'maxWidth'
            ]
        ]
    ]),
    flex: (0, _createUtilityPlugin).default('flex'),
    flexShrink: (0, _createUtilityPlugin).default('flexShrink', [
        [
            'flex-shrink',
            [
                'flex-shrink'
            ]
        ],
        [
            'shrink',
            [
                'flex-shrink'
            ]
        ], 
    ]),
    flexGrow: (0, _createUtilityPlugin).default('flexGrow', [
        [
            'flex-grow',
            [
                'flex-grow'
            ]
        ],
        [
            'grow',
            [
                'flex-grow'
            ]
        ], 
    ]),
    flexBasis: (0, _createUtilityPlugin).default('flexBasis', [
        [
            'basis',
            [
                'flex-basis'
            ]
        ]
    ]),
    tableLayout: ({ addUtilities  })=>{
        addUtilities({
            '.table-auto': {
                'table-layout': 'auto'
            },
            '.table-fixed': {
                'table-layout': 'fixed'
            }
        });
    },
    borderCollapse: ({ addUtilities  })=>{
        addUtilities({
            '.border-collapse': {
                'border-collapse': 'collapse'
            },
            '.border-separate': {
                'border-collapse': 'separate'
            }
        });
    },
    transformOrigin: (0, _createUtilityPlugin).default('transformOrigin', [
        [
            'origin',
            [
                'transformOrigin'
            ]
        ]
    ]),
    translate: (0, _createUtilityPlugin).default('translate', [
        [
            [
                'translate-x',
                [
                    [
                        '@defaults transform',
                        {}
                    ],
                    '--tw-translate-x',
                    [
                        'transform',
                        cssTransformValue
                    ]
                ], 
            ],
            [
                'translate-y',
                [
                    [
                        '@defaults transform',
                        {}
                    ],
                    '--tw-translate-y',
                    [
                        'transform',
                        cssTransformValue
                    ]
                ], 
            ], 
        ], 
    ], {
        supportsNegativeValues: true
    }),
    rotate: (0, _createUtilityPlugin).default('rotate', [
        [
            'rotate',
            [
                [
                    '@defaults transform',
                    {}
                ],
                '--tw-rotate',
                [
                    'transform',
                    cssTransformValue
                ]
            ]
        ]
    ], {
        supportsNegativeValues: true
    }),
    skew: (0, _createUtilityPlugin).default('skew', [
        [
            [
                'skew-x',
                [
                    [
                        '@defaults transform',
                        {}
                    ],
                    '--tw-skew-x',
                    [
                        'transform',
                        cssTransformValue
                    ]
                ]
            ],
            [
                'skew-y',
                [
                    [
                        '@defaults transform',
                        {}
                    ],
                    '--tw-skew-y',
                    [
                        'transform',
                        cssTransformValue
                    ]
                ]
            ], 
        ], 
    ], {
        supportsNegativeValues: true
    }),
    scale: (0, _createUtilityPlugin).default('scale', [
        [
            'scale',
            [
                [
                    '@defaults transform',
                    {}
                ],
                '--tw-scale-x',
                '--tw-scale-y',
                [
                    'transform',
                    cssTransformValue
                ], 
            ], 
        ],
        [
            [
                'scale-x',
                [
                    [
                        '@defaults transform',
                        {}
                    ],
                    '--tw-scale-x',
                    [
                        'transform',
                        cssTransformValue
                    ]
                ], 
            ],
            [
                'scale-y',
                [
                    [
                        '@defaults transform',
                        {}
                    ],
                    '--tw-scale-y',
                    [
                        'transform',
                        cssTransformValue
                    ]
                ], 
            ], 
        ], 
    ], {
        supportsNegativeValues: true
    }),
    transform: ({ addDefaults , addUtilities  })=>{
        addDefaults('transform', {
            '--tw-translate-x': '0',
            '--tw-translate-y': '0',
            '--tw-rotate': '0',
            '--tw-skew-x': '0',
            '--tw-skew-y': '0',
            '--tw-scale-x': '1',
            '--tw-scale-y': '1'
        });
        addUtilities({
            '.transform': {
                '@defaults transform': {},
                transform: cssTransformValue
            },
            '.transform-cpu': {
                transform: cssTransformValue
            },
            '.transform-gpu': {
                transform: cssTransformValue.replace('translate(var(--tw-translate-x), var(--tw-translate-y))', 'translate3d(var(--tw-translate-x), var(--tw-translate-y), 0)')
            },
            '.transform-none': {
                transform: 'none'
            }
        });
    },
    animation: ({ matchUtilities , theme , prefix  })=>{
        let prefixName = (name)=>prefix(`.${name}`).slice(1)
        ;
        var ref;
        let keyframes = Object.fromEntries(Object.entries((ref = theme('keyframes')) !== null && ref !== void 0 ? ref : {}).map(([key, value])=>{
            return [
                key,
                {
                    [`@keyframes ${prefixName(key)}`]: value
                }
            ];
        }));
        matchUtilities({
            animate: (value1)=>{
                let animations = (0, _parseAnimationValue).default(value1);
                return [
                    ...animations.flatMap((animation)=>keyframes[animation.name]
                    ),
                    {
                        animation: animations.map(({ name , value  })=>{
                            if (name === undefined || keyframes[name] === undefined) {
                                return value;
                            }
                            return value.replace(name, prefixName(name));
                        }).join(', ')
                    }, 
                ];
            }
        }, {
            values: theme('animation')
        });
    },
    cursor: (0, _createUtilityPlugin).default('cursor'),
    touchAction: ({ addDefaults , addUtilities  })=>{
        addDefaults('touch-action', {
            '--tw-pan-x': ' ',
            '--tw-pan-y': ' ',
            '--tw-pinch-zoom': ' '
        });
        let cssTouchActionValue = 'var(--tw-pan-x) var(--tw-pan-y) var(--tw-pinch-zoom)';
        addUtilities({
            '.touch-auto': {
                'touch-action': 'auto'
            },
            '.touch-none': {
                'touch-action': 'none'
            },
            '.touch-pan-x': {
                '@defaults touch-action': {},
                '--tw-pan-x': 'pan-x',
                'touch-action': cssTouchActionValue
            },
            '.touch-pan-left': {
                '@defaults touch-action': {},
                '--tw-pan-x': 'pan-left',
                'touch-action': cssTouchActionValue
            },
            '.touch-pan-right': {
                '@defaults touch-action': {},
                '--tw-pan-x': 'pan-right',
                'touch-action': cssTouchActionValue
            },
            '.touch-pan-y': {
                '@defaults touch-action': {},
                '--tw-pan-y': 'pan-y',
                'touch-action': cssTouchActionValue
            },
            '.touch-pan-up': {
                '@defaults touch-action': {},
                '--tw-pan-y': 'pan-up',
                'touch-action': cssTouchActionValue
            },
            '.touch-pan-down': {
                '@defaults touch-action': {},
                '--tw-pan-y': 'pan-down',
                'touch-action': cssTouchActionValue
            },
            '.touch-pinch-zoom': {
                '@defaults touch-action': {},
                '--tw-pinch-zoom': 'pinch-zoom',
                'touch-action': cssTouchActionValue
            },
            '.touch-manipulation': {
                'touch-action': 'manipulation'
            }
        });
    },
    userSelect: ({ addUtilities  })=>{
        addUtilities({
            '.select-none': {
                'user-select': 'none'
            },
            '.select-text': {
                'user-select': 'text'
            },
            '.select-all': {
                'user-select': 'all'
            },
            '.select-auto': {
                'user-select': 'auto'
            }
        });
    },
    resize: ({ addUtilities  })=>{
        addUtilities({
            '.resize-none': {
                resize: 'none'
            },
            '.resize-y': {
                resize: 'vertical'
            },
            '.resize-x': {
                resize: 'horizontal'
            },
            '.resize': {
                resize: 'both'
            }
        });
    },
    scrollSnapType: ({ addDefaults , addUtilities  })=>{
        addDefaults('scroll-snap-type', {
            '--tw-scroll-snap-strictness': 'proximity'
        });
        addUtilities({
            '.snap-none': {
                'scroll-snap-type': 'none'
            },
            '.snap-x': {
                '@defaults scroll-snap-type': {},
                'scroll-snap-type': 'x var(--tw-scroll-snap-strictness)'
            },
            '.snap-y': {
                '@defaults scroll-snap-type': {},
                'scroll-snap-type': 'y var(--tw-scroll-snap-strictness)'
            },
            '.snap-both': {
                '@defaults scroll-snap-type': {},
                'scroll-snap-type': 'both var(--tw-scroll-snap-strictness)'
            },
            '.snap-mandatory': {
                '--tw-scroll-snap-strictness': 'mandatory'
            },
            '.snap-proximity': {
                '--tw-scroll-snap-strictness': 'proximity'
            }
        });
    },
    scrollSnapAlign: ({ addUtilities  })=>{
        addUtilities({
            '.snap-start': {
                'scroll-snap-align': 'start'
            },
            '.snap-end': {
                'scroll-snap-align': 'end'
            },
            '.snap-center': {
                'scroll-snap-align': 'center'
            },
            '.snap-align-none': {
                'scroll-snap-align': 'none'
            }
        });
    },
    scrollSnapStop: ({ addUtilities  })=>{
        addUtilities({
            '.snap-normal': {
                'scroll-snap-stop': 'normal'
            },
            '.snap-always': {
                'scroll-snap-stop': 'always'
            }
        });
    },
    scrollMargin: (0, _createUtilityPlugin).default('scrollMargin', [
        [
            'scroll-m',
            [
                'scroll-margin'
            ]
        ],
        [
            [
                'scroll-mx',
                [
                    'scroll-margin-left',
                    'scroll-margin-right'
                ]
            ],
            [
                'scroll-my',
                [
                    'scroll-margin-top',
                    'scroll-margin-bottom'
                ]
            ], 
        ],
        [
            [
                'scroll-mt',
                [
                    'scroll-margin-top'
                ]
            ],
            [
                'scroll-mr',
                [
                    'scroll-margin-right'
                ]
            ],
            [
                'scroll-mb',
                [
                    'scroll-margin-bottom'
                ]
            ],
            [
                'scroll-ml',
                [
                    'scroll-margin-left'
                ]
            ], 
        ], 
    ], {
        supportsNegativeValues: true
    }),
    scrollPadding: (0, _createUtilityPlugin).default('scrollPadding', [
        [
            'scroll-p',
            [
                'scroll-padding'
            ]
        ],
        [
            [
                'scroll-px',
                [
                    'scroll-padding-left',
                    'scroll-padding-right'
                ]
            ],
            [
                'scroll-py',
                [
                    'scroll-padding-top',
                    'scroll-padding-bottom'
                ]
            ], 
        ],
        [
            [
                'scroll-pt',
                [
                    'scroll-padding-top'
                ]
            ],
            [
                'scroll-pr',
                [
                    'scroll-padding-right'
                ]
            ],
            [
                'scroll-pb',
                [
                    'scroll-padding-bottom'
                ]
            ],
            [
                'scroll-pl',
                [
                    'scroll-padding-left'
                ]
            ], 
        ], 
    ]),
    listStylePosition: ({ addUtilities  })=>{
        addUtilities({
            '.list-inside': {
                'list-style-position': 'inside'
            },
            '.list-outside': {
                'list-style-position': 'outside'
            }
        });
    },
    listStyleType: (0, _createUtilityPlugin).default('listStyleType', [
        [
            'list',
            [
                'listStyleType'
            ]
        ]
    ]),
    appearance: ({ addUtilities  })=>{
        addUtilities({
            '.appearance-none': {
                appearance: 'none'
            }
        });
    },
    columns: (0, _createUtilityPlugin).default('columns', [
        [
            'columns',
            [
                'columns'
            ]
        ]
    ]),
    breakBefore: ({ addUtilities  })=>{
        addUtilities({
            '.break-before-auto': {
                'break-before': 'auto'
            },
            '.break-before-avoid': {
                'break-before': 'avoid'
            },
            '.break-before-all': {
                'break-before': 'all'
            },
            '.break-before-avoid-page': {
                'break-before': 'avoid-page'
            },
            '.break-before-page': {
                'break-before': 'page'
            },
            '.break-before-left': {
                'break-before': 'left'
            },
            '.break-before-right': {
                'break-before': 'right'
            },
            '.break-before-column': {
                'break-before': 'column'
            }
        });
    },
    breakInside: ({ addUtilities  })=>{
        addUtilities({
            '.break-inside-auto': {
                'break-inside': 'auto'
            },
            '.break-inside-avoid': {
                'break-inside': 'avoid'
            },
            '.break-inside-avoid-page': {
                'break-inside': 'avoid-page'
            },
            '.break-inside-avoid-column': {
                'break-inside': 'avoid-column'
            }
        });
    },
    breakAfter: ({ addUtilities  })=>{
        addUtilities({
            '.break-after-auto': {
                'break-after': 'auto'
            },
            '.break-after-avoid': {
                'break-after': 'avoid'
            },
            '.break-after-all': {
                'break-after': 'all'
            },
            '.break-after-avoid-page': {
                'break-after': 'avoid-page'
            },
            '.break-after-page': {
                'break-after': 'page'
            },
            '.break-after-left': {
                'break-after': 'left'
            },
            '.break-after-right': {
                'break-after': 'right'
            },
            '.break-after-column': {
                'break-after': 'column'
            }
        });
    },
    gridAutoColumns: (0, _createUtilityPlugin).default('gridAutoColumns', [
        [
            'auto-cols',
            [
                'gridAutoColumns'
            ]
        ]
    ]),
    gridAutoFlow: ({ addUtilities  })=>{
        addUtilities({
            '.grid-flow-row': {
                gridAutoFlow: 'row'
            },
            '.grid-flow-col': {
                gridAutoFlow: 'column'
            },
            '.grid-flow-row-dense': {
                gridAutoFlow: 'row dense'
            },
            '.grid-flow-col-dense': {
                gridAutoFlow: 'column dense'
            }
        });
    },
    gridAutoRows: (0, _createUtilityPlugin).default('gridAutoRows', [
        [
            'auto-rows',
            [
                'gridAutoRows'
            ]
        ]
    ]),
    gridTemplateColumns: (0, _createUtilityPlugin).default('gridTemplateColumns', [
        [
            'grid-cols',
            [
                'gridTemplateColumns'
            ]
        ], 
    ]),
    gridTemplateRows: (0, _createUtilityPlugin).default('gridTemplateRows', [
        [
            'grid-rows',
            [
                'gridTemplateRows'
            ]
        ]
    ]),
    flexDirection: ({ addUtilities  })=>{
        addUtilities({
            '.flex-row': {
                'flex-direction': 'row'
            },
            '.flex-row-reverse': {
                'flex-direction': 'row-reverse'
            },
            '.flex-col': {
                'flex-direction': 'column'
            },
            '.flex-col-reverse': {
                'flex-direction': 'column-reverse'
            }
        });
    },
    flexWrap: ({ addUtilities  })=>{
        addUtilities({
            '.flex-wrap': {
                'flex-wrap': 'wrap'
            },
            '.flex-wrap-reverse': {
                'flex-wrap': 'wrap-reverse'
            },
            '.flex-nowrap': {
                'flex-wrap': 'nowrap'
            }
        });
    },
    placeContent: ({ addUtilities  })=>{
        addUtilities({
            '.place-content-center': {
                'place-content': 'center'
            },
            '.place-content-start': {
                'place-content': 'start'
            },
            '.place-content-end': {
                'place-content': 'end'
            },
            '.place-content-between': {
                'place-content': 'space-between'
            },
            '.place-content-around': {
                'place-content': 'space-around'
            },
            '.place-content-evenly': {
                'place-content': 'space-evenly'
            },
            '.place-content-stretch': {
                'place-content': 'stretch'
            }
        });
    },
    placeItems: ({ addUtilities  })=>{
        addUtilities({
            '.place-items-start': {
                'place-items': 'start'
            },
            '.place-items-end': {
                'place-items': 'end'
            },
            '.place-items-center': {
                'place-items': 'center'
            },
            '.place-items-stretch': {
                'place-items': 'stretch'
            }
        });
    },
    alignContent: ({ addUtilities  })=>{
        addUtilities({
            '.content-center': {
                'align-content': 'center'
            },
            '.content-start': {
                'align-content': 'flex-start'
            },
            '.content-end': {
                'align-content': 'flex-end'
            },
            '.content-between': {
                'align-content': 'space-between'
            },
            '.content-around': {
                'align-content': 'space-around'
            },
            '.content-evenly': {
                'align-content': 'space-evenly'
            }
        });
    },
    alignItems: ({ addUtilities  })=>{
        addUtilities({
            '.items-start': {
                'align-items': 'flex-start'
            },
            '.items-end': {
                'align-items': 'flex-end'
            },
            '.items-center': {
                'align-items': 'center'
            },
            '.items-baseline': {
                'align-items': 'baseline'
            },
            '.items-stretch': {
                'align-items': 'stretch'
            }
        });
    },
    justifyContent: ({ addUtilities  })=>{
        addUtilities({
            '.justify-start': {
                'justify-content': 'flex-start'
            },
            '.justify-end': {
                'justify-content': 'flex-end'
            },
            '.justify-center': {
                'justify-content': 'center'
            },
            '.justify-between': {
                'justify-content': 'space-between'
            },
            '.justify-around': {
                'justify-content': 'space-around'
            },
            '.justify-evenly': {
                'justify-content': 'space-evenly'
            }
        });
    },
    justifyItems: ({ addUtilities  })=>{
        addUtilities({
            '.justify-items-start': {
                'justify-items': 'start'
            },
            '.justify-items-end': {
                'justify-items': 'end'
            },
            '.justify-items-center': {
                'justify-items': 'center'
            },
            '.justify-items-stretch': {
                'justify-items': 'stretch'
            }
        });
    },
    gap: (0, _createUtilityPlugin).default('gap', [
        [
            'gap',
            [
                'gap'
            ]
        ],
        [
            [
                'gap-x',
                [
                    'columnGap'
                ]
            ],
            [
                'gap-y',
                [
                    'rowGap'
                ]
            ], 
        ], 
    ]),
    space: ({ matchUtilities , addUtilities , theme  })=>{
        matchUtilities({
            'space-x': (value)=>{
                value = value === '0' ? '0px' : value;
                return {
                    '& > :not([hidden]) ~ :not([hidden])': {
                        '--tw-space-x-reverse': '0',
                        'margin-right': `calc(${value} * var(--tw-space-x-reverse))`,
                        'margin-left': `calc(${value} * calc(1 - var(--tw-space-x-reverse)))`
                    }
                };
            },
            'space-y': (value)=>{
                value = value === '0' ? '0px' : value;
                return {
                    '& > :not([hidden]) ~ :not([hidden])': {
                        '--tw-space-y-reverse': '0',
                        'margin-top': `calc(${value} * calc(1 - var(--tw-space-y-reverse)))`,
                        'margin-bottom': `calc(${value} * var(--tw-space-y-reverse))`
                    }
                };
            }
        }, {
            values: theme('space'),
            supportsNegativeValues: true
        });
        addUtilities({
            '.space-y-reverse > :not([hidden]) ~ :not([hidden])': {
                '--tw-space-y-reverse': '1'
            },
            '.space-x-reverse > :not([hidden]) ~ :not([hidden])': {
                '--tw-space-x-reverse': '1'
            }
        });
    },
    divideWidth: ({ matchUtilities , addUtilities , theme  })=>{
        matchUtilities({
            'divide-x': (value)=>{
                value = value === '0' ? '0px' : value;
                return {
                    '& > :not([hidden]) ~ :not([hidden])': {
                        '@defaults border-width': {},
                        '--tw-divide-x-reverse': '0',
                        'border-right-width': `calc(${value} * var(--tw-divide-x-reverse))`,
                        'border-left-width': `calc(${value} * calc(1 - var(--tw-divide-x-reverse)))`
                    }
                };
            },
            'divide-y': (value)=>{
                value = value === '0' ? '0px' : value;
                return {
                    '& > :not([hidden]) ~ :not([hidden])': {
                        '@defaults border-width': {},
                        '--tw-divide-y-reverse': '0',
                        'border-top-width': `calc(${value} * calc(1 - var(--tw-divide-y-reverse)))`,
                        'border-bottom-width': `calc(${value} * var(--tw-divide-y-reverse))`
                    }
                };
            }
        }, {
            values: theme('divideWidth'),
            type: [
                'line-width',
                'length'
            ]
        });
        addUtilities({
            '.divide-y-reverse > :not([hidden]) ~ :not([hidden])': {
                '@defaults border-width': {},
                '--tw-divide-y-reverse': '1'
            },
            '.divide-x-reverse > :not([hidden]) ~ :not([hidden])': {
                '@defaults border-width': {},
                '--tw-divide-x-reverse': '1'
            }
        });
    },
    divideStyle: ({ addUtilities  })=>{
        addUtilities({
            '.divide-solid > :not([hidden]) ~ :not([hidden])': {
                'border-style': 'solid'
            },
            '.divide-dashed > :not([hidden]) ~ :not([hidden])': {
                'border-style': 'dashed'
            },
            '.divide-dotted > :not([hidden]) ~ :not([hidden])': {
                'border-style': 'dotted'
            },
            '.divide-double > :not([hidden]) ~ :not([hidden])': {
                'border-style': 'double'
            },
            '.divide-none > :not([hidden]) ~ :not([hidden])': {
                'border-style': 'none'
            }
        });
    },
    divideColor: ({ matchUtilities , theme , corePlugins: corePlugins1  })=>{
        matchUtilities({
            divide: (value)=>{
                if (!corePlugins1('divideOpacity')) {
                    return {
                        ['& > :not([hidden]) ~ :not([hidden])']: {
                            'border-color': (0, _toColorValue).default(value)
                        }
                    };
                }
                return {
                    ['& > :not([hidden]) ~ :not([hidden])']: (0, _withAlphaVariable).default({
                        color: value,
                        property: 'border-color',
                        variable: '--tw-divide-opacity'
                    })
                };
            }
        }, {
            values: (({ DEFAULT: _ , ...colors })=>colors
            )((0, _flattenColorPalette).default(theme('divideColor'))),
            type: 'color'
        });
    },
    divideOpacity: ({ matchUtilities , theme  })=>{
        matchUtilities({
            'divide-opacity': (value)=>{
                return {
                    [`& > :not([hidden]) ~ :not([hidden])`]: {
                        '--tw-divide-opacity': value
                    }
                };
            }
        }, {
            values: theme('divideOpacity')
        });
    },
    placeSelf: ({ addUtilities  })=>{
        addUtilities({
            '.place-self-auto': {
                'place-self': 'auto'
            },
            '.place-self-start': {
                'place-self': 'start'
            },
            '.place-self-end': {
                'place-self': 'end'
            },
            '.place-self-center': {
                'place-self': 'center'
            },
            '.place-self-stretch': {
                'place-self': 'stretch'
            }
        });
    },
    alignSelf: ({ addUtilities  })=>{
        addUtilities({
            '.self-auto': {
                'align-self': 'auto'
            },
            '.self-start': {
                'align-self': 'flex-start'
            },
            '.self-end': {
                'align-self': 'flex-end'
            },
            '.self-center': {
                'align-self': 'center'
            },
            '.self-stretch': {
                'align-self': 'stretch'
            },
            '.self-baseline': {
                'align-self': 'baseline'
            }
        });
    },
    justifySelf: ({ addUtilities  })=>{
        addUtilities({
            '.justify-self-auto': {
                'justify-self': 'auto'
            },
            '.justify-self-start': {
                'justify-self': 'start'
            },
            '.justify-self-end': {
                'justify-self': 'end'
            },
            '.justify-self-center': {
                'justify-self': 'center'
            },
            '.justify-self-stretch': {
                'justify-self': 'stretch'
            }
        });
    },
    overflow: ({ addUtilities  })=>{
        addUtilities({
            '.overflow-auto': {
                overflow: 'auto'
            },
            '.overflow-hidden': {
                overflow: 'hidden'
            },
            '.overflow-clip': {
                overflow: 'clip'
            },
            '.overflow-visible': {
                overflow: 'visible'
            },
            '.overflow-scroll': {
                overflow: 'scroll'
            },
            '.overflow-x-auto': {
                'overflow-x': 'auto'
            },
            '.overflow-y-auto': {
                'overflow-y': 'auto'
            },
            '.overflow-x-hidden': {
                'overflow-x': 'hidden'
            },
            '.overflow-y-hidden': {
                'overflow-y': 'hidden'
            },
            '.overflow-x-clip': {
                'overflow-x': 'clip'
            },
            '.overflow-y-clip': {
                'overflow-y': 'clip'
            },
            '.overflow-x-visible': {
                'overflow-x': 'visible'
            },
            '.overflow-y-visible': {
                'overflow-y': 'visible'
            },
            '.overflow-x-scroll': {
                'overflow-x': 'scroll'
            },
            '.overflow-y-scroll': {
                'overflow-y': 'scroll'
            }
        });
    },
    overscrollBehavior: ({ addUtilities  })=>{
        addUtilities({
            '.overscroll-auto': {
                'overscroll-behavior': 'auto'
            },
            '.overscroll-contain': {
                'overscroll-behavior': 'contain'
            },
            '.overscroll-none': {
                'overscroll-behavior': 'none'
            },
            '.overscroll-y-auto': {
                'overscroll-behavior-y': 'auto'
            },
            '.overscroll-y-contain': {
                'overscroll-behavior-y': 'contain'
            },
            '.overscroll-y-none': {
                'overscroll-behavior-y': 'none'
            },
            '.overscroll-x-auto': {
                'overscroll-behavior-x': 'auto'
            },
            '.overscroll-x-contain': {
                'overscroll-behavior-x': 'contain'
            },
            '.overscroll-x-none': {
                'overscroll-behavior-x': 'none'
            }
        });
    },
    scrollBehavior: ({ addUtilities  })=>{
        addUtilities({
            '.scroll-auto': {
                'scroll-behavior': 'auto'
            },
            '.scroll-smooth': {
                'scroll-behavior': 'smooth'
            }
        });
    },
    textOverflow: ({ addUtilities  })=>{
        addUtilities({
            '.truncate': {
                overflow: 'hidden',
                'text-overflow': 'ellipsis',
                'white-space': 'nowrap'
            },
            '.overflow-ellipsis': {
                'text-overflow': 'ellipsis'
            },
            '.text-ellipsis': {
                'text-overflow': 'ellipsis'
            },
            '.text-clip': {
                'text-overflow': 'clip'
            }
        });
    },
    whitespace: ({ addUtilities  })=>{
        addUtilities({
            '.whitespace-normal': {
                'white-space': 'normal'
            },
            '.whitespace-nowrap': {
                'white-space': 'nowrap'
            },
            '.whitespace-pre': {
                'white-space': 'pre'
            },
            '.whitespace-pre-line': {
                'white-space': 'pre-line'
            },
            '.whitespace-pre-wrap': {
                'white-space': 'pre-wrap'
            }
        });
    },
    wordBreak: ({ addUtilities  })=>{
        addUtilities({
            '.break-normal': {
                'overflow-wrap': 'normal',
                'word-break': 'normal'
            },
            '.break-words': {
                'overflow-wrap': 'break-word'
            },
            '.break-all': {
                'word-break': 'break-all'
            }
        });
    },
    borderRadius: (0, _createUtilityPlugin).default('borderRadius', [
        [
            'rounded',
            [
                'border-radius'
            ]
        ],
        [
            [
                'rounded-t',
                [
                    'border-top-left-radius',
                    'border-top-right-radius'
                ]
            ],
            [
                'rounded-r',
                [
                    'border-top-right-radius',
                    'border-bottom-right-radius'
                ]
            ],
            [
                'rounded-b',
                [
                    'border-bottom-right-radius',
                    'border-bottom-left-radius'
                ]
            ],
            [
                'rounded-l',
                [
                    'border-top-left-radius',
                    'border-bottom-left-radius'
                ]
            ], 
        ],
        [
            [
                'rounded-tl',
                [
                    'border-top-left-radius'
                ]
            ],
            [
                'rounded-tr',
                [
                    'border-top-right-radius'
                ]
            ],
            [
                'rounded-br',
                [
                    'border-bottom-right-radius'
                ]
            ],
            [
                'rounded-bl',
                [
                    'border-bottom-left-radius'
                ]
            ], 
        ], 
    ]),
    borderWidth: (0, _createUtilityPlugin).default('borderWidth', [
        [
            'border',
            [
                [
                    '@defaults border-width',
                    {}
                ],
                'border-width'
            ]
        ],
        [
            [
                'border-x',
                [
                    [
                        '@defaults border-width',
                        {}
                    ],
                    'border-left-width',
                    'border-right-width'
                ]
            ],
            [
                'border-y',
                [
                    [
                        '@defaults border-width',
                        {}
                    ],
                    'border-top-width',
                    'border-bottom-width'
                ]
            ], 
        ],
        [
            [
                'border-t',
                [
                    [
                        '@defaults border-width',
                        {}
                    ],
                    'border-top-width'
                ]
            ],
            [
                'border-r',
                [
                    [
                        '@defaults border-width',
                        {}
                    ],
                    'border-right-width'
                ]
            ],
            [
                'border-b',
                [
                    [
                        '@defaults border-width',
                        {}
                    ],
                    'border-bottom-width'
                ]
            ],
            [
                'border-l',
                [
                    [
                        '@defaults border-width',
                        {}
                    ],
                    'border-left-width'
                ]
            ], 
        ], 
    ], {
        type: [
            'line-width',
            'length'
        ]
    }),
    borderStyle: ({ addUtilities  })=>{
        addUtilities({
            '.border-solid': {
                'border-style': 'solid'
            },
            '.border-dashed': {
                'border-style': 'dashed'
            },
            '.border-dotted': {
                'border-style': 'dotted'
            },
            '.border-double': {
                'border-style': 'double'
            },
            '.border-hidden': {
                'border-style': 'hidden'
            },
            '.border-none': {
                'border-style': 'none'
            }
        });
    },
    borderColor: ({ matchUtilities , theme , corePlugins: corePlugins2  })=>{
        matchUtilities({
            border: (value)=>{
                if (!corePlugins2('borderOpacity')) {
                    return {
                        'border-color': (0, _toColorValue).default(value)
                    };
                }
                return (0, _withAlphaVariable).default({
                    color: value,
                    property: 'border-color',
                    variable: '--tw-border-opacity'
                });
            }
        }, {
            values: (({ DEFAULT: _ , ...colors })=>colors
            )((0, _flattenColorPalette).default(theme('borderColor'))),
            type: [
                'color'
            ]
        });
        matchUtilities({
            'border-x': (value)=>{
                if (!corePlugins2('borderOpacity')) {
                    return {
                        'border-left-color': (0, _toColorValue).default(value),
                        'border-right-color': (0, _toColorValue).default(value)
                    };
                }
                return (0, _withAlphaVariable).default({
                    color: value,
                    property: [
                        'border-left-color',
                        'border-right-color'
                    ],
                    variable: '--tw-border-opacity'
                });
            },
            'border-y': (value)=>{
                if (!corePlugins2('borderOpacity')) {
                    return {
                        'border-top-color': (0, _toColorValue).default(value),
                        'border-bottom-color': (0, _toColorValue).default(value)
                    };
                }
                return (0, _withAlphaVariable).default({
                    color: value,
                    property: [
                        'border-top-color',
                        'border-bottom-color'
                    ],
                    variable: '--tw-border-opacity'
                });
            }
        }, {
            values: (({ DEFAULT: _ , ...colors })=>colors
            )((0, _flattenColorPalette).default(theme('borderColor'))),
            type: 'color'
        });
        matchUtilities({
            'border-t': (value)=>{
                if (!corePlugins2('borderOpacity')) {
                    return {
                        'border-top-color': (0, _toColorValue).default(value)
                    };
                }
                return (0, _withAlphaVariable).default({
                    color: value,
                    property: 'border-top-color',
                    variable: '--tw-border-opacity'
                });
            },
            'border-r': (value)=>{
                if (!corePlugins2('borderOpacity')) {
                    return {
                        'border-right-color': (0, _toColorValue).default(value)
                    };
                }
                return (0, _withAlphaVariable).default({
                    color: value,
                    property: 'border-right-color',
                    variable: '--tw-border-opacity'
                });
            },
            'border-b': (value)=>{
                if (!corePlugins2('borderOpacity')) {
                    return {
                        'border-bottom-color': (0, _toColorValue).default(value)
                    };
                }
                return (0, _withAlphaVariable).default({
                    color: value,
                    property: 'border-bottom-color',
                    variable: '--tw-border-opacity'
                });
            },
            'border-l': (value)=>{
                if (!corePlugins2('borderOpacity')) {
                    return {
                        'border-left-color': (0, _toColorValue).default(value)
                    };
                }
                return (0, _withAlphaVariable).default({
                    color: value,
                    property: 'border-left-color',
                    variable: '--tw-border-opacity'
                });
            }
        }, {
            values: (({ DEFAULT: _ , ...colors })=>colors
            )((0, _flattenColorPalette).default(theme('borderColor'))),
            type: 'color'
        });
    },
    borderOpacity: (0, _createUtilityPlugin).default('borderOpacity', [
        [
            'border-opacity',
            [
                '--tw-border-opacity'
            ]
        ], 
    ]),
    backgroundColor: ({ matchUtilities , theme , corePlugins: corePlugins3  })=>{
        matchUtilities({
            bg: (value)=>{
                if (!corePlugins3('backgroundOpacity')) {
                    return {
                        'background-color': (0, _toColorValue).default(value)
                    };
                }
                return (0, _withAlphaVariable).default({
                    color: value,
                    property: 'background-color',
                    variable: '--tw-bg-opacity'
                });
            }
        }, {
            values: (0, _flattenColorPalette).default(theme('backgroundColor')),
            type: 'color'
        });
    },
    backgroundOpacity: (0, _createUtilityPlugin).default('backgroundOpacity', [
        [
            'bg-opacity',
            [
                '--tw-bg-opacity'
            ]
        ], 
    ]),
    backgroundImage: (0, _createUtilityPlugin).default('backgroundImage', [
        [
            'bg',
            [
                'background-image'
            ]
        ]
    ], {
        type: [
            'lookup',
            'image',
            'url'
        ]
    }),
    gradientColorStops: (()=>{
        function transparentTo(value) {
            return (0, _withAlphaVariable).withAlphaValue(value, 0, 'rgb(255 255 255 / 0)');
        }
        return function({ matchUtilities , theme  }) {
            let options = {
                values: (0, _flattenColorPalette).default(theme('gradientColorStops')),
                type: [
                    'color',
                    'any'
                ]
            };
            matchUtilities({
                from: (value)=>{
                    let transparentToValue = transparentTo(value);
                    return {
                        '--tw-gradient-from': (0, _toColorValue).default(value, 'from'),
                        '--tw-gradient-stops': `var(--tw-gradient-from), var(--tw-gradient-to, ${transparentToValue})`
                    };
                }
            }, options);
            matchUtilities({
                via: (value)=>{
                    let transparentToValue = transparentTo(value);
                    return {
                        '--tw-gradient-stops': `var(--tw-gradient-from), ${(0, _toColorValue).default(value, 'via')}, var(--tw-gradient-to, ${transparentToValue})`
                    };
                }
            }, options);
            matchUtilities({
                to: (value)=>({
                        '--tw-gradient-to': (0, _toColorValue).default(value, 'to')
                    })
            }, options);
        };
    })(),
    boxDecorationBreak: ({ addUtilities  })=>{
        addUtilities({
            '.decoration-slice': {
                'box-decoration-break': 'slice'
            },
            '.decoration-clone': {
                'box-decoration-break': 'clone'
            },
            '.box-decoration-slice': {
                'box-decoration-break': 'slice'
            },
            '.box-decoration-clone': {
                'box-decoration-break': 'clone'
            }
        });
    },
    backgroundSize: (0, _createUtilityPlugin).default('backgroundSize', [
        [
            'bg',
            [
                'background-size'
            ]
        ]
    ], {
        type: [
            'lookup',
            'length',
            'percentage'
        ]
    }),
    backgroundAttachment: ({ addUtilities  })=>{
        addUtilities({
            '.bg-fixed': {
                'background-attachment': 'fixed'
            },
            '.bg-local': {
                'background-attachment': 'local'
            },
            '.bg-scroll': {
                'background-attachment': 'scroll'
            }
        });
    },
    backgroundClip: ({ addUtilities  })=>{
        addUtilities({
            '.bg-clip-border': {
                'background-clip': 'border-box'
            },
            '.bg-clip-padding': {
                'background-clip': 'padding-box'
            },
            '.bg-clip-content': {
                'background-clip': 'content-box'
            },
            '.bg-clip-text': {
                'background-clip': 'text'
            }
        });
    },
    backgroundPosition: (0, _createUtilityPlugin).default('backgroundPosition', [
        [
            'bg',
            [
                'background-position'
            ]
        ]
    ], {
        type: [
            'lookup',
            'position'
        ]
    }),
    backgroundRepeat: ({ addUtilities  })=>{
        addUtilities({
            '.bg-repeat': {
                'background-repeat': 'repeat'
            },
            '.bg-no-repeat': {
                'background-repeat': 'no-repeat'
            },
            '.bg-repeat-x': {
                'background-repeat': 'repeat-x'
            },
            '.bg-repeat-y': {
                'background-repeat': 'repeat-y'
            },
            '.bg-repeat-round': {
                'background-repeat': 'round'
            },
            '.bg-repeat-space': {
                'background-repeat': 'space'
            }
        });
    },
    backgroundOrigin: ({ addUtilities  })=>{
        addUtilities({
            '.bg-origin-border': {
                'background-origin': 'border-box'
            },
            '.bg-origin-padding': {
                'background-origin': 'padding-box'
            },
            '.bg-origin-content': {
                'background-origin': 'content-box'
            }
        });
    },
    fill: ({ matchUtilities , theme  })=>{
        matchUtilities({
            fill: (value)=>{
                return {
                    fill: (0, _toColorValue).default(value)
                };
            }
        }, {
            values: (0, _flattenColorPalette).default(theme('fill')),
            type: [
                'color',
                'any'
            ]
        });
    },
    stroke: ({ matchUtilities , theme  })=>{
        matchUtilities({
            stroke: (value)=>{
                return {
                    stroke: (0, _toColorValue).default(value)
                };
            }
        }, {
            values: (0, _flattenColorPalette).default(theme('stroke')),
            type: [
                'color',
                'url'
            ]
        });
    },
    strokeWidth: (0, _createUtilityPlugin).default('strokeWidth', [
        [
            'stroke',
            [
                'stroke-width'
            ]
        ]
    ], {
        type: [
            'length',
            'number',
            'percentage'
        ]
    }),
    objectFit: ({ addUtilities  })=>{
        addUtilities({
            '.object-contain': {
                'object-fit': 'contain'
            },
            '.object-cover': {
                'object-fit': 'cover'
            },
            '.object-fill': {
                'object-fit': 'fill'
            },
            '.object-none': {
                'object-fit': 'none'
            },
            '.object-scale-down': {
                'object-fit': 'scale-down'
            }
        });
    },
    objectPosition: (0, _createUtilityPlugin).default('objectPosition', [
        [
            'object',
            [
                'object-position'
            ]
        ]
    ]),
    padding: (0, _createUtilityPlugin).default('padding', [
        [
            'p',
            [
                'padding'
            ]
        ],
        [
            [
                'px',
                [
                    'padding-left',
                    'padding-right'
                ]
            ],
            [
                'py',
                [
                    'padding-top',
                    'padding-bottom'
                ]
            ], 
        ],
        [
            [
                'pt',
                [
                    'padding-top'
                ]
            ],
            [
                'pr',
                [
                    'padding-right'
                ]
            ],
            [
                'pb',
                [
                    'padding-bottom'
                ]
            ],
            [
                'pl',
                [
                    'padding-left'
                ]
            ], 
        ], 
    ]),
    textAlign: ({ addUtilities  })=>{
        addUtilities({
            '.text-left': {
                'text-align': 'left'
            },
            '.text-center': {
                'text-align': 'center'
            },
            '.text-right': {
                'text-align': 'right'
            },
            '.text-justify': {
                'text-align': 'justify'
            }
        });
    },
    textIndent: (0, _createUtilityPlugin).default('textIndent', [
        [
            'indent',
            [
                'text-indent'
            ]
        ]
    ], {
        supportsNegativeValues: true
    }),
    verticalAlign: ({ addUtilities , matchUtilities  })=>{
        addUtilities({
            '.align-baseline': {
                'vertical-align': 'baseline'
            },
            '.align-top': {
                'vertical-align': 'top'
            },
            '.align-middle': {
                'vertical-align': 'middle'
            },
            '.align-bottom': {
                'vertical-align': 'bottom'
            },
            '.align-text-top': {
                'vertical-align': 'text-top'
            },
            '.align-text-bottom': {
                'vertical-align': 'text-bottom'
            },
            '.align-sub': {
                'vertical-align': 'sub'
            },
            '.align-super': {
                'vertical-align': 'super'
            }
        });
        matchUtilities({
            align: (value)=>({
                    'vertical-align': value
                })
        });
    },
    fontFamily: (0, _createUtilityPlugin).default('fontFamily', [
        [
            'font',
            [
                'fontFamily'
            ]
        ]
    ], {
        type: [
            'lookup',
            'generic-name',
            'family-name'
        ]
    }),
    fontSize: ({ matchUtilities , theme  })=>{
        matchUtilities({
            text: (value)=>{
                let [fontSize, options] = Array.isArray(value) ? value : [
                    value
                ];
                let { lineHeight , letterSpacing  } = (0, _isPlainObject).default(options) ? options : {
                    lineHeight: options
                };
                return {
                    'font-size': fontSize,
                    ...lineHeight === undefined ? {} : {
                        'line-height': lineHeight
                    },
                    ...letterSpacing === undefined ? {} : {
                        'letter-spacing': letterSpacing
                    }
                };
            }
        }, {
            values: theme('fontSize'),
            type: [
                'absolute-size',
                'relative-size',
                'length',
                'percentage'
            ]
        });
    },
    fontWeight: (0, _createUtilityPlugin).default('fontWeight', [
        [
            'font',
            [
                'fontWeight'
            ]
        ]
    ], {
        type: [
            'lookup',
            'number'
        ]
    }),
    textTransform: ({ addUtilities  })=>{
        addUtilities({
            '.uppercase': {
                'text-transform': 'uppercase'
            },
            '.lowercase': {
                'text-transform': 'lowercase'
            },
            '.capitalize': {
                'text-transform': 'capitalize'
            },
            '.normal-case': {
                'text-transform': 'none'
            }
        });
    },
    fontStyle: ({ addUtilities  })=>{
        addUtilities({
            '.italic': {
                'font-style': 'italic'
            },
            '.not-italic': {
                'font-style': 'normal'
            }
        });
    },
    fontVariantNumeric: ({ addDefaults , addUtilities  })=>{
        let cssFontVariantNumericValue = 'var(--tw-ordinal) var(--tw-slashed-zero) var(--tw-numeric-figure) var(--tw-numeric-spacing) var(--tw-numeric-fraction)';
        addDefaults('font-variant-numeric', {
            '--tw-ordinal': ' ',
            '--tw-slashed-zero': ' ',
            '--tw-numeric-figure': ' ',
            '--tw-numeric-spacing': ' ',
            '--tw-numeric-fraction': ' '
        });
        addUtilities({
            '.normal-nums': {
                'font-variant-numeric': 'normal'
            },
            '.ordinal': {
                '@defaults font-variant-numeric': {},
                '--tw-ordinal': 'ordinal',
                'font-variant-numeric': cssFontVariantNumericValue
            },
            '.slashed-zero': {
                '@defaults font-variant-numeric': {},
                '--tw-slashed-zero': 'slashed-zero',
                'font-variant-numeric': cssFontVariantNumericValue
            },
            '.lining-nums': {
                '@defaults font-variant-numeric': {},
                '--tw-numeric-figure': 'lining-nums',
                'font-variant-numeric': cssFontVariantNumericValue
            },
            '.oldstyle-nums': {
                '@defaults font-variant-numeric': {},
                '--tw-numeric-figure': 'oldstyle-nums',
                'font-variant-numeric': cssFontVariantNumericValue
            },
            '.proportional-nums': {
                '@defaults font-variant-numeric': {},
                '--tw-numeric-spacing': 'proportional-nums',
                'font-variant-numeric': cssFontVariantNumericValue
            },
            '.tabular-nums': {
                '@defaults font-variant-numeric': {},
                '--tw-numeric-spacing': 'tabular-nums',
                'font-variant-numeric': cssFontVariantNumericValue
            },
            '.diagonal-fractions': {
                '@defaults font-variant-numeric': {},
                '--tw-numeric-fraction': 'diagonal-fractions',
                'font-variant-numeric': cssFontVariantNumericValue
            },
            '.stacked-fractions': {
                '@defaults font-variant-numeric': {},
                '--tw-numeric-fraction': 'stacked-fractions',
                'font-variant-numeric': cssFontVariantNumericValue
            }
        });
    },
    lineHeight: (0, _createUtilityPlugin).default('lineHeight', [
        [
            'leading',
            [
                'lineHeight'
            ]
        ]
    ]),
    letterSpacing: (0, _createUtilityPlugin).default('letterSpacing', [
        [
            'tracking',
            [
                'letterSpacing'
            ]
        ]
    ], {
        supportsNegativeValues: true
    }),
    textColor: ({ matchUtilities , theme , corePlugins: corePlugins4  })=>{
        matchUtilities({
            text: (value)=>{
                if (!corePlugins4('textOpacity')) {
                    return {
                        color: (0, _toColorValue).default(value)
                    };
                }
                return (0, _withAlphaVariable).default({
                    color: value,
                    property: 'color',
                    variable: '--tw-text-opacity'
                });
            }
        }, {
            values: (0, _flattenColorPalette).default(theme('textColor')),
            type: 'color'
        });
    },
    textOpacity: (0, _createUtilityPlugin).default('textOpacity', [
        [
            'text-opacity',
            [
                '--tw-text-opacity'
            ]
        ]
    ]),
    textDecoration: ({ addUtilities  })=>{
        addUtilities({
            '.underline': {
                'text-decoration-line': 'underline'
            },
            '.overline': {
                'text-decoration-line': 'overline'
            },
            '.line-through': {
                'text-decoration-line': 'line-through'
            },
            '.no-underline': {
                'text-decoration-line': 'none'
            }
        });
    },
    textDecorationColor: ({ matchUtilities , theme  })=>{
        matchUtilities({
            decoration: (value)=>{
                return {
                    'text-decoration-color': (0, _toColorValue).default(value)
                };
            }
        }, {
            values: (0, _flattenColorPalette).default(theme('textDecorationColor')),
            type: [
                'color'
            ]
        });
    },
    textDecorationStyle: ({ addUtilities  })=>{
        addUtilities({
            '.decoration-solid': {
                'text-decoration-style': 'solid'
            },
            '.decoration-double': {
                'text-decoration-style': 'double'
            },
            '.decoration-dotted': {
                'text-decoration-style': 'dotted'
            },
            '.decoration-dashed': {
                'text-decoration-style': 'dashed'
            },
            '.decoration-wavy': {
                'text-decoration-style': 'wavy'
            }
        });
    },
    textDecorationThickness: (0, _createUtilityPlugin).default('textDecorationThickness', [
        [
            'decoration',
            [
                'text-decoration-thickness'
            ]
        ]
    ], {
        type: [
            'length',
            'percentage'
        ]
    }),
    textUnderlineOffset: (0, _createUtilityPlugin).default('textUnderlineOffset', [
        [
            'underline-offset',
            [
                'text-underline-offset'
            ]
        ]
    ], {
        type: [
            'length',
            'percentage'
        ]
    }),
    fontSmoothing: ({ addUtilities  })=>{
        addUtilities({
            '.antialiased': {
                '-webkit-font-smoothing': 'antialiased',
                '-moz-osx-font-smoothing': 'grayscale'
            },
            '.subpixel-antialiased': {
                '-webkit-font-smoothing': 'auto',
                '-moz-osx-font-smoothing': 'auto'
            }
        });
    },
    placeholderColor: ({ matchUtilities , theme , corePlugins: corePlugins5  })=>{
        matchUtilities({
            placeholder: (value)=>{
                if (!corePlugins5('placeholderOpacity')) {
                    return {
                        '&::placeholder': {
                            color: (0, _toColorValue).default(value)
                        }
                    };
                }
                return {
                    '&::placeholder': (0, _withAlphaVariable).default({
                        color: value,
                        property: 'color',
                        variable: '--tw-placeholder-opacity'
                    })
                };
            }
        }, {
            values: (0, _flattenColorPalette).default(theme('placeholderColor')),
            type: [
                'color',
                'any'
            ]
        });
    },
    placeholderOpacity: ({ matchUtilities , theme  })=>{
        matchUtilities({
            'placeholder-opacity': (value)=>{
                return {
                    ['&::placeholder']: {
                        '--tw-placeholder-opacity': value
                    }
                };
            }
        }, {
            values: theme('placeholderOpacity')
        });
    },
    caretColor: ({ matchUtilities , theme  })=>{
        matchUtilities({
            caret: (value)=>{
                return {
                    'caret-color': (0, _toColorValue).default(value)
                };
            }
        }, {
            values: (0, _flattenColorPalette).default(theme('caretColor')),
            type: [
                'color',
                'any'
            ]
        });
    },
    accentColor: ({ matchUtilities , theme  })=>{
        matchUtilities({
            accent: (value)=>{
                return {
                    'accent-color': (0, _toColorValue).default(value)
                };
            }
        }, {
            values: (0, _flattenColorPalette).default(theme('accentColor')),
            type: [
                'color',
                'any'
            ]
        });
    },
    opacity: (0, _createUtilityPlugin).default('opacity', [
        [
            'opacity',
            [
                'opacity'
            ]
        ]
    ]),
    backgroundBlendMode: ({ addUtilities  })=>{
        addUtilities({
            '.bg-blend-normal': {
                'background-blend-mode': 'normal'
            },
            '.bg-blend-multiply': {
                'background-blend-mode': 'multiply'
            },
            '.bg-blend-screen': {
                'background-blend-mode': 'screen'
            },
            '.bg-blend-overlay': {
                'background-blend-mode': 'overlay'
            },
            '.bg-blend-darken': {
                'background-blend-mode': 'darken'
            },
            '.bg-blend-lighten': {
                'background-blend-mode': 'lighten'
            },
            '.bg-blend-color-dodge': {
                'background-blend-mode': 'color-dodge'
            },
            '.bg-blend-color-burn': {
                'background-blend-mode': 'color-burn'
            },
            '.bg-blend-hard-light': {
                'background-blend-mode': 'hard-light'
            },
            '.bg-blend-soft-light': {
                'background-blend-mode': 'soft-light'
            },
            '.bg-blend-difference': {
                'background-blend-mode': 'difference'
            },
            '.bg-blend-exclusion': {
                'background-blend-mode': 'exclusion'
            },
            '.bg-blend-hue': {
                'background-blend-mode': 'hue'
            },
            '.bg-blend-saturation': {
                'background-blend-mode': 'saturation'
            },
            '.bg-blend-color': {
                'background-blend-mode': 'color'
            },
            '.bg-blend-luminosity': {
                'background-blend-mode': 'luminosity'
            }
        });
    },
    mixBlendMode: ({ addUtilities  })=>{
        addUtilities({
            '.mix-blend-normal': {
                'mix-blend-mode': 'normal'
            },
            '.mix-blend-multiply': {
                'mix-blend-mode': 'multiply'
            },
            '.mix-blend-screen': {
                'mix-blend-mode': 'screen'
            },
            '.mix-blend-overlay': {
                'mix-blend-mode': 'overlay'
            },
            '.mix-blend-darken': {
                'mix-blend-mode': 'darken'
            },
            '.mix-blend-lighten': {
                'mix-blend-mode': 'lighten'
            },
            '.mix-blend-color-dodge': {
                'mix-blend-mode': 'color-dodge'
            },
            '.mix-blend-color-burn': {
                'mix-blend-mode': 'color-burn'
            },
            '.mix-blend-hard-light': {
                'mix-blend-mode': 'hard-light'
            },
            '.mix-blend-soft-light': {
                'mix-blend-mode': 'soft-light'
            },
            '.mix-blend-difference': {
                'mix-blend-mode': 'difference'
            },
            '.mix-blend-exclusion': {
                'mix-blend-mode': 'exclusion'
            },
            '.mix-blend-hue': {
                'mix-blend-mode': 'hue'
            },
            '.mix-blend-saturation': {
                'mix-blend-mode': 'saturation'
            },
            '.mix-blend-color': {
                'mix-blend-mode': 'color'
            },
            '.mix-blend-luminosity': {
                'mix-blend-mode': 'luminosity'
            }
        });
    },
    boxShadow: (()=>{
        let transformValue = (0, _transformThemeValue).default('boxShadow');
        let defaultBoxShadow = [
            `var(--tw-ring-offset-shadow, 0 0 #0000)`,
            `var(--tw-ring-shadow, 0 0 #0000)`,
            `var(--tw-shadow)`, 
        ].join(', ');
        return function({ matchUtilities , addDefaults , theme  }) {
            addDefaults(' box-shadow', {
                '--tw-ring-offset-shadow': '0 0 #0000',
                '--tw-ring-shadow': '0 0 #0000',
                '--tw-shadow': '0 0 #0000',
                '--tw-shadow-colored': '0 0 #0000'
            });
            matchUtilities({
                shadow: (value)=>{
                    value = transformValue(value);
                    let ast = (0, _parseBoxShadowValue).parseBoxShadowValue(value);
                    for (let shadow of ast){
                        // Don't override color if the whole shadow is a variable
                        if (!shadow.valid) {
                            continue;
                        }
                        shadow.color = 'var(--tw-shadow-color)';
                    }
                    return {
                        '@defaults box-shadow': {},
                        '--tw-shadow': value === 'none' ? '0 0 #0000' : value,
                        '--tw-shadow-colored': value === 'none' ? '0 0 #0000' : (0, _parseBoxShadowValue).formatBoxShadowValue(ast),
                        'box-shadow': defaultBoxShadow
                    };
                }
            }, {
                values: theme('boxShadow'),
                type: [
                    'shadow'
                ]
            });
        };
    })(),
    boxShadowColor: ({ matchUtilities , theme  })=>{
        matchUtilities({
            shadow: (value)=>{
                return {
                    '--tw-shadow-color': (0, _toColorValue).default(value),
                    '--tw-shadow': 'var(--tw-shadow-colored)'
                };
            }
        }, {
            values: (0, _flattenColorPalette).default(theme('boxShadowColor')),
            type: [
                'color'
            ]
        });
    },
    outlineStyle: ({ addUtilities  })=>{
        addUtilities({
            '.outline-none': {
                outline: '2px solid transparent',
                'outline-offset': '2px'
            },
            '.outline': {
                'outline-style': 'solid'
            },
            '.outline-dashed': {
                'outline-style': 'dashed'
            },
            '.outline-dotted': {
                'outline-style': 'dotted'
            },
            '.outline-double': {
                'outline-style': 'double'
            },
            '.outline-hidden': {
                'outline-style': 'hidden'
            }
        });
    },
    outlineWidth: (0, _createUtilityPlugin).default('outlineWidth', [
        [
            'outline',
            [
                'outline-width'
            ]
        ]
    ], {
        type: [
            'length',
            'number',
            'percentage'
        ]
    }),
    outlineOffset: (0, _createUtilityPlugin).default('outlineOffset', [
        [
            'outline-offset',
            [
                'outline-offset'
            ]
        ]
    ], {
        type: [
            'length',
            'number',
            'percentage'
        ]
    }),
    outlineColor: ({ matchUtilities , theme  })=>{
        matchUtilities({
            outline: (value)=>{
                return {
                    'outline-color': (0, _toColorValue).default(value)
                };
            }
        }, {
            values: (0, _flattenColorPalette).default(theme('outlineColor')),
            type: [
                'color'
            ]
        });
    },
    ringWidth: ({ matchUtilities , addDefaults , addUtilities , theme  })=>{
        let ringOpacityDefault = theme('ringOpacity.DEFAULT', '0.5');
        let ringColorDefault = (0, _withAlphaVariable).withAlphaValue(theme('ringColor.DEFAULT'), ringOpacityDefault, `rgb(147 197 253 / ${ringOpacityDefault})`);
        addDefaults('ring-width', {
            '--tw-ring-inset': ' ',
            '--tw-ring-offset-width': theme('ringOffsetWidth.DEFAULT', '0px'),
            '--tw-ring-offset-color': theme('ringOffsetColor.DEFAULT', '#fff'),
            '--tw-ring-color': ringColorDefault,
            '--tw-ring-offset-shadow': '0 0 #0000',
            '--tw-ring-shadow': '0 0 #0000',
            '--tw-shadow': '0 0 #0000',
            '--tw-shadow-colored': '0 0 #0000'
        });
        matchUtilities({
            ring: (value)=>{
                return {
                    '@defaults ring-width': {},
                    '--tw-ring-offset-shadow': `var(--tw-ring-inset) 0 0 0 var(--tw-ring-offset-width) var(--tw-ring-offset-color)`,
                    '--tw-ring-shadow': `var(--tw-ring-inset) 0 0 0 calc(${value} + var(--tw-ring-offset-width)) var(--tw-ring-color)`,
                    'box-shadow': [
                        `var(--tw-ring-offset-shadow)`,
                        `var(--tw-ring-shadow)`,
                        `var(--tw-shadow, 0 0 #0000)`, 
                    ].join(', ')
                };
            }
        }, {
            values: theme('ringWidth'),
            type: 'length'
        });
        addUtilities({
            '.ring-inset': {
                '@defaults ring-width': {},
                '--tw-ring-inset': 'inset'
            }
        });
    },
    ringColor: ({ matchUtilities , theme  })=>{
        matchUtilities({
            ring: (value)=>{
                return (0, _withAlphaVariable).default({
                    color: value,
                    property: '--tw-ring-color',
                    variable: '--tw-ring-opacity'
                });
            }
        }, {
            values: Object.fromEntries(Object.entries((0, _flattenColorPalette).default(theme('ringColor'))).filter(([modifier])=>modifier !== 'DEFAULT'
            )),
            type: 'color'
        });
    },
    ringOpacity: (0, _createUtilityPlugin).default('ringOpacity', [
        [
            'ring-opacity',
            [
                '--tw-ring-opacity'
            ]
        ]
    ], {
        filterDefault: true
    }),
    ringOffsetWidth: (0, _createUtilityPlugin).default('ringOffsetWidth', [
        [
            'ring-offset',
            [
                '--tw-ring-offset-width'
            ]
        ]
    ], {
        type: 'length'
    }),
    ringOffsetColor: ({ matchUtilities , theme  })=>{
        matchUtilities({
            'ring-offset': (value)=>{
                return {
                    '--tw-ring-offset-color': (0, _toColorValue).default(value)
                };
            }
        }, {
            values: (0, _flattenColorPalette).default(theme('ringOffsetColor')),
            type: 'color'
        });
    },
    blur: ({ matchUtilities , theme  })=>{
        matchUtilities({
            blur: (value)=>{
                return {
                    '--tw-blur': `blur(${value})`,
                    '@defaults filter': {},
                    filter: cssFilterValue
                };
            }
        }, {
            values: theme('blur')
        });
    },
    brightness: ({ matchUtilities , theme  })=>{
        matchUtilities({
            brightness: (value)=>{
                return {
                    '--tw-brightness': `brightness(${value})`,
                    '@defaults filter': {},
                    filter: cssFilterValue
                };
            }
        }, {
            values: theme('brightness')
        });
    },
    contrast: ({ matchUtilities , theme  })=>{
        matchUtilities({
            contrast: (value)=>{
                return {
                    '--tw-contrast': `contrast(${value})`,
                    '@defaults filter': {},
                    filter: cssFilterValue
                };
            }
        }, {
            values: theme('contrast')
        });
    },
    dropShadow: ({ matchUtilities , theme  })=>{
        matchUtilities({
            'drop-shadow': (value)=>{
                return {
                    '--tw-drop-shadow': Array.isArray(value) ? value.map((v)=>`drop-shadow(${v})`
                    ).join(' ') : `drop-shadow(${value})`,
                    '@defaults filter': {},
                    filter: cssFilterValue
                };
            }
        }, {
            values: theme('dropShadow')
        });
    },
    grayscale: ({ matchUtilities , theme  })=>{
        matchUtilities({
            grayscale: (value)=>{
                return {
                    '--tw-grayscale': `grayscale(${value})`,
                    '@defaults filter': {},
                    filter: cssFilterValue
                };
            }
        }, {
            values: theme('grayscale')
        });
    },
    hueRotate: ({ matchUtilities , theme  })=>{
        matchUtilities({
            'hue-rotate': (value)=>{
                return {
                    '--tw-hue-rotate': `hue-rotate(${value})`,
                    '@defaults filter': {},
                    filter: cssFilterValue
                };
            }
        }, {
            values: theme('hueRotate'),
            supportsNegativeValues: true
        });
    },
    invert: ({ matchUtilities , theme  })=>{
        matchUtilities({
            invert: (value)=>{
                return {
                    '--tw-invert': `invert(${value})`,
                    '@defaults filter': {},
                    filter: cssFilterValue
                };
            }
        }, {
            values: theme('invert')
        });
    },
    saturate: ({ matchUtilities , theme  })=>{
        matchUtilities({
            saturate: (value)=>{
                return {
                    '--tw-saturate': `saturate(${value})`,
                    '@defaults filter': {},
                    filter: cssFilterValue
                };
            }
        }, {
            values: theme('saturate')
        });
    },
    sepia: ({ matchUtilities , theme  })=>{
        matchUtilities({
            sepia: (value)=>{
                return {
                    '--tw-sepia': `sepia(${value})`,
                    '@defaults filter': {},
                    filter: cssFilterValue
                };
            }
        }, {
            values: theme('sepia')
        });
    },
    filter: ({ addDefaults , addUtilities  })=>{
        addDefaults('filter', {
            '--tw-blur': ' ',
            '--tw-brightness': ' ',
            '--tw-contrast': ' ',
            '--tw-grayscale': ' ',
            '--tw-hue-rotate': ' ',
            '--tw-invert': ' ',
            '--tw-saturate': ' ',
            '--tw-sepia': ' ',
            '--tw-drop-shadow': ' '
        });
        addUtilities({
            '.filter': {
                '@defaults filter': {},
                filter: cssFilterValue
            },
            '.filter-none': {
                filter: 'none'
            }
        });
    },
    backdropBlur: ({ matchUtilities , theme  })=>{
        matchUtilities({
            'backdrop-blur': (value)=>{
                return {
                    '--tw-backdrop-blur': `blur(${value})`,
                    '@defaults backdrop-filter': {},
                    'backdrop-filter': cssBackdropFilterValue
                };
            }
        }, {
            values: theme('backdropBlur')
        });
    },
    backdropBrightness: ({ matchUtilities , theme  })=>{
        matchUtilities({
            'backdrop-brightness': (value)=>{
                return {
                    '--tw-backdrop-brightness': `brightness(${value})`,
                    '@defaults backdrop-filter': {},
                    'backdrop-filter': cssBackdropFilterValue
                };
            }
        }, {
            values: theme('backdropBrightness')
        });
    },
    backdropContrast: ({ matchUtilities , theme  })=>{
        matchUtilities({
            'backdrop-contrast': (value)=>{
                return {
                    '--tw-backdrop-contrast': `contrast(${value})`,
                    '@defaults backdrop-filter': {},
                    'backdrop-filter': cssBackdropFilterValue
                };
            }
        }, {
            values: theme('backdropContrast')
        });
    },
    backdropGrayscale: ({ matchUtilities , theme  })=>{
        matchUtilities({
            'backdrop-grayscale': (value)=>{
                return {
                    '--tw-backdrop-grayscale': `grayscale(${value})`,
                    '@defaults backdrop-filter': {},
                    'backdrop-filter': cssBackdropFilterValue
                };
            }
        }, {
            values: theme('backdropGrayscale')
        });
    },
    backdropHueRotate: ({ matchUtilities , theme  })=>{
        matchUtilities({
            'backdrop-hue-rotate': (value)=>{
                return {
                    '--tw-backdrop-hue-rotate': `hue-rotate(${value})`,
                    '@defaults backdrop-filter': {},
                    'backdrop-filter': cssBackdropFilterValue
                };
            }
        }, {
            values: theme('backdropHueRotate'),
            supportsNegativeValues: true
        });
    },
    backdropInvert: ({ matchUtilities , theme  })=>{
        matchUtilities({
            'backdrop-invert': (value)=>{
                return {
                    '--tw-backdrop-invert': `invert(${value})`,
                    '@defaults backdrop-filter': {},
                    'backdrop-filter': cssBackdropFilterValue
                };
            }
        }, {
            values: theme('backdropInvert')
        });
    },
    backdropOpacity: ({ matchUtilities , theme  })=>{
        matchUtilities({
            'backdrop-opacity': (value)=>{
                return {
                    '--tw-backdrop-opacity': `opacity(${value})`,
                    '@defaults backdrop-filter': {},
                    'backdrop-filter': cssBackdropFilterValue
                };
            }
        }, {
            values: theme('backdropOpacity')
        });
    },
    backdropSaturate: ({ matchUtilities , theme  })=>{
        matchUtilities({
            'backdrop-saturate': (value)=>{
                return {
                    '--tw-backdrop-saturate': `saturate(${value})`,
                    '@defaults backdrop-filter': {},
                    'backdrop-filter': cssBackdropFilterValue
                };
            }
        }, {
            values: theme('backdropSaturate')
        });
    },
    backdropSepia: ({ matchUtilities , theme  })=>{
        matchUtilities({
            'backdrop-sepia': (value)=>{
                return {
                    '--tw-backdrop-sepia': `sepia(${value})`,
                    '@defaults backdrop-filter': {},
                    'backdrop-filter': cssBackdropFilterValue
                };
            }
        }, {
            values: theme('backdropSepia')
        });
    },
    backdropFilter: ({ addDefaults , addUtilities  })=>{
        addDefaults('backdrop-filter', {
            '--tw-backdrop-blur': ' ',
            '--tw-backdrop-brightness': ' ',
            '--tw-backdrop-contrast': ' ',
            '--tw-backdrop-grayscale': ' ',
            '--tw-backdrop-hue-rotate': ' ',
            '--tw-backdrop-invert': ' ',
            '--tw-backdrop-opacity': ' ',
            '--tw-backdrop-saturate': ' ',
            '--tw-backdrop-sepia': ' '
        });
        addUtilities({
            '.backdrop-filter': {
                '@defaults backdrop-filter': {},
                'backdrop-filter': cssBackdropFilterValue
            },
            '.backdrop-filter-none': {
                'backdrop-filter': 'none'
            }
        });
    },
    transitionProperty: ({ matchUtilities , theme  })=>{
        let defaultTimingFunction = theme('transitionTimingFunction.DEFAULT');
        let defaultDuration = theme('transitionDuration.DEFAULT');
        matchUtilities({
            transition: (value)=>{
                return {
                    'transition-property': value,
                    ...value === 'none' ? {} : {
                        'transition-timing-function': defaultTimingFunction,
                        'transition-duration': defaultDuration
                    }
                };
            }
        }, {
            values: theme('transitionProperty')
        });
    },
    transitionDelay: (0, _createUtilityPlugin).default('transitionDelay', [
        [
            'delay',
            [
                'transitionDelay'
            ]
        ]
    ]),
    transitionDuration: (0, _createUtilityPlugin).default('transitionDuration', [
        [
            'duration',
            [
                'transitionDuration'
            ]
        ]
    ], {
        filterDefault: true
    }),
    transitionTimingFunction: (0, _createUtilityPlugin).default('transitionTimingFunction', [
        [
            'ease',
            [
                'transitionTimingFunction'
            ]
        ]
    ], {
        filterDefault: true
    }),
    willChange: (0, _createUtilityPlugin).default('willChange', [
        [
            'will-change',
            [
                'will-change'
            ]
        ]
    ]),
    content: (0, _createUtilityPlugin).default('content', [
        [
            'content',
            [
                '--tw-content',
                [
                    'content',
                    'var(--tw-content)'
                ]
            ]
        ], 
    ])
};
exports.corePlugins = corePlugins;