tailwindcss 0.0.0-insiders.eb3fe8f → 0.0.0-insiders.ebc1c7a

package/CHANGELOG.md

@@ -13,12 +13,50 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Throw when trying to `@apply` the `group` class ([#4666](https://github.com/tailwindlabs/tailwindcss/pull/4666))
 - Remove dependency on `modern-normalize`, inline and consolidate with Preflight ([#5358](https://github.com/tailwindlabs/tailwindcss/pull/5358))
 - Enable extended color palette by default with updated color names ([#5384](https://github.com/tailwindlabs/tailwindcss/pull/5384))
+- Move `vertical-align` values to config file instead of hard-coding ([#5487](https://github.com/tailwindlabs/tailwindcss/pull/5487))
 
 ### Added
 
 - Add native `aspect-ratio` utilities ([#5359](https://github.com/tailwindlabs/tailwindcss/pull/5359))
 - Unify config callback helpers into single object ([#5382](https://github.com/tailwindlabs/tailwindcss/pull/5382))
 - Preserve original color format when adding opacity whenever possible ([#5154](https://github.com/tailwindlabs/tailwindcss/pull/5154))
+- Add `scroll-behavior` utilities ([#5388](https://github.com/tailwindlabs/tailwindcss/pull/5388))
+- Add `border-hidden` utility ([#5485](https://github.com/tailwindlabs/tailwindcss/pull/5485))
+- Add `align-sub` and `align-super` utilities by default ([#5486](https://github.com/tailwindlabs/tailwindcss/pull/5486))
+
+### Fixed
+
+- Fix defining colors as functions when color opacity plugins are disabled ([#5470](https://github.com/tailwindlabs/tailwindcss/pull/5470))
+
+## [2.2.15] - 2021-09-10
+
+### Fixed
+
+- Ensure using CLI without `-i` for input file continues to work even though deprecated ([#5464](https://github.com/tailwindlabs/tailwindcss/pull/5464))
+
+## [2.2.14] - 2021-09-08
+
+### Fixed
+
+- Only use `@defaults` in JIT, switch back to `clean-css` in case there's any meaningful differences in the output ([bf248cb](https://github.com/tailwindlabs/tailwindcss/commit/bf248cb0de889d48854fbdd26536f4a492556efd))
+
+## [2.2.13] - 2021-09-08
+
+### Fixed
+
+- Replace `clean-css` with `cssnano` for CDN builds to fix minified builds ([75cc3ca](https://github.com/tailwindlabs/tailwindcss/commit/75cc3ca305aedddc8a85f3df1a420fefad3fb5c4))
+
+## [2.2.12] - 2021-09-08
+
+### Fixed
+
+- Ensure that divide utilities inject a default border color ([#5438](https://github.com/tailwindlabs/tailwindcss/pull/5438))
+
+## [2.2.11] - 2021-09-07
+
+### Fixed
+
+- Rebundle to fix missing CLI peer dependencies
 
 ## [2.2.10] - 2021-09-06
 
@@ -43,13 +81,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Fixed
 
 - Improve accessibility of default link focus styles in Firefox ([#5082](https://github.com/tailwindlabs/tailwindcss/pull/5082))
-- JIT: Fix animation variants corrupting keyframes rules [#5223](https://github.com/tailwindlabs/tailwindcss/pull/5223)
-- JIT: Ignore escaped commas when splitting selectors to apply prefixes [#5239](https://github.com/tailwindlabs/tailwindcss/pull/5239/)
-- Nesting: Maintain PostCSS node sources when handling `@apply` [#5249](https://github.com/tailwindlabs/tailwindcss/pull/5249)
-- JIT: Fix support for animation lists [#5252](https://github.com/tailwindlabs/tailwindcss/pull/5252)
-- JIT: Fix arbitrary value support for `object-position` utilities [#5245](https://github.com/tailwindlabs/tailwindcss/pull/5245)
-- CLI: Abort watcher if stdin is closed to avoid zombie processes [#4997](https://github.com/tailwindlabs/tailwindcss/pull/4997)
-- JIT: Ignore arbitrary values with unbalanced brackets [#5293](https://github.com/tailwindlabs/tailwindcss/pull/5293)
+- JIT: Fix animation variants corrupting keyframes rules ([#5223](https://github.com/tailwindlabs/tailwindcss/pull/5223))
+- JIT: Ignore escaped commas when splitting selectors to apply prefixes ([#5239](https://github.com/tailwindlabs/tailwindcss/pull/5239/))
+- Nesting: Maintain PostCSS node sources when handling `@apply` ([#5249](https://github.com/tailwindlabs/tailwindcss/pull/5249))
+- JIT: Fix support for animation lists ([#5252](https://github.com/tailwindlabs/tailwindcss/pull/5252))
+- JIT: Fix arbitrary value support for `object-position` utilities ([#5245](https://github.com/tailwindlabs/tailwindcss/pull/5245))
+- CLI: Abort watcher if stdin is closed to avoid zombie processes ([#4997](https://github.com/tailwindlabs/tailwindcss/pull/4997))
+- JIT: Ignore arbitrary values with unbalanced brackets ([#5293](https://github.com/tailwindlabs/tailwindcss/pull/5293))
 
 ## [2.2.7] - 2021-07-23
 
@@ -1542,7 +1580,12 @@ No release notes
 
 - Everything!
 
-[unreleased]: https://github.com/tailwindlabs/tailwindcss/compare/v2.2.10...HEAD
+[unreleased]: https://github.com/tailwindlabs/tailwindcss/compare/v2.2.15...HEAD
+[2.2.15]: https://github.com/tailwindlabs/tailwindcss/compare/v2.2.14...v2.2.15
+[2.2.14]: https://github.com/tailwindlabs/tailwindcss/compare/v2.2.13...v2.2.14
+[2.2.13]: https://github.com/tailwindlabs/tailwindcss/compare/v2.2.12...v2.2.13
+[2.2.12]: https://github.com/tailwindlabs/tailwindcss/compare/v2.2.11...v2.2.12
+[2.2.11]: https://github.com/tailwindlabs/tailwindcss/compare/v2.2.10...v2.2.11
 [2.2.10]: https://github.com/tailwindlabs/tailwindcss/compare/v2.2.9...v2.2.10
 [2.2.9]: https://github.com/tailwindlabs/tailwindcss/compare/v2.2.8...v2.2.9
 [2.2.8]: https://github.com/tailwindlabs/tailwindcss/compare/v2.2.7...v2.2.8

package/colors.js

@@ -1,9 +1,13 @@
+const log = require('./lib/util/log').default
+
 let warned = []
 
 function warn({ version, from, to }) {
   if (!warned.includes(from)) {
-    console.log(`warn - As of Tailwind CSS ${version}, \`${from}\` has been renamed to \`${to}\`.`)
-    console.log('warn - Please update your color palette to eliminate this warning.')
+    log.warn([
+      `As of Tailwind CSS ${version}, \`${from}\` has been renamed to \`${to}\`.`,
+      'Please update your color palette to eliminate this warning.',
+    ])
     warned.push(from)
   }
 }

package/lib/cli.js

@@ -380,6 +380,7 @@ async function build() {
 
   if (!input && args['_'][1]) {
     console.error('[deprecation] Running tailwindcss without -i, please provide an input file.');
+    input = args['--input'] = args['_'][1];
   }
 
   if (input && !_fs.default.existsSync(input = _path.default.resolve(input))) {

package/lib/corePluginList.js

@@ -4,5 +4,5 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-var _default = ["preflight", "container", "accessibility", "pointerEvents", "visibility", "position", "inset", "isolation", "zIndex", "order", "gridColumn", "gridColumnStart", "gridColumnEnd", "gridRow", "gridRowStart", "gridRowEnd", "float", "clear", "margin", "boxSizing", "display", "aspectRatio", "height", "maxHeight", "minHeight", "width", "minWidth", "maxWidth", "flex", "flexShrink", "flexGrow", "tableLayout", "borderCollapse", "transformOrigin", "translate", "rotate", "skew", "scale", "transform", "animation", "cursor", "userSelect", "resize", "listStylePosition", "listStyleType", "appearance", "gridAutoColumns", "gridAutoFlow", "gridAutoRows", "gridTemplateColumns", "gridTemplateRows", "flexDirection", "flexWrap", "placeContent", "placeItems", "alignContent", "alignItems", "justifyContent", "justifyItems", "gap", "space", "divideWidth", "divideStyle", "divideColor", "divideOpacity", "placeSelf", "alignSelf", "justifySelf", "overflow", "overscrollBehavior", "textOverflow", "whitespace", "wordBreak", "borderRadius", "borderWidth", "borderStyle", "borderColor", "borderOpacity", "backgroundColor", "backgroundOpacity", "backgroundImage", "gradientColorStops", "boxDecorationBreak", "backgroundSize", "backgroundAttachment", "backgroundClip", "backgroundPosition", "backgroundRepeat", "backgroundOrigin", "fill", "stroke", "strokeWidth", "objectFit", "objectPosition", "padding", "textAlign", "verticalAlign", "fontFamily", "fontSize", "fontWeight", "textTransform", "fontStyle", "fontVariantNumeric", "lineHeight", "letterSpacing", "textColor", "textOpacity", "textDecoration", "fontSmoothing", "placeholderColor", "placeholderOpacity", "caretColor", "accentColor", "opacity", "backgroundBlendMode", "mixBlendMode", "boxShadow", "outline", "ringWidth", "ringColor", "ringOpacity", "ringOffsetWidth", "ringOffsetColor", "blur", "brightness", "contrast", "dropShadow", "grayscale", "hueRotate", "invert", "saturate", "sepia", "filter", "backdropBlur", "backdropBrightness", "backdropContrast", "backdropGrayscale", "backdropHueRotate", "backdropInvert", "backdropOpacity", "backdropSaturate", "backdropSepia", "backdropFilter", "transitionProperty", "transitionDelay", "transitionDuration", "transitionTimingFunction", "content"];
+var _default = ["preflight", "container", "accessibility", "pointerEvents", "visibility", "position", "inset", "isolation", "zIndex", "order", "gridColumn", "gridColumnStart", "gridColumnEnd", "gridRow", "gridRowStart", "gridRowEnd", "float", "clear", "margin", "boxSizing", "display", "aspectRatio", "height", "maxHeight", "minHeight", "width", "minWidth", "maxWidth", "flex", "flexShrink", "flexGrow", "tableLayout", "borderCollapse", "transformOrigin", "translate", "rotate", "skew", "scale", "transform", "animation", "cursor", "userSelect", "resize", "listStylePosition", "listStyleType", "appearance", "columns", "gridAutoColumns", "gridAutoFlow", "gridAutoRows", "gridTemplateColumns", "gridTemplateRows", "flexDirection", "flexWrap", "placeContent", "placeItems", "alignContent", "alignItems", "justifyContent", "justifyItems", "gap", "space", "divideWidth", "divideStyle", "divideColor", "divideOpacity", "placeSelf", "alignSelf", "justifySelf", "overflow", "overscrollBehavior", "scrollBehavior", "textOverflow", "whitespace", "wordBreak", "borderRadius", "borderWidth", "borderStyle", "borderColor", "borderOpacity", "backgroundColor", "backgroundOpacity", "backgroundImage", "gradientColorStops", "boxDecorationBreak", "backgroundSize", "backgroundAttachment", "backgroundClip", "backgroundPosition", "backgroundRepeat", "backgroundOrigin", "fill", "stroke", "strokeWidth", "objectFit", "objectPosition", "padding", "textAlign", "textIndent", "verticalAlign", "fontFamily", "fontSize", "fontWeight", "textTransform", "fontStyle", "fontVariantNumeric", "lineHeight", "letterSpacing", "textColor", "textOpacity", "textDecoration", "fontSmoothing", "placeholderColor", "placeholderOpacity", "caretColor", "accentColor", "opacity", "backgroundBlendMode", "mixBlendMode", "boxShadow", "outline", "ringWidth", "ringColor", "ringOpacity", "ringOffsetWidth", "ringOffsetColor", "blur", "brightness", "contrast", "dropShadow", "grayscale", "hueRotate", "invert", "saturate", "sepia", "filter", "backdropBlur", "backdropBrightness", "backdropContrast", "backdropGrayscale", "backdropHueRotate", "backdropInvert", "backdropOpacity", "backdropSaturate", "backdropSepia", "backdropFilter", "transitionProperty", "transitionDelay", "transitionDuration", "transitionTimingFunction", "willChange", "content"];
 exports.default = _default;

package/lib/corePlugins.js

@@ -3,18 +3,35 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = void 0;
+exports.strokeWidth = exports.stroke = exports.fill = exports.backgroundOrigin = exports.backgroundRepeat = exports.backgroundPosition = exports.backgroundClip = exports.backgroundAttachment = exports.backgroundSize = exports.boxDecorationBreak = exports.gradientColorStops = exports.backgroundImage = exports.backgroundOpacity = exports.backgroundColor = exports.borderOpacity = exports.borderColor = exports.borderStyle = exports.borderWidth = exports.borderRadius = exports.wordBreak = exports.whitespace = exports.textOverflow = exports.scrollBehavior = exports.overscrollBehavior = exports.overflow = exports.justifySelf = exports.alignSelf = exports.placeSelf = exports.divideOpacity = exports.divideColor = exports.divideStyle = exports.divideWidth = exports.space = exports.gap = exports.justifyItems = exports.justifyContent = exports.alignItems = exports.alignContent = exports.placeItems = exports.placeContent = exports.flexWrap = exports.flexDirection = exports.gridTemplateRows = exports.gridTemplateColumns = exports.gridAutoRows = exports.gridAutoFlow = exports.gridAutoColumns = exports.columns = exports.appearance = exports.listStyleType = exports.listStylePosition = exports.resize = exports.userSelect = exports.cursor = exports.animation = exports.transform = exports.scale = exports.skew = exports.rotate = exports.translate = exports.transformOrigin = exports.borderCollapse = exports.tableLayout = exports.flexGrow = exports.flexShrink = exports.flex = exports.maxWidth = exports.minWidth = exports.width = exports.minHeight = exports.maxHeight = exports.height = exports.aspectRatio = exports.display = exports.boxSizing = exports.margin = exports.clear = exports.float = exports.gridRowEnd = exports.gridRowStart = exports.gridRow = exports.gridColumnEnd = exports.gridColumnStart = exports.gridColumn = exports.order = exports.zIndex = exports.isolation = exports.inset = exports.position = exports.visibility = exports.pointerEvents = exports.accessibility = exports.container = exports.preflight = exports.screenVariants = exports.darkVariants = exports.reducedMotionVariants = exports.directionVariants = exports.pseudoClassVariants = exports.pseudoElementVariants = void 0;
+exports.content = exports.willChange = exports.transitionTimingFunction = exports.transitionDuration = exports.transitionDelay = exports.transitionProperty = exports.backdropFilter = exports.backdropSepia = exports.backdropSaturate = exports.backdropOpacity = exports.backdropInvert = exports.backdropHueRotate = exports.backdropGrayscale = exports.backdropContrast = exports.backdropBrightness = exports.backdropBlur = exports.filter = exports.sepia = exports.saturate = exports.invert = exports.hueRotate = exports.grayscale = exports.dropShadow = exports.contrast = exports.brightness = exports.blur = exports.ringOffsetColor = exports.ringOffsetWidth = exports.ringOpacity = exports.ringColor = exports.ringWidth = exports.outline = exports.boxShadow = exports.mixBlendMode = exports.backgroundBlendMode = exports.opacity = exports.accentColor = exports.caretColor = exports.placeholderOpacity = exports.placeholderColor = exports.fontSmoothing = exports.textDecoration = exports.textOpacity = exports.textColor = exports.letterSpacing = exports.lineHeight = exports.fontVariantNumeric = exports.fontStyle = exports.textTransform = exports.fontWeight = exports.fontSize = exports.fontFamily = exports.verticalAlign = exports.textIndent = exports.textAlign = exports.padding = exports.objectPosition = exports.objectFit = void 0;
+
+var _fs = _interopRequireDefault(require("fs"));
 
 var _postcss = _interopRequireDefault(require("postcss"));
 
-var corePlugins = _interopRequireWildcard(require("./plugins"));
+var _createUtilityPlugin = _interopRequireDefault(require("./util/createUtilityPlugin"));
 
 var _buildMediaQuery = _interopRequireDefault(require("./util/buildMediaQuery"));
 
 var _prefixSelector = _interopRequireDefault(require("./util/prefixSelector"));
 
+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 _pluginUtils = require("./util/pluginUtils");
 
+var _package = _interopRequireDefault(require("../package.json"));
+
 var _log = _interopRequireDefault(require("./util/log"));
 
 function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
@@ -23,234 +40,2938 @@ function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj &&
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-var _default = {
-  pseudoElementVariants: function ({
-    config,
-    addVariant
-  }) {
-    addVariant('first-letter', (0, _pluginUtils.transformAllSelectors)(selector => {
-      return (0, _pluginUtils.updateAllClasses)(selector, (className, {
-        withPseudo
-      }) => {
-        return withPseudo(`first-letter${config('separator')}${className}`, '::first-letter');
+// Variant plugins
+let pseudoElementVariants = ({
+  config,
+  addVariant
+}) => {
+  addVariant('first-letter', (0, _pluginUtils.transformAllSelectors)(selector => {
+    return (0, _pluginUtils.updateAllClasses)(selector, (className, {
+      withPseudo
+    }) => {
+      return withPseudo(`first-letter${config('separator')}${className}`, '::first-letter');
+    });
+  }));
+  addVariant('first-line', (0, _pluginUtils.transformAllSelectors)(selector => {
+    return (0, _pluginUtils.updateAllClasses)(selector, (className, {
+      withPseudo
+    }) => {
+      return withPseudo(`first-line${config('separator')}${className}`, '::first-line');
+    });
+  }));
+  addVariant('marker', [(0, _pluginUtils.transformAllSelectors)(selector => {
+    let variantSelector = (0, _pluginUtils.updateAllClasses)(selector, className => {
+      return `marker${config('separator')}${className}`;
+    });
+    return `${variantSelector} *::marker`;
+  }), (0, _pluginUtils.transformAllSelectors)(selector => {
+    return (0, _pluginUtils.updateAllClasses)(selector, (className, {
+      withPseudo
+    }) => {
+      return withPseudo(`marker${config('separator')}${className}`, '::marker');
+    });
+  })]);
+  addVariant('selection', [(0, _pluginUtils.transformAllSelectors)(selector => {
+    let variantSelector = (0, _pluginUtils.updateAllClasses)(selector, className => {
+      return `selection${config('separator')}${className}`;
+    });
+    return `${variantSelector} *::selection`;
+  }), (0, _pluginUtils.transformAllSelectors)(selector => {
+    return (0, _pluginUtils.updateAllClasses)(selector, (className, {
+      withPseudo
+    }) => {
+      return withPseudo(`selection${config('separator')}${className}`, '::selection');
+    });
+  })]);
+  addVariant('before', (0, _pluginUtils.transformAllSelectors)(selector => {
+    return (0, _pluginUtils.updateAllClasses)(selector, (className, {
+      withPseudo
+    }) => {
+      return withPseudo(`before${config('separator')}${className}`, '::before');
+    });
+  }, {
+    withRule: rule => {
+      let foundContent = false;
+      rule.walkDecls('content', () => {
+        foundContent = true;
       });
-    }));
-    addVariant('first-line', (0, _pluginUtils.transformAllSelectors)(selector => {
-      return (0, _pluginUtils.updateAllClasses)(selector, (className, {
-        withPseudo
-      }) => {
-        return withPseudo(`first-line${config('separator')}${className}`, '::first-line');
+
+      if (!foundContent) {
+        rule.prepend(_postcss.default.decl({
+          prop: 'content',
+          value: '""'
+        }));
+      }
+    }
+  }));
+  addVariant('after', (0, _pluginUtils.transformAllSelectors)(selector => {
+    return (0, _pluginUtils.updateAllClasses)(selector, (className, {
+      withPseudo
+    }) => {
+      return withPseudo(`after${config('separator')}${className}`, '::after');
+    });
+  }, {
+    withRule: rule => {
+      let foundContent = false;
+      rule.walkDecls('content', () => {
+        foundContent = true;
       });
+
+      if (!foundContent) {
+        rule.prepend(_postcss.default.decl({
+          prop: 'content',
+          value: '""'
+        }));
+      }
+    }
+  }));
+};
+
+exports.pseudoElementVariants = pseudoElementVariants;
+
+let pseudoClassVariants = ({
+  config,
+  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', 'target', // 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'];
+
+  for (let variant of pseudoVariants) {
+    let [variantName, state] = Array.isArray(variant) ? variant : [variant, variant];
+    addVariant(variantName, (0, _pluginUtils.transformAllClasses)((className, {
+      withPseudo
+    }) => {
+      return withPseudo(`${variantName}${config('separator')}${className}`, `:${state}`);
     }));
-    addVariant('marker', [(0, _pluginUtils.transformAllSelectors)(selector => {
-      let variantSelector = (0, _pluginUtils.updateAllClasses)(selector, className => {
-        return `marker${config('separator')}${className}`;
-      });
-      return `${variantSelector} *::marker`;
-    }), (0, _pluginUtils.transformAllSelectors)(selector => {
-      return (0, _pluginUtils.updateAllClasses)(selector, (className, {
-        withPseudo
-      }) => {
-        return withPseudo(`marker${config('separator')}${className}`, '::marker');
-      });
-    })]);
-    addVariant('selection', [(0, _pluginUtils.transformAllSelectors)(selector => {
+  }
+
+  let groupMarker = (0, _prefixSelector.default)(config('prefix'), '.group');
+
+  for (let variant of pseudoVariants) {
+    let [variantName, state] = Array.isArray(variant) ? variant : [variant, variant];
+    let groupVariantName = `group-${variantName}`;
+    addVariant(groupVariantName, (0, _pluginUtils.transformAllSelectors)(selector => {
       let variantSelector = (0, _pluginUtils.updateAllClasses)(selector, className => {
-        return `selection${config('separator')}${className}`;
-      });
-      return `${variantSelector} *::selection`;
-    }), (0, _pluginUtils.transformAllSelectors)(selector => {
-      return (0, _pluginUtils.updateAllClasses)(selector, (className, {
-        withPseudo
-      }) => {
-        return withPseudo(`selection${config('separator')}${className}`, '::selection');
+        if (`.${className}` === groupMarker) return className;
+        return `${groupVariantName}${config('separator')}${className}`;
       });
-    })]);
-    addVariant('before', (0, _pluginUtils.transformAllSelectors)(selector => {
-      return (0, _pluginUtils.updateAllClasses)(selector, (className, {
-        withPseudo
-      }) => {
-        return withPseudo(`before${config('separator')}${className}`, '::before');
-      });
-    }, {
-      withRule: rule => {
-        let foundContent = false;
-        rule.walkDecls('content', () => {
-          foundContent = true;
-        });
-
-        if (!foundContent) {
-          rule.prepend(_postcss.default.decl({
-            prop: 'content',
-            value: '""'
-          }));
-        }
+
+      if (variantSelector === selector) {
+        return null;
       }
+
+      return (0, _pluginUtils.applyPseudoToMarker)(variantSelector, groupMarker, state, (marker, selector) => `${marker} ${selector}`);
     }));
-    addVariant('after', (0, _pluginUtils.transformAllSelectors)(selector => {
-      return (0, _pluginUtils.updateAllClasses)(selector, (className, {
-        withPseudo
-      }) => {
-        return withPseudo(`after${config('separator')}${className}`, '::after');
+  }
+
+  let peerMarker = (0, _prefixSelector.default)(config('prefix'), '.peer');
+
+  for (let variant of pseudoVariants) {
+    let [variantName, state] = Array.isArray(variant) ? variant : [variant, variant];
+    let peerVariantName = `peer-${variantName}`;
+    addVariant(peerVariantName, (0, _pluginUtils.transformAllSelectors)(selector => {
+      let variantSelector = (0, _pluginUtils.updateAllClasses)(selector, className => {
+        if (`.${className}` === peerMarker) return className;
+        return `${peerVariantName}${config('separator')}${className}`;
       });
-    }, {
-      withRule: rule => {
-        let foundContent = false;
-        rule.walkDecls('content', () => {
-          foundContent = true;
-        });
-
-        if (!foundContent) {
-          rule.prepend(_postcss.default.decl({
-            prop: 'content',
-            value: '""'
-          }));
-        }
+
+      if (variantSelector === selector) {
+        return null;
       }
+
+      return (0, _pluginUtils.applyPseudoToMarker)(variantSelector, peerMarker, state, (marker, selector) => selector.trim().startsWith('~') ? `${marker}${selector}` : `${marker} ~ ${selector}`);
     }));
-  },
-  pseudoClassVariants: function ({
-    config,
-    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', 'target', // 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'];
-
-    for (let variant of pseudoVariants) {
-      let [variantName, state] = Array.isArray(variant) ? variant : [variant, variant];
-      addVariant(variantName, (0, _pluginUtils.transformAllClasses)((className, {
-        withPseudo
-      }) => {
-        return withPseudo(`${variantName}${config('separator')}${className}`, `:${state}`);
-      }));
-    }
-
-    let groupMarker = (0, _prefixSelector.default)(config('prefix'), '.group');
-
-    for (let variant of pseudoVariants) {
-      let [variantName, state] = Array.isArray(variant) ? variant : [variant, variant];
-      let groupVariantName = `group-${variantName}`;
-      addVariant(groupVariantName, (0, _pluginUtils.transformAllSelectors)(selector => {
-        let variantSelector = (0, _pluginUtils.updateAllClasses)(selector, className => {
-          if (`.${className}` === groupMarker) return className;
-          return `${groupVariantName}${config('separator')}${className}`;
-        });
-
-        if (variantSelector === selector) {
-          return null;
-        }
+  }
+};
 
-        return (0, _pluginUtils.applyPseudoToMarker)(variantSelector, groupMarker, state, (marker, selector) => `${marker} ${selector}`);
-      }));
-    }
+exports.pseudoClassVariants = pseudoClassVariants;
 
-    let peerMarker = (0, _prefixSelector.default)(config('prefix'), '.peer');
+let directionVariants = ({
+  config,
+  addVariant
+}) => {
+  addVariant('ltr', (0, _pluginUtils.transformAllSelectors)(selector => `[dir="ltr"] ${(0, _pluginUtils.updateAllClasses)(selector, className => `ltr${config('separator')}${className}`)}`));
+  addVariant('rtl', (0, _pluginUtils.transformAllSelectors)(selector => `[dir="rtl"] ${(0, _pluginUtils.updateAllClasses)(selector, className => `rtl${config('separator')}${className}`)}`));
+};
 
-    for (let variant of pseudoVariants) {
-      let [variantName, state] = Array.isArray(variant) ? variant : [variant, variant];
-      let peerVariantName = `peer-${variantName}`;
-      addVariant(peerVariantName, (0, _pluginUtils.transformAllSelectors)(selector => {
-        let variantSelector = (0, _pluginUtils.updateAllClasses)(selector, className => {
-          if (`.${className}` === peerMarker) return className;
-          return `${peerVariantName}${config('separator')}${className}`;
-        });
+exports.directionVariants = directionVariants;
 
-        if (variantSelector === selector) {
-          return null;
-        }
+let reducedMotionVariants = ({
+  config,
+  addVariant
+}) => {
+  addVariant('motion-safe', (0, _pluginUtils.transformLastClasses)(className => {
+    return `motion-safe${config('separator')}${className}`;
+  }, {
+    wrap: () => _postcss.default.atRule({
+      name: 'media',
+      params: '(prefers-reduced-motion: no-preference)'
+    })
+  }));
+  addVariant('motion-reduce', (0, _pluginUtils.transformLastClasses)(className => {
+    return `motion-reduce${config('separator')}${className}`;
+  }, {
+    wrap: () => _postcss.default.atRule({
+      name: 'media',
+      params: '(prefers-reduced-motion: reduce)'
+    })
+  }));
+};
 
-        return (0, _pluginUtils.applyPseudoToMarker)(variantSelector, peerMarker, state, (marker, selector) => selector.trim().startsWith('~') ? `${marker}${selector}` : `${marker} ~ ${selector}`);
-      }));
-    }
-  },
-  directionVariants: function ({
-    config,
-    addVariant
-  }) {
-    addVariant('ltr', (0, _pluginUtils.transformAllSelectors)(selector => `[dir="ltr"] ${(0, _pluginUtils.updateAllClasses)(selector, className => `ltr${config('separator')}${className}`)}`));
-    addVariant('rtl', (0, _pluginUtils.transformAllSelectors)(selector => `[dir="rtl"] ${(0, _pluginUtils.updateAllClasses)(selector, className => `rtl${config('separator')}${className}`)}`));
-  },
-  reducedMotionVariants: function ({
-    config,
-    addVariant
-  }) {
-    addVariant('motion-safe', (0, _pluginUtils.transformLastClasses)(className => {
-      return `motion-safe${config('separator')}${className}`;
+exports.reducedMotionVariants = reducedMotionVariants;
+
+let darkVariants = ({
+  config,
+  addVariant
+}) => {
+  let mode = config('darkMode', 'media');
+
+  if (mode === false) {
+    mode = 'media';
+
+    _log.default.warn(['`darkMode` is set to `false` in your config.', 'This will behave just like the `media` value.']);
+  }
+
+  if (mode === 'class') {
+    addVariant('dark', (0, _pluginUtils.transformAllSelectors)(selector => {
+      let variantSelector = (0, _pluginUtils.updateLastClasses)(selector, className => {
+        return `dark${config('separator')}${className}`;
+      });
+
+      if (variantSelector === selector) {
+        return null;
+      }
+
+      let darkSelector = (0, _prefixSelector.default)(config('prefix'), `.dark`);
+      return `${darkSelector} ${variantSelector}`;
+    }));
+  } else if (mode === 'media') {
+    addVariant('dark', (0, _pluginUtils.transformLastClasses)(className => {
+      return `dark${config('separator')}${className}`;
     }, {
       wrap: () => _postcss.default.atRule({
         name: 'media',
-        params: '(prefers-reduced-motion: no-preference)'
+        params: '(prefers-color-scheme: dark)'
       })
     }));
-    addVariant('motion-reduce', (0, _pluginUtils.transformLastClasses)(className => {
-      return `motion-reduce${config('separator')}${className}`;
+  }
+};
+
+exports.darkVariants = darkVariants;
+
+let screenVariants = ({
+  config,
+  theme,
+  addVariant
+}) => {
+  for (let screen in theme('screens')) {
+    let size = theme('screens')[screen];
+    let query = (0, _buildMediaQuery.default)(size);
+    addVariant(screen, (0, _pluginUtils.transformLastClasses)(className => {
+      return `${screen}${config('separator')}${className}`;
     }, {
       wrap: () => _postcss.default.atRule({
         name: 'media',
-        params: '(prefers-reduced-motion: reduce)'
+        params: query
       })
     }));
-  },
-  darkVariants: function ({
-    config,
-    addVariant
+  }
+}; // Actual plugins
+
+
+exports.screenVariants = screenVariants;
+
+let preflight = ({
+  addBase
+}) => {
+  let preflightStyles = _postcss.default.parse(_fs.default.readFileSync(`${__dirname}/css/preflight.css`, 'utf8'));
+
+  addBase([_postcss.default.comment({
+    text: `! tailwindcss v${_package.default.version} | MIT License | https://tailwindcss.com`
+  }), ...preflightStyles.nodes]);
+};
+
+exports.preflight = preflight;
+
+let container = (() => {
+  function extractMinWidths(breakpoints) {
+    return Object.values(breakpoints !== null && breakpoints !== void 0 ? breakpoints : {}).flatMap(breakpoints => {
+      if (typeof breakpoints === 'string') {
+        breakpoints = {
+          min: breakpoints
+        };
+      }
+
+      if (!Array.isArray(breakpoints)) {
+        breakpoints = [breakpoints];
+      }
+
+      return breakpoints.filter(breakpoint => {
+        var _breakpoint$hasOwnPro;
+
+        return (breakpoint === null || breakpoint === void 0 ? void 0 : (_breakpoint$hasOwnPro = breakpoint.hasOwnProperty) === null || _breakpoint$hasOwnPro === void 0 ? void 0 : _breakpoint$hasOwnPro.call(breakpoint, 'min')) || (breakpoint === null || breakpoint === void 0 ? void 0 : breakpoint.hasOwnProperty('min-width'));
+      }).map(breakpoint => {
+        var _breakpoint$minWidth;
+
+        return (_breakpoint$minWidth = breakpoint['min-width']) !== null && _breakpoint$minWidth !== void 0 ? _breakpoint$minWidth : breakpoint.min;
+      });
+    });
+  }
+
+  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, value] of Object.entries(screens)) {
+        let screenMinWidth = typeof value === 'object' && value !== null ? value.min || value['min-width'] : value;
+
+        if (`${screenMinWidth}` === `${minWidth}`) {
+          mapping.push({
+            screen,
+            minWidth,
+            padding: paddings[screen]
+          });
+        }
+      }
+    }
+
+    return mapping;
+  }
+
+  return function ({
+    addComponents,
+    theme
   }) {
-    let mode = config('darkMode', 'media');
+    let screens = 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]);
+  };
+})();
+
+exports.container = container;
+
+let 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'
+    }
+  });
+};
+
+exports.accessibility = accessibility;
+
+let pointerEvents = ({
+  addUtilities
+}) => {
+  addUtilities({
+    '.pointer-events-none': {
+      'pointer-events': 'none'
+    },
+    '.pointer-events-auto': {
+      'pointer-events': 'auto'
+    }
+  });
+};
+
+exports.pointerEvents = pointerEvents;
+
+let visibility = ({
+  addUtilities
+}) => {
+  addUtilities({
+    '.visible': {
+      visibility: 'visible'
+    },
+    '.invisible': {
+      visibility: 'hidden'
+    }
+  });
+};
+
+exports.visibility = visibility;
+
+let position = ({
+  addUtilities
+}) => {
+  addUtilities({
+    '.static': {
+      position: 'static'
+    },
+    '.fixed': {
+      position: 'fixed'
+    },
+    '.absolute': {
+      position: 'absolute'
+    },
+    '.relative': {
+      position: 'relative'
+    },
+    '.sticky': {
+      position: 'sticky'
+    }
+  });
+};
+
+exports.position = position;
+
+let inset = ({
+  matchUtilities,
+  theme
+}) => {
+  let options = {
+    values: theme('inset'),
+    type: 'any'
+  };
+  matchUtilities({
+    inset: value => ({
+      top: value,
+      right: value,
+      bottom: value,
+      left: value
+    })
+  }, options);
+  matchUtilities({
+    'inset-x': value => ({
+      left: value,
+      right: value
+    }),
+    'inset-y': value => ({
+      top: value,
+      bottom: value
+    })
+  }, options);
+  matchUtilities({
+    top: top => ({
+      top
+    }),
+    right: right => ({
+      right
+    }),
+    bottom: bottom => ({
+      bottom
+    }),
+    left: left => ({
+      left
+    })
+  }, options);
+};
+
+exports.inset = inset;
+
+let isolation = ({
+  addUtilities
+}) => {
+  addUtilities({
+    '.isolate': {
+      isolation: 'isolate'
+    },
+    '.isolation-auto': {
+      isolation: 'auto'
+    }
+  });
+};
+
+exports.isolation = isolation;
+let zIndex = (0, _createUtilityPlugin.default)('zIndex', [['z', ['zIndex']]]);
+exports.zIndex = zIndex;
+let order = (0, _createUtilityPlugin.default)('order');
+exports.order = order;
+let gridColumn = (0, _createUtilityPlugin.default)('gridColumn', [['col', ['gridColumn']]]);
+exports.gridColumn = gridColumn;
+let gridColumnStart = (0, _createUtilityPlugin.default)('gridColumnStart', [['col-start', ['gridColumnStart']]]);
+exports.gridColumnStart = gridColumnStart;
+let gridColumnEnd = (0, _createUtilityPlugin.default)('gridColumnEnd', [['col-end', ['gridColumnEnd']]]);
+exports.gridColumnEnd = gridColumnEnd;
+let gridRow = (0, _createUtilityPlugin.default)('gridRow', [['row', ['gridRow']]]);
+exports.gridRow = gridRow;
+let gridRowStart = (0, _createUtilityPlugin.default)('gridRowStart', [['row-start', ['gridRowStart']]]);
+exports.gridRowStart = gridRowStart;
+let gridRowEnd = (0, _createUtilityPlugin.default)('gridRowEnd', [['row-end', ['gridRowEnd']]]);
+exports.gridRowEnd = gridRowEnd;
+
+let float = ({
+  addUtilities
+}) => {
+  addUtilities({
+    '.float-right': {
+      float: 'right'
+    },
+    '.float-left': {
+      float: 'left'
+    },
+    '.float-none': {
+      float: 'none'
+    }
+  });
+};
+
+exports.float = float;
+
+let clear = ({
+  addUtilities
+}) => {
+  addUtilities({
+    '.clear-left': {
+      clear: 'left'
+    },
+    '.clear-right': {
+      clear: 'right'
+    },
+    '.clear-both': {
+      clear: 'both'
+    },
+    '.clear-none': {
+      clear: 'none'
+    }
+  });
+};
+
+exports.clear = clear;
+let 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']]]]);
+exports.margin = margin;
+
+let boxSizing = ({
+  addUtilities
+}) => {
+  addUtilities({
+    '.box-border': {
+      'box-sizing': 'border-box'
+    },
+    '.box-content': {
+      'box-sizing': 'content-box'
+    }
+  });
+};
+
+exports.boxSizing = boxSizing;
+
+let 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'
+    }
+  });
+};
+
+exports.display = display;
+let aspectRatio = (0, _createUtilityPlugin.default)('aspectRatio', [['aspect', ['aspect-ratio']]]);
+exports.aspectRatio = aspectRatio;
+let height = (0, _createUtilityPlugin.default)('height', [['h', ['height']]]);
+exports.height = height;
+let maxHeight = (0, _createUtilityPlugin.default)('maxHeight', [['max-h', ['maxHeight']]]);
+exports.maxHeight = maxHeight;
+let minHeight = (0, _createUtilityPlugin.default)('minHeight', [['min-h', ['minHeight']]]);
+exports.minHeight = minHeight;
+let width = (0, _createUtilityPlugin.default)('width', [['w', ['width']]]);
+exports.width = width;
+let minWidth = (0, _createUtilityPlugin.default)('minWidth', [['min-w', ['minWidth']]]);
+exports.minWidth = minWidth;
+let maxWidth = (0, _createUtilityPlugin.default)('maxWidth', [['max-w', ['maxWidth']]]);
+exports.maxWidth = maxWidth;
+let flex = (0, _createUtilityPlugin.default)('flex');
+exports.flex = flex;
+let flexShrink = (0, _createUtilityPlugin.default)('flexShrink', [['flex-shrink', ['flex-shrink']]]);
+exports.flexShrink = flexShrink;
+let flexGrow = (0, _createUtilityPlugin.default)('flexGrow', [['flex-grow', ['flex-grow']]]);
+exports.flexGrow = flexGrow;
+
+let tableLayout = ({
+  addUtilities
+}) => {
+  addUtilities({
+    '.table-auto': {
+      'table-layout': 'auto'
+    },
+    '.table-fixed': {
+      'table-layout': 'fixed'
+    }
+  });
+};
+
+exports.tableLayout = tableLayout;
+
+let borderCollapse = ({
+  addUtilities
+}) => {
+  addUtilities({
+    '.border-collapse': {
+      'border-collapse': 'collapse'
+    },
+    '.border-separate': {
+      'border-collapse': 'separate'
+    }
+  });
+};
 
-    if (mode === false) {
-      mode = 'media';
+exports.borderCollapse = borderCollapse;
+let transformOrigin = (0, _createUtilityPlugin.default)('transformOrigin', [['origin', ['transformOrigin']]]);
+exports.transformOrigin = transformOrigin;
+let translate = (0, _createUtilityPlugin.default)('translate', [[['translate-x', [['@defaults transform', {}], '--tw-translate-x', ['transform', 'var(--tw-transform)']]], ['translate-y', [['@defaults transform', {}], '--tw-translate-y', ['transform', 'var(--tw-transform)']]]]]);
+exports.translate = translate;
+let rotate = (0, _createUtilityPlugin.default)('rotate', [['rotate', [['@defaults transform', {}], '--tw-rotate', ['transform', 'var(--tw-transform)']]]]);
+exports.rotate = rotate;
+let skew = (0, _createUtilityPlugin.default)('skew', [[['skew-x', [['@defaults transform', {}], '--tw-skew-x', ['transform', 'var(--tw-transform)']]], ['skew-y', [['@defaults transform', {}], '--tw-skew-y', ['transform', 'var(--tw-transform)']]]]]);
+exports.skew = skew;
+let scale = (0, _createUtilityPlugin.default)('scale', [['scale', [['@defaults transform', {}], '--tw-scale-x', '--tw-scale-y', ['transform', 'var(--tw-transform)']]], [['scale-x', [['@defaults transform', {}], '--tw-scale-x', ['transform', 'var(--tw-transform)']]], ['scale-y', [['@defaults transform', {}], '--tw-scale-y', ['transform', 'var(--tw-transform)']]]]]);
+exports.scale = scale;
 
-      _log.default.warn(['`darkMode` is set to `false` in your config.', 'This will behave just like the `media` value.']);
+let transform = ({
+  addBase,
+  addUtilities
+}) => {
+  addBase({
+    '@defaults 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',
+      '--tw-transform': ['translateX(var(--tw-translate-x))', 'translateY(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(' ')
+    }
+  });
+  addUtilities({
+    '.transform': {
+      '@defaults transform': {},
+      transform: 'var(--tw-transform)'
+    },
+    '.transform-cpu': {
+      '--tw-transform': ['translateX(var(--tw-translate-x))', 'translateY(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(' ')
+    },
+    '.transform-gpu': {
+      '--tw-transform': ['translate3d(var(--tw-translate-x), var(--tw-translate-y), 0)', '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(' ')
+    },
+    '.transform-none': {
+      transform: 'none'
     }
+  });
+};
+
+exports.transform = transform;
 
-    if (mode === 'class') {
-      addVariant('dark', (0, _pluginUtils.transformAllSelectors)(selector => {
-        let variantSelector = (0, _pluginUtils.updateLastClasses)(selector, className => {
-          return `dark${config('separator')}${className}`;
-        });
+let animation = ({
+  matchUtilities,
+  theme,
+  prefix
+}) => {
+  var _theme;
 
-        if (variantSelector === selector) {
-          return null;
+  let prefixName = name => prefix(`.${name}`).slice(1);
+
+  let keyframes = Object.fromEntries(Object.entries((_theme = theme('keyframes')) !== null && _theme !== void 0 ? _theme : {}).map(([key, value]) => {
+    return [key, [{
+      [`@keyframes ${prefixName(key)}`]: value
+    }]];
+  }));
+  matchUtilities({
+    animate: (value, {
+      includeRules
+    }) => {
+      let animations = (0, _parseAnimationValue.default)(value);
+
+      for (let {
+        name
+      } of animations) {
+        if (keyframes[name] !== undefined) {
+          includeRules(keyframes[name], {
+            respectImportant: false
+          });
         }
+      }
 
-        let darkSelector = (0, _prefixSelector.default)(config('prefix'), `.dark`);
-        return `${darkSelector} ${variantSelector}`;
-      }));
-    } else if (mode === 'media') {
-      addVariant('dark', (0, _pluginUtils.transformLastClasses)(className => {
-        return `dark${config('separator')}${className}`;
-      }, {
-        wrap: () => _postcss.default.atRule({
-          name: 'media',
-          params: '(prefers-color-scheme: dark)'
-        })
-      }));
+      return {
+        animation: animations.map(({
+          name,
+          value
+        }) => {
+          if (name === undefined || keyframes[name] === undefined) {
+            return value;
+          }
+
+          return value.replace(name, prefixName(name));
+        }).join(', ')
+      };
     }
-  },
-  screenVariants: function ({
-    config,
-    theme,
-    addVariant
-  }) {
-    for (let screen in theme('screens')) {
-      let size = theme('screens')[screen];
-      let query = (0, _buildMediaQuery.default)(size);
-      addVariant(screen, (0, _pluginUtils.transformLastClasses)(className => {
-        return `${screen}${config('separator')}${className}`;
-      }, {
-        wrap: () => _postcss.default.atRule({
-          name: 'media',
-          params: query
+  }, {
+    values: theme('animation')
+  });
+};
+
+exports.animation = animation;
+let cursor = (0, _createUtilityPlugin.default)('cursor');
+exports.cursor = cursor;
+
+let userSelect = ({
+  addUtilities
+}) => {
+  addUtilities({
+    '.select-none': {
+      'user-select': 'none'
+    },
+    '.select-text': {
+      'user-select': 'text'
+    },
+    '.select-all': {
+      'user-select': 'all'
+    },
+    '.select-auto': {
+      'user-select': 'auto'
+    }
+  });
+};
+
+exports.userSelect = userSelect;
+
+let resize = ({
+  addUtilities
+}) => {
+  addUtilities({
+    '.resize-none': {
+      resize: 'none'
+    },
+    '.resize-y': {
+      resize: 'vertical'
+    },
+    '.resize-x': {
+      resize: 'horizontal'
+    },
+    '.resize': {
+      resize: 'both'
+    }
+  });
+};
+
+exports.resize = resize;
+
+let listStylePosition = ({
+  addUtilities
+}) => {
+  addUtilities({
+    '.list-inside': {
+      'list-style-position': 'inside'
+    },
+    '.list-outside': {
+      'list-style-position': 'outside'
+    }
+  });
+};
+
+exports.listStylePosition = listStylePosition;
+let listStyleType = (0, _createUtilityPlugin.default)('listStyleType', [['list', ['listStyleType']]]);
+exports.listStyleType = listStyleType;
+
+let appearance = ({
+  addUtilities
+}) => {
+  addUtilities({
+    '.appearance-none': {
+      appearance: 'none'
+    }
+  });
+};
+
+exports.appearance = appearance;
+let columns = (0, _createUtilityPlugin.default)('columns', [['columns', ['columns']]]);
+exports.columns = columns;
+let gridAutoColumns = (0, _createUtilityPlugin.default)('gridAutoColumns', [['auto-cols', ['gridAutoColumns']]]);
+exports.gridAutoColumns = gridAutoColumns;
+
+let 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'
+    }
+  });
+};
+
+exports.gridAutoFlow = gridAutoFlow;
+let gridAutoRows = (0, _createUtilityPlugin.default)('gridAutoRows', [['auto-rows', ['gridAutoRows']]]);
+exports.gridAutoRows = gridAutoRows;
+let gridTemplateColumns = (0, _createUtilityPlugin.default)('gridTemplateColumns', [['grid-cols', ['gridTemplateColumns']]]);
+exports.gridTemplateColumns = gridTemplateColumns;
+let gridTemplateRows = (0, _createUtilityPlugin.default)('gridTemplateRows', [['grid-rows', ['gridTemplateRows']]]);
+exports.gridTemplateRows = gridTemplateRows;
+
+let 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'
+    }
+  });
+};
+
+exports.flexDirection = flexDirection;
+
+let flexWrap = ({
+  addUtilities
+}) => {
+  addUtilities({
+    '.flex-wrap': {
+      'flex-wrap': 'wrap'
+    },
+    '.flex-wrap-reverse': {
+      'flex-wrap': 'wrap-reverse'
+    },
+    '.flex-nowrap': {
+      'flex-wrap': 'nowrap'
+    }
+  });
+};
+
+exports.flexWrap = flexWrap;
+
+let 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'
+    }
+  });
+};
+
+exports.placeContent = placeContent;
+
+let 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'
+    }
+  });
+};
+
+exports.placeItems = placeItems;
+
+let 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'
+    }
+  });
+};
+
+exports.alignContent = alignContent;
+
+let 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'
+    }
+  });
+};
+
+exports.alignItems = alignItems;
+
+let 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'
+    }
+  });
+};
+
+exports.justifyContent = justifyContent;
+
+let 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'
+    }
+  });
+};
+
+exports.justifyItems = justifyItems;
+let gap = (0, _createUtilityPlugin.default)('gap', [['gap', ['gap']], [['gap-x', ['columnGap']], ['gap-y', ['rowGap']]]]);
+exports.gap = gap;
+
+let 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'),
+    type: 'any'
+  });
+  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'
+    }
+  });
+};
+
+exports.space = space;
+
+let 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: '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'
+    }
+  });
+};
+
+exports.divideWidth = divideWidth;
+
+let 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'
+    }
+  });
+};
+
+exports.divideStyle = divideStyle;
+
+let divideColor = ({
+  matchUtilities,
+  theme,
+  corePlugins
+}) => {
+  matchUtilities({
+    divide: value => {
+      if (!corePlugins('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'
+  });
+};
+
+exports.divideColor = divideColor;
+
+let divideOpacity = ({
+  matchUtilities,
+  theme
+}) => {
+  matchUtilities({
+    'divide-opacity': value => {
+      return {
+        [`& > :not([hidden]) ~ :not([hidden])`]: {
+          '--tw-divide-opacity': value
+        }
+      };
+    }
+  }, {
+    values: theme('divideOpacity'),
+    type: 'any'
+  });
+};
+
+exports.divideOpacity = divideOpacity;
+
+let 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'
+    }
+  });
+};
+
+exports.placeSelf = placeSelf;
+
+let 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'
+    }
+  });
+};
+
+exports.alignSelf = alignSelf;
+
+let 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'
+    }
+  });
+};
+
+exports.justifySelf = justifySelf;
+
+let overflow = ({
+  addUtilities
+}) => {
+  addUtilities({
+    '.overflow-auto': {
+      overflow: 'auto'
+    },
+    '.overflow-hidden': {
+      overflow: 'hidden'
+    },
+    '.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-visible': {
+      'overflow-x': 'visible'
+    },
+    '.overflow-y-visible': {
+      'overflow-y': 'visible'
+    },
+    '.overflow-x-scroll': {
+      'overflow-x': 'scroll'
+    },
+    '.overflow-y-scroll': {
+      'overflow-y': 'scroll'
+    }
+  });
+};
+
+exports.overflow = overflow;
+
+let 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'
     }
-  },
-  ...Object.fromEntries(Object.entries(corePlugins).map(([pluginName, plugin]) => {
-    return [pluginName, plugin()];
-  }))
+  });
 };
-exports.default = _default;
+
+exports.overscrollBehavior = overscrollBehavior;
+
+let scrollBehavior = ({
+  addUtilities
+}) => {
+  addUtilities({
+    '.scroll-auto': {
+      'scroll-behavior': 'auto'
+    },
+    '.scroll-smooth': {
+      'scroll-behavior': 'smooth'
+    }
+  });
+};
+
+exports.scrollBehavior = scrollBehavior;
+
+let textOverflow = ({
+  addUtilities
+}) => {
+  addUtilities({
+    '.truncate': {
+      overflow: 'hidden',
+      'text-overflow': 'ellipsis',
+      'white-space': 'nowrap'
+    },
+    '.overflow-ellipsis': {
+      'text-overflow': 'ellipsis'
+    },
+    '.overflow-clip': {
+      'text-overflow': 'clip'
+    }
+  });
+};
+
+exports.textOverflow = textOverflow;
+
+let 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'
+    }
+  });
+};
+
+exports.whitespace = whitespace;
+
+let wordBreak = ({
+  addUtilities
+}) => {
+  addUtilities({
+    '.break-normal': {
+      'overflow-wrap': 'normal',
+      'word-break': 'normal'
+    },
+    '.break-words': {
+      'overflow-wrap': 'break-word'
+    },
+    '.break-all': {
+      'word-break': 'break-all'
+    }
+  });
+};
+
+exports.wordBreak = wordBreak;
+let 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']]]]);
+exports.borderRadius = borderRadius;
+let borderWidth = (0, _createUtilityPlugin.default)('borderWidth', [['border', [['@defaults border-width', {}], 'border-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']]]], {
+  resolveArbitraryValue: _pluginUtils.asLength
+});
+exports.borderWidth = borderWidth;
+
+let 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'
+    }
+  });
+};
+
+exports.borderStyle = borderStyle;
+
+let borderColor = ({
+  addBase,
+  matchUtilities,
+  theme,
+  corePlugins
+}) => {
+  if (!corePlugins('borderOpacity')) {
+    let value = theme('borderColor.DEFAULT', 'currentColor');
+    addBase({
+      '@defaults border-width': {
+        'border-color': (0, _toColorValue.default)(value)
+      }
+    });
+  } else {
+    addBase({
+      '@defaults border-width': (0, _withAlphaVariable.default)({
+        color: theme('borderColor.DEFAULT', 'currentColor'),
+        property: 'border-color',
+        variable: '--tw-border-opacity'
+      })
+    });
+  }
+
+  matchUtilities({
+    border: value => {
+      if (!corePlugins('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-t': value => {
+      if (!corePlugins('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 (!corePlugins('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 (!corePlugins('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 (!corePlugins('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'
+  });
+};
+
+exports.borderColor = borderColor;
+let borderOpacity = (0, _createUtilityPlugin.default)('borderOpacity', [['border-opacity', ['--tw-border-opacity']]]);
+exports.borderOpacity = borderOpacity;
+
+let backgroundColor = ({
+  matchUtilities,
+  theme,
+  corePlugins
+}) => {
+  matchUtilities({
+    bg: value => {
+      if (!corePlugins('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'
+  });
+};
+
+exports.backgroundColor = backgroundColor;
+let backgroundOpacity = (0, _createUtilityPlugin.default)('backgroundOpacity', [['bg-opacity', ['--tw-bg-opacity']]]);
+exports.backgroundOpacity = backgroundOpacity;
+let backgroundImage = (0, _createUtilityPlugin.default)('backgroundImage', [['bg', ['background-image']]], {
+  resolveArbitraryValue: _pluginUtils.asLookupValue
+});
+exports.backgroundImage = backgroundImage;
+
+let 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);
+  };
+})();
+
+exports.gradientColorStops = gradientColorStops;
+
+let boxDecorationBreak = ({
+  addUtilities
+}) => {
+  addUtilities({
+    '.decoration-slice': {
+      'box-decoration-break': 'slice'
+    },
+    '.decoration-clone': {
+      'box-decoration-break': 'clone'
+    }
+  });
+};
+
+exports.boxDecorationBreak = boxDecorationBreak;
+let backgroundSize = (0, _createUtilityPlugin.default)('backgroundSize', [['bg', ['background-size']]], {
+  resolveArbitraryValue: _pluginUtils.asLookupValue
+});
+exports.backgroundSize = backgroundSize;
+
+let backgroundAttachment = ({
+  addUtilities
+}) => {
+  addUtilities({
+    '.bg-fixed': {
+      'background-attachment': 'fixed'
+    },
+    '.bg-local': {
+      'background-attachment': 'local'
+    },
+    '.bg-scroll': {
+      'background-attachment': 'scroll'
+    }
+  });
+};
+
+exports.backgroundAttachment = backgroundAttachment;
+
+let 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'
+    }
+  });
+};
+
+exports.backgroundClip = backgroundClip;
+let backgroundPosition = (0, _createUtilityPlugin.default)('backgroundPosition', [['bg', ['background-position']]], {
+  resolveArbitraryValue: _pluginUtils.asLookupValue
+});
+exports.backgroundPosition = backgroundPosition;
+
+let 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'
+    }
+  });
+};
+
+exports.backgroundRepeat = backgroundRepeat;
+
+let backgroundOrigin = ({
+  addUtilities
+}) => {
+  addUtilities({
+    '.bg-origin-border': {
+      'background-origin': 'border-box'
+    },
+    '.bg-origin-padding': {
+      'background-origin': 'padding-box'
+    },
+    '.bg-origin-content': {
+      'background-origin': 'content-box'
+    }
+  });
+};
+
+exports.backgroundOrigin = backgroundOrigin;
+
+let fill = ({
+  matchUtilities,
+  theme
+}) => {
+  matchUtilities({
+    fill: value => {
+      return {
+        fill: (0, _toColorValue.default)(value)
+      };
+    }
+  }, {
+    values: (0, _flattenColorPalette.default)(theme('fill')),
+    type: ['color', 'any']
+  });
+};
+
+exports.fill = fill;
+
+let stroke = ({
+  matchUtilities,
+  theme
+}) => {
+  matchUtilities({
+    stroke: value => {
+      return {
+        stroke: (0, _toColorValue.default)(value)
+      };
+    }
+  }, {
+    values: (0, _flattenColorPalette.default)(theme('stroke')),
+    type: 'color'
+  });
+};
+
+exports.stroke = stroke;
+let strokeWidth = (0, _createUtilityPlugin.default)('strokeWidth', [['stroke', ['stroke-width']]], {
+  resolveArbitraryValue: _pluginUtils.asLength
+});
+exports.strokeWidth = strokeWidth;
+
+let 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'
+    }
+  });
+};
+
+exports.objectFit = objectFit;
+let objectPosition = (0, _createUtilityPlugin.default)('objectPosition', [['object', ['object-position']]]);
+exports.objectPosition = objectPosition;
+let 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']]]]);
+exports.padding = padding;
+
+let textAlign = ({
+  addUtilities
+}) => {
+  addUtilities({
+    '.text-left': {
+      'text-align': 'left'
+    },
+    '.text-center': {
+      'text-align': 'center'
+    },
+    '.text-right': {
+      'text-align': 'right'
+    },
+    '.text-justify': {
+      'text-align': 'justify'
+    }
+  });
+};
+
+exports.textAlign = textAlign;
+let textIndent = (0, _createUtilityPlugin.default)('textIndent', [['indent', ['text-indent']]]);
+exports.textIndent = textIndent;
+
+let 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
+    })
+  }, {
+    values: {},
+    type: 'any'
+  });
+};
+
+exports.verticalAlign = verticalAlign;
+let fontFamily = (0, _createUtilityPlugin.default)('fontFamily', [['font', ['fontFamily']]], {
+  resolveArbitraryValue: _pluginUtils.asLookupValue
+});
+exports.fontFamily = fontFamily;
+
+let 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: 'length'
+  });
+};
+
+exports.fontSize = fontSize;
+let fontWeight = (0, _createUtilityPlugin.default)('fontWeight', [['font', ['fontWeight']]], {
+  resolveArbitraryValue: _pluginUtils.asLookupValue
+});
+exports.fontWeight = fontWeight;
+
+let textTransform = ({
+  addUtilities
+}) => {
+  addUtilities({
+    '.uppercase': {
+      'text-transform': 'uppercase'
+    },
+    '.lowercase': {
+      'text-transform': 'lowercase'
+    },
+    '.capitalize': {
+      'text-transform': 'capitalize'
+    },
+    '.normal-case': {
+      'text-transform': 'none'
+    }
+  });
+};
+
+exports.textTransform = textTransform;
+
+let fontStyle = ({
+  addUtilities
+}) => {
+  addUtilities({
+    '.italic': {
+      'font-style': 'italic'
+    },
+    '.not-italic': {
+      'font-style': 'normal'
+    }
+  });
+};
+
+exports.fontStyle = fontStyle;
+
+let fontVariantNumeric = ({
+  addUtilities
+}) => {
+  addUtilities({
+    '.ordinal, .slashed-zero, .lining-nums, .oldstyle-nums, .proportional-nums, .tabular-nums, .diagonal-fractions, .stacked-fractions': {
+      '--tw-ordinal': 'var(--tw-empty,/*!*/ /*!*/)',
+      '--tw-slashed-zero': 'var(--tw-empty,/*!*/ /*!*/)',
+      '--tw-numeric-figure': 'var(--tw-empty,/*!*/ /*!*/)',
+      '--tw-numeric-spacing': 'var(--tw-empty,/*!*/ /*!*/)',
+      '--tw-numeric-fraction': 'var(--tw-empty,/*!*/ /*!*/)',
+      'font-variant-numeric': 'var(--tw-ordinal) var(--tw-slashed-zero) var(--tw-numeric-figure) var(--tw-numeric-spacing) var(--tw-numeric-fraction)'
+    },
+    '.normal-nums': {
+      'font-variant-numeric': 'normal'
+    },
+    '.ordinal': {
+      '--tw-ordinal': 'ordinal'
+    },
+    '.slashed-zero': {
+      '--tw-slashed-zero': 'slashed-zero'
+    },
+    '.lining-nums': {
+      '--tw-numeric-figure': 'lining-nums'
+    },
+    '.oldstyle-nums': {
+      '--tw-numeric-figure': 'oldstyle-nums'
+    },
+    '.proportional-nums': {
+      '--tw-numeric-spacing': 'proportional-nums'
+    },
+    '.tabular-nums': {
+      '--tw-numeric-spacing': 'tabular-nums'
+    },
+    '.diagonal-fractions': {
+      '--tw-numeric-fraction': 'diagonal-fractions'
+    },
+    '.stacked-fractions': {
+      '--tw-numeric-fraction': 'stacked-fractions'
+    }
+  });
+};
+
+exports.fontVariantNumeric = fontVariantNumeric;
+let lineHeight = (0, _createUtilityPlugin.default)('lineHeight', [['leading', ['lineHeight']]]);
+exports.lineHeight = lineHeight;
+let letterSpacing = (0, _createUtilityPlugin.default)('letterSpacing', [['tracking', ['letterSpacing']]]);
+exports.letterSpacing = letterSpacing;
+
+let textColor = ({
+  matchUtilities,
+  theme,
+  corePlugins
+}) => {
+  matchUtilities({
+    text: value => {
+      if (!corePlugins('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'
+  });
+};
+
+exports.textColor = textColor;
+let textOpacity = (0, _createUtilityPlugin.default)('textOpacity', [['text-opacity', ['--tw-text-opacity']]]);
+exports.textOpacity = textOpacity;
+
+let textDecoration = ({
+  addUtilities
+}) => {
+  addUtilities({
+    '.underline': {
+      'text-decoration': 'underline'
+    },
+    '.line-through': {
+      'text-decoration': 'line-through'
+    },
+    '.no-underline': {
+      'text-decoration': 'none'
+    }
+  });
+};
+
+exports.textDecoration = textDecoration;
+
+let fontSmoothing = ({
+  addUtilities
+}) => {
+  addUtilities({
+    '.antialiased': {
+      '-webkit-font-smoothing': 'antialiased',
+      '-moz-osx-font-smoothing': 'grayscale'
+    },
+    '.subpixel-antialiased': {
+      '-webkit-font-smoothing': 'auto',
+      '-moz-osx-font-smoothing': 'auto'
+    }
+  });
+};
+
+exports.fontSmoothing = fontSmoothing;
+
+let placeholderColor = ({
+  matchUtilities,
+  theme,
+  corePlugins
+}) => {
+  matchUtilities({
+    placeholder: value => {
+      if (!corePlugins('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']
+  });
+};
+
+exports.placeholderColor = placeholderColor;
+
+let placeholderOpacity = ({
+  matchUtilities,
+  theme
+}) => {
+  matchUtilities({
+    'placeholder-opacity': value => {
+      return {
+        ['&::placeholder']: {
+          '--tw-placeholder-opacity': value
+        }
+      };
+    }
+  }, {
+    values: theme('placeholderOpacity'),
+    type: 'any'
+  });
+};
+
+exports.placeholderOpacity = placeholderOpacity;
+
+let caretColor = ({
+  matchUtilities,
+  theme
+}) => {
+  matchUtilities({
+    caret: value => {
+      return {
+        'caret-color': (0, _toColorValue.default)(value)
+      };
+    }
+  }, {
+    values: (0, _flattenColorPalette.default)(theme('caretColor')),
+    type: ['color', 'any']
+  });
+};
+
+exports.caretColor = caretColor;
+
+let accentColor = ({
+  matchUtilities,
+  theme
+}) => {
+  matchUtilities({
+    accent: value => {
+      return {
+        'accent-color': (0, _toColorValue.default)(value)
+      };
+    }
+  }, {
+    values: (0, _flattenColorPalette.default)(theme('accentColor')),
+    type: ['color', 'any']
+  });
+};
+
+exports.accentColor = accentColor;
+let opacity = (0, _createUtilityPlugin.default)('opacity', [['opacity', ['opacity']]]);
+exports.opacity = opacity;
+
+let 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'
+    }
+  });
+};
+
+exports.backgroundBlendMode = backgroundBlendMode;
+
+let 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'
+    }
+  });
+};
+
+exports.mixBlendMode = mixBlendMode;
+
+let 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,
+    addBase,
+    theme
+  }) {
+    addBase({
+      '@defaults box-shadow': {
+        '--tw-ring-offset-shadow': '0 0 #0000',
+        '--tw-ring-shadow': '0 0 #0000',
+        '--tw-shadow': '0 0 #0000'
+      }
+    });
+    matchUtilities({
+      shadow: value => {
+        value = transformValue(value);
+        return {
+          '@defaults box-shadow': {},
+          '--tw-shadow': value === 'none' ? '0 0 #0000' : value,
+          'box-shadow': defaultBoxShadow
+        };
+      }
+    }, {
+      values: theme('boxShadow')
+    });
+  };
+})();
+
+exports.boxShadow = boxShadow;
+
+let outline = ({
+  matchUtilities,
+  theme
+}) => {
+  matchUtilities({
+    outline: value => {
+      let [outline, outlineOffset = '0'] = Array.isArray(value) ? value : [value];
+      return {
+        outline,
+        'outline-offset': outlineOffset
+      };
+    }
+  }, {
+    values: theme('outline'),
+    type: 'any'
+  });
+};
+
+exports.outline = outline;
+
+let ringWidth = ({
+  matchUtilities,
+  addBase,
+  addUtilities,
+  theme
+}) => {
+  let ringOpacityDefault = theme('ringOpacity.DEFAULT', '0.5');
+  let ringColorDefault = (0, _withAlphaVariable.withAlphaValue)(theme('ringColor.DEFAULT'), ringOpacityDefault, `rgb(147 197 253 / ${ringOpacityDefault})`);
+  addBase({
+    '@defaults ring-width': {
+      '--tw-ring-inset': 'var(--tw-empty,/*!*/ /*!*/)',
+      '--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'
+    }
+  });
+  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'
+    }
+  });
+};
+
+exports.ringWidth = ringWidth;
+
+let 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'
+  });
+};
+
+exports.ringColor = ringColor;
+let ringOpacity = (0, _createUtilityPlugin.default)('ringOpacity', [['ring-opacity', ['--tw-ring-opacity']]], {
+  filterDefault: true
+});
+exports.ringOpacity = ringOpacity;
+let ringOffsetWidth = (0, _createUtilityPlugin.default)('ringOffsetWidth', [['ring-offset', ['--tw-ring-offset-width']]], {
+  resolveArbitraryValue: _pluginUtils.asLength
+});
+exports.ringOffsetWidth = ringOffsetWidth;
+
+let ringOffsetColor = ({
+  matchUtilities,
+  theme
+}) => {
+  matchUtilities({
+    'ring-offset': value => {
+      return {
+        '--tw-ring-offset-color': (0, _toColorValue.default)(value)
+      };
+    }
+  }, {
+    values: (0, _flattenColorPalette.default)(theme('ringOffsetColor')),
+    type: 'color'
+  });
+};
+
+exports.ringOffsetColor = ringOffsetColor;
+
+let blur = ({
+  matchUtilities,
+  theme
+}) => {
+  matchUtilities({
+    blur: value => {
+      return {
+        '--tw-blur': `blur(${value})`,
+        '@defaults filter': {},
+        filter: 'var(--tw-filter)'
+      };
+    }
+  }, {
+    values: theme('blur'),
+    type: 'any'
+  });
+};
+
+exports.blur = blur;
+
+let brightness = ({
+  matchUtilities,
+  theme
+}) => {
+  matchUtilities({
+    brightness: value => {
+      return {
+        '--tw-brightness': `brightness(${value})`,
+        '@defaults filter': {},
+        filter: 'var(--tw-filter)'
+      };
+    }
+  }, {
+    values: theme('brightness'),
+    type: 'any'
+  });
+};
+
+exports.brightness = brightness;
+
+let contrast = ({
+  matchUtilities,
+  theme
+}) => {
+  matchUtilities({
+    contrast: value => {
+      return {
+        '--tw-contrast': `contrast(${value})`,
+        '@defaults filter': {},
+        filter: 'var(--tw-filter)'
+      };
+    }
+  }, {
+    values: theme('contrast'),
+    type: 'any'
+  });
+};
+
+exports.contrast = contrast;
+
+let 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: 'var(--tw-filter)'
+      };
+    }
+  }, {
+    values: theme('dropShadow')
+  });
+};
+
+exports.dropShadow = dropShadow;
+
+let grayscale = ({
+  matchUtilities,
+  theme
+}) => {
+  matchUtilities({
+    grayscale: value => {
+      return {
+        '--tw-grayscale': `grayscale(${value})`,
+        '@defaults filter': {},
+        filter: 'var(--tw-filter)'
+      };
+    }
+  }, {
+    values: theme('grayscale'),
+    type: 'any'
+  });
+};
+
+exports.grayscale = grayscale;
+
+let hueRotate = ({
+  matchUtilities,
+  theme
+}) => {
+  matchUtilities({
+    'hue-rotate': value => {
+      return {
+        '--tw-hue-rotate': `hue-rotate(${value})`,
+        '@defaults filter': {},
+        filter: 'var(--tw-filter)'
+      };
+    }
+  }, {
+    values: theme('hueRotate'),
+    type: 'any'
+  });
+};
+
+exports.hueRotate = hueRotate;
+
+let invert = ({
+  matchUtilities,
+  theme
+}) => {
+  matchUtilities({
+    invert: value => {
+      return {
+        '--tw-invert': `invert(${value})`,
+        '@defaults filter': {},
+        filter: 'var(--tw-filter)'
+      };
+    }
+  }, {
+    values: theme('invert'),
+    type: 'any'
+  });
+};
+
+exports.invert = invert;
+
+let saturate = ({
+  matchUtilities,
+  theme
+}) => {
+  matchUtilities({
+    saturate: value => {
+      return {
+        '--tw-saturate': `saturate(${value})`,
+        '@defaults filter': {},
+        filter: 'var(--tw-filter)'
+      };
+    }
+  }, {
+    values: theme('saturate'),
+    type: 'any'
+  });
+};
+
+exports.saturate = saturate;
+
+let sepia = ({
+  matchUtilities,
+  theme
+}) => {
+  matchUtilities({
+    sepia: value => {
+      return {
+        '--tw-sepia': `sepia(${value})`,
+        '@defaults filter': {},
+        filter: 'var(--tw-filter)'
+      };
+    }
+  }, {
+    values: theme('sepia'),
+    type: 'any'
+  });
+};
+
+exports.sepia = sepia;
+
+let filter = ({
+  addBase,
+  addUtilities
+}) => {
+  addBase({
+    '@defaults filter': {
+      '--tw-blur': 'var(--tw-empty,/*!*/ /*!*/)',
+      '--tw-brightness': 'var(--tw-empty,/*!*/ /*!*/)',
+      '--tw-contrast': 'var(--tw-empty,/*!*/ /*!*/)',
+      '--tw-grayscale': 'var(--tw-empty,/*!*/ /*!*/)',
+      '--tw-hue-rotate': 'var(--tw-empty,/*!*/ /*!*/)',
+      '--tw-invert': 'var(--tw-empty,/*!*/ /*!*/)',
+      '--tw-saturate': 'var(--tw-empty,/*!*/ /*!*/)',
+      '--tw-sepia': 'var(--tw-empty,/*!*/ /*!*/)',
+      '--tw-drop-shadow': 'var(--tw-empty,/*!*/ /*!*/)',
+      '--tw-filter': ['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(' ')
+    }
+  });
+  addUtilities({
+    '.filter': {
+      '@defaults filter': {},
+      filter: 'var(--tw-filter)'
+    },
+    '.filter-none': {
+      filter: 'none'
+    }
+  });
+};
+
+exports.filter = filter;
+
+let backdropBlur = ({
+  matchUtilities,
+  theme
+}) => {
+  matchUtilities({
+    'backdrop-blur': value => {
+      return {
+        '--tw-backdrop-blur': `blur(${value})`,
+        '@defaults backdrop-filter': {},
+        'backdrop-filter': 'var(--tw-backdrop-filter)'
+      };
+    }
+  }, {
+    values: theme('backdropBlur'),
+    type: 'any'
+  });
+};
+
+exports.backdropBlur = backdropBlur;
+
+let backdropBrightness = ({
+  matchUtilities,
+  theme
+}) => {
+  matchUtilities({
+    'backdrop-brightness': value => {
+      return {
+        '--tw-backdrop-brightness': `brightness(${value})`,
+        '@defaults backdrop-filter': {},
+        'backdrop-filter': 'var(--tw-backdrop-filter)'
+      };
+    }
+  }, {
+    values: theme('backdropBrightness'),
+    type: 'any'
+  });
+};
+
+exports.backdropBrightness = backdropBrightness;
+
+let backdropContrast = ({
+  matchUtilities,
+  theme
+}) => {
+  matchUtilities({
+    'backdrop-contrast': value => {
+      return {
+        '--tw-backdrop-contrast': `contrast(${value})`,
+        '@defaults backdrop-filter': {},
+        'backdrop-filter': 'var(--tw-backdrop-filter)'
+      };
+    }
+  }, {
+    values: theme('backdropContrast'),
+    type: 'any'
+  });
+};
+
+exports.backdropContrast = backdropContrast;
+
+let backdropGrayscale = ({
+  matchUtilities,
+  theme
+}) => {
+  matchUtilities({
+    'backdrop-grayscale': value => {
+      return {
+        '--tw-backdrop-grayscale': `grayscale(${value})`,
+        '@defaults backdrop-filter': {},
+        'backdrop-filter': 'var(--tw-backdrop-filter)'
+      };
+    }
+  }, {
+    values: theme('backdropGrayscale'),
+    type: 'any'
+  });
+};
+
+exports.backdropGrayscale = backdropGrayscale;
+
+let backdropHueRotate = ({
+  matchUtilities,
+  theme
+}) => {
+  matchUtilities({
+    'backdrop-hue-rotate': value => {
+      return {
+        '--tw-backdrop-hue-rotate': `hue-rotate(${value})`,
+        '@defaults backdrop-filter': {},
+        'backdrop-filter': 'var(--tw-backdrop-filter)'
+      };
+    }
+  }, {
+    values: theme('backdropHueRotate'),
+    type: 'any'
+  });
+};
+
+exports.backdropHueRotate = backdropHueRotate;
+
+let backdropInvert = ({
+  matchUtilities,
+  theme
+}) => {
+  matchUtilities({
+    'backdrop-invert': value => {
+      return {
+        '--tw-backdrop-invert': `invert(${value})`,
+        '@defaults backdrop-filter': {},
+        'backdrop-filter': 'var(--tw-backdrop-filter)'
+      };
+    }
+  }, {
+    values: theme('backdropInvert'),
+    type: 'any'
+  });
+};
+
+exports.backdropInvert = backdropInvert;
+
+let backdropOpacity = ({
+  matchUtilities,
+  theme
+}) => {
+  matchUtilities({
+    'backdrop-opacity': value => {
+      return {
+        '--tw-backdrop-opacity': `opacity(${value})`,
+        '@defaults backdrop-filter': {},
+        'backdrop-filter': 'var(--tw-backdrop-filter)'
+      };
+    }
+  }, {
+    values: theme('backdropOpacity'),
+    type: 'any'
+  });
+};
+
+exports.backdropOpacity = backdropOpacity;
+
+let backdropSaturate = ({
+  matchUtilities,
+  theme
+}) => {
+  matchUtilities({
+    'backdrop-saturate': value => {
+      return {
+        '--tw-backdrop-saturate': `saturate(${value})`,
+        '@defaults backdrop-filter': {},
+        'backdrop-filter': 'var(--tw-backdrop-filter)'
+      };
+    }
+  }, {
+    values: theme('backdropSaturate'),
+    type: 'any'
+  });
+};
+
+exports.backdropSaturate = backdropSaturate;
+
+let backdropSepia = ({
+  matchUtilities,
+  theme
+}) => {
+  matchUtilities({
+    'backdrop-sepia': value => {
+      return {
+        '--tw-backdrop-sepia': `sepia(${value})`,
+        '@defaults backdrop-filter': {},
+        'backdrop-filter': 'var(--tw-backdrop-filter)'
+      };
+    }
+  }, {
+    values: theme('backdropSepia'),
+    type: 'any'
+  });
+};
+
+exports.backdropSepia = backdropSepia;
+
+let backdropFilter = ({
+  addBase,
+  addUtilities
+}) => {
+  addBase({
+    '@defaults backdrop-filter': {
+      '--tw-backdrop-blur': 'var(--tw-empty,/*!*/ /*!*/)',
+      '--tw-backdrop-brightness': 'var(--tw-empty,/*!*/ /*!*/)',
+      '--tw-backdrop-contrast': 'var(--tw-empty,/*!*/ /*!*/)',
+      '--tw-backdrop-grayscale': 'var(--tw-empty,/*!*/ /*!*/)',
+      '--tw-backdrop-hue-rotate': 'var(--tw-empty,/*!*/ /*!*/)',
+      '--tw-backdrop-invert': 'var(--tw-empty,/*!*/ /*!*/)',
+      '--tw-backdrop-opacity': 'var(--tw-empty,/*!*/ /*!*/)',
+      '--tw-backdrop-saturate': 'var(--tw-empty,/*!*/ /*!*/)',
+      '--tw-backdrop-sepia': 'var(--tw-empty,/*!*/ /*!*/)',
+      '--tw-backdrop-filter': ['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(' ')
+    }
+  });
+  addUtilities({
+    '.backdrop-filter': {
+      '@defaults backdrop-filter': {},
+      'backdrop-filter': 'var(--tw-backdrop-filter)'
+    },
+    '.backdrop-filter-none': {
+      'backdrop-filter': 'none'
+    }
+  });
+};
+
+exports.backdropFilter = backdropFilter;
+
+let 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'),
+    type: 'any'
+  });
+};
+
+exports.transitionProperty = transitionProperty;
+let transitionDelay = (0, _createUtilityPlugin.default)('transitionDelay', [['delay', ['transitionDelay']]]);
+exports.transitionDelay = transitionDelay;
+let transitionDuration = (0, _createUtilityPlugin.default)('transitionDuration', [['duration', ['transitionDuration']]], {
+  filterDefault: true
+});
+exports.transitionDuration = transitionDuration;
+let transitionTimingFunction = (0, _createUtilityPlugin.default)('transitionTimingFunction', [['ease', ['transitionTimingFunction']]], {
+  filterDefault: true
+});
+exports.transitionTimingFunction = transitionTimingFunction;
+let willChange = (0, _createUtilityPlugin.default)('willChange', [['will-change', ['will-change']]]);
+exports.willChange = willChange;
+let content = (0, _createUtilityPlugin.default)('content');
+exports.content = content;