text: import { __assign } from "tslib";
  import _ from 'lodash';
  import { nonConfigurableClassNames } from '../lib/non-configurable';
  import { tailwindLabsPlugins } from '../lib/tailwindlabs-plugins';
  /**
   * Responsible for generating the types from a parsed config by ConfigScanner.
   */
  var ClassnamesGenerator = /** @class */ (function () {
      /**
       * Initializes a new instance of the `ClassesGenerator` class.
       * @param tailwindConfig The _parsed_ TailwindCSS Config.
       */
      function ClassnamesGenerator(parser) {
          var _this = this;
          /**
           * Get the generated classnames.
           */
          this.generate = function () {
              return {
                  regularClassnames: _this._generatedRegularClassnames,
                  pseudoClassnames: _this._generatedPseudoClassnames,
              };
          };
          this.isJitModeEnabled = function () { return _this._configParser.getMode() === 'jit'; };
          this.layout = function () {
              var classnames = __assign(__assign({}, nonConfigurableClassNames.layout), { objectPosition: Object.keys(_this._theme.objectPosition).map(function (x) { return 'object-' + x; }), inset: Object.keys(_this._theme.inset).flatMap(function (insetValue) {
                      return ['inset', 'inset-x', 'inset-y', 'top', 'right', 'bottom', 'left'].map(function (side) {
                          return insetValue.startsWith('-')
                              ? "-" + side + "-" + insetValue.substring(1)
                              : side + "-" + insetValue;
                      });
                  }), zIndex: Object.keys(_this._theme.zIndex).flatMap(function (zIndexValue) {
                      return zIndexValue.startsWith('-') ? "-z-" + zIndexValue.substring(1) : "z-" + zIndexValue;
                  }) });
              if (_this.isJitModeEnabled()) {
                  return __assign(__assign({}, classnames), { content: Object.keys(_this._theme.content).map(function (x) { return 'content-' + x; }) });
              }
              else {
                  return classnames;
              }
          };
          this.backgrounds = function () {
              return __assign(__assign({}, nonConfigurableClassNames.backgrounds), { backgroundOpacity: _this.getGeneratedClassesWithOpacities().backgroundOpacities, backgroundColor: _this.generateClassesWithColors('backgroundColor'), backgroundPosition: Object.keys(_this._theme.backgroundPosition).map(function (x) { return 'bg-' + x; }), backgroundSize: Object.keys(_this._theme.backgroundSize).map(function (x) { return 'bg-' + x; }), backgroundImage: Object.keys(_this._theme.backgroundImage).map(function (x) { return 'bg-' + x; }), gradientColorStops: _this.generateClassesWithColors('gradientColorStops').flatMap(function (val) {
                      return ['from', 'via', 'to'].map(function (x) { return x + val.replace('gradient', ''); });
                  }) });
          };
          this.borders = function () {
              var classnames = __assign(__assign({}, nonConfigurableClassNames.borders), { 
                  /* Dynamic border utils */
                  borderColor: _this.generateClassesWithColors('borderColor'), borderOpacity: _this.getGeneratedClassesWithOpacities().borderOpacities, borderRadius: Object.keys(_this._theme.borderRadius).flatMap(function (radius) {
                      var sides = ['t', 'r', 'b', 'l', 'tr', 'tl', 'br', 'bl'];
                      return sides.map(function (side) { return "rounded-" + side + "-" + radius; }).concat("rounded-" + radius);
                  }), borderWidth: Object.keys(_this._theme.borderWidth).flatMap(function (width) {
                      var sides = ['t', 'r', 'b', 'l'];
                      return sides.map(function (side) { return "border-" + side + "-" + width; }).concat("border-" + width);
                  }), 
                  /* Dynamic divide utilities */
                  divideColor: _this.generateClassesWithColors('divideColor'), divideOpacity: _this.getGeneratedClassesWithOpacities().divideOpacities, 
                  // divide width inherits its values from theme.borderWidth by default
                  // but theme.divideWidth overrides it.
                  divideWidth: Object.keys(_.isEmpty(_this._theme.divideWidth) ? _this._theme.borderWidth : _this._theme.divideWidth)
                      .concat('reverse')
                      .flatMap(function (width) { return ['x', 'y'].map(function (axis) { return "divide-" + axis + "-" + width; }); }), 
                  /* Dynamic ring utilities */
                  ringColor: _this.generateClassesWithColors('ringColor'), ringWidth: Object.keys(_this._theme.ringWidth)
                      .map(function (x) { return 'ring-' + x; })
                      .concat('inset'), ringOpacity: _this.getGeneratedClassesWithOpacities().ringOpacities, ringOffsetColor: _this.generateClassesWithColors('ringOffsetColor'), ringOffsetWidth: Object.keys(_this._theme.ringOffsetWidth).map(function (x) { return 'ring-offset-' + x; }) });
              return _this.isJitModeEnabled()
                  ? __assign(__assign({}, classnames), { caretColor: _this.generateClassesWithColors('caretColor') }) : classnames;
          };
          this.tables = function () {
              return nonConfigurableClassNames.tables;
          };
          this.effects = function () {
              return __assign(__assign({}, nonConfigurableClassNames.effects), { boxShadow: Object.keys(_this._theme.boxShadow).map(function (key) { return "shadow-" + key; }), opacity: _this.getGeneratedClassesWithOpacities().opacities });
          };
          this.transitionsAndAnimations = function () {
              return __assign(__assign({}, nonConfigurableClassNames.transitionsAndAnimations), { transitionProperty: Object.keys(_this._theme.transitionProperty).map(function (property) { return 'transition-' + property; }), transitionDuration: Object.keys(_this._theme.transitionDuration).map(function (value) { return 'duration-' + value; }), transitionTimingFunction: Object.keys(_this._theme.transitionTimingFunction)
                      .filter(function (k) { return k !== 'DEFAULT'; }) // The `DEFAULT` key does not correspond to a classname
                      .map(function (value) { return 'ease-' + value; }), transitionDelay: Object.keys(_this._theme.transitionDelay).map(function (value) { return 'delay-' + value; }), animation: Object.keys(_this._theme.animation).map(function (val) { return 'animate-' + val; }) });
          };
          this.transforms = function () {
              return __assign(__assign({}, nonConfigurableClassNames.transforms), { scale: ['', 'x-', 'y-'].flatMap(function (x) {
                      return Object.keys(_this._theme.scale).map(function (value) { return 'scale-' + x + value; });
                  }), rotate: Object.keys(_this._theme.rotate).map(function (value) {
                      return value.startsWith('-') ? '-rotate-' + value.slice(1) : "rotate-" + value;
                  }), 
                  // translate gets values from theme.spacing in addition to 50% and 100% variations
                  // by default and theme.translate overrides this behaviour.
                  translate: ['x', 'y'].flatMap(function (side) {
                      return Object.keys(_.isEmpty(_this._theme.translate) ? _this._theme.spacing : _this._theme.translate).map(function (value) {
                          return value.startsWith('-')
                              ? "-translate-" + side + "-" + value.slice(1)
                              : "translate-" + side + "-" + value;
                      });
                  }), skew: ['x', 'y'].flatMap(function (side) {
                      return Object.keys(_this._theme.skew).map(function (value) {
                          return value.startsWith('-') ? "-skew-" + side + "-" + value.substring(1) : "skew-" + side + "-" + value;
                      });
                  }), transformOrigin: Object.keys(_this._theme.transformOrigin).map(function (value) { return 'origin-' + value; }) });
          };
          this.interactivity = function () {
              return __assign(__assign({}, nonConfigurableClassNames.interactivity), { cursor: Object.keys(_this._theme.cursor).map(function (x) { return 'cursor-' + x; }), outline: Object.keys(_this._theme.outline).map(function (x) { return 'outline-' + x; }) });
          };
          this.SVG = function () {
              return __assign(__assign({}, nonConfigurableClassNames.svg), { fill: Object.keys(_this._theme.fill).map(function (value) { return 'fill-' + value; }), stroke: Object.keys(_this._theme.stroke).map(function (value) { return 'stroke-' + value; }), strokeWidth: Object.keys(_this._theme.strokeWidth).map(function (value) { return 'stroke-' + value; }) });
          };
          this.accessibility = function () {
              return __assign({}, nonConfigurableClassNames.accessibility);
          };
          this.filters = function () {
              return __assign(__assign({}, nonConfigurableClassNames.filters), { blur: Object.keys(_this._theme.blur).map(function (x) { return 'blur-' + x; }), brightness: Object.keys(_this._theme.brightness).map(function (x) { return 'brightness-' + x; }), contrast: Object.keys(_this._theme.contrast).map(function (x) { return 'contrast-' + x; }), dropShadow: Object.keys(_this._theme.dropShadow).map(function (x) { return 'drop-shadow-' + x; }), grayscale: Object.keys(_this._theme.grayscale).map(function (x) { return 'grayscale-' + x; }), hueRotate: Object.keys(_this._theme.hueRotate).map(function (x) { return 'hue-rotate-' + x; }), invert: Object.keys(_this._theme.invert).map(function (x) { return 'invert-' + x; }), saturate: Object.keys(_this._theme.saturate).map(function (x) { return 'saturate-' + x; }), sepia: Object.keys(_this._theme.sepia).map(function (x) { return 'sepia-' + x; }), backdropBlur: Object.keys(_this._theme.backdropBlur).map(function (x) { return 'backdrop-blur-' + x; }), backdropBrightness: Object.keys(_this._theme.backdropBrightness).map(function (x) { return 'backdrop-brightness-' + x; }), backdropContrast: Object.keys(_this._theme.backdropContrast).map(function (x) { return 'backdrop-contrast-' + x; }), backdropGrayscale: Object.keys(_this._theme.backdropGrayscale).map(function (x) { return 'backdrop-grayscale-' + x; }), backdropHueRotate: Object.keys(_this._theme.backdropHueRotate).map(function (x) { return 'backdrop-hue-rotate-' + x; }), backdropInvert: Object.keys(_this._theme.backdropInvert).map(function (x) { return 'backdrop-invert-' + x; }), backdropOpacity: Object.keys(_this._theme.backdropOpacity).map(function (x) { return 'backdrop-opacity-' + x; }), backdropSaturate: Object.keys(_this._theme.backdropSaturate).map(function (x) { return 'backdrop-saturate-' + x; }), backdropSepia: Object.keys(_this._theme.backdropSepia).map(function (x) { return 'backdrop-sepia-' + x; }) });
          };
          this.flexBox = function () {
              return __assign(__assign({}, nonConfigurableClassNames.flexBox), { flexGrow: Object.keys(_this._theme.flexGrow).map(function (key) { return "flex-grow-" + key; }), flexShrink: Object.keys(_this._theme.flexShrink).map(function (key) { return "flex-shrink-" + key; }), order: Object.keys(_this._theme.order).map(function (key) { return "order-" + key; }) });
          };
          this.grid = function () {
              return __assign(__assign({}, nonConfigurableClassNames.grid), { gridTemplateColumns: Object.keys(_this._theme.gridTemplateColumns).map(function (key) { return "grid-cols-" + key; }), gridAutoColumns: Object.keys(_this._theme.gridAutoColumns).map(function (key) { return "auto-cols-" + key; }), gridColumn: Object.keys(_this._theme.gridColumn).map(function (key) { return "col-" + key; }), gridColumnStart: Object.keys(_this._theme.gridColumnStart).map(function (key) { return "col-start-" + key; }), gridColumnEnd: Object.keys(_this._theme.gridColumnEnd).map(function (key) { return "col-end-" + key; }), gridTemplateRows: Object.keys(_this._theme.gridTemplateRows).map(function (key) { return "grid-rows-" + key; }), gridAutoRows: Object.keys(_this._theme.gridAutoRows).map(function (key) { return "auto-rows-" + key; }), gridRow: Object.keys(_this._theme.gridRow).map(function (key) { return "row-" + key; }), gridRowStart: Object.keys(_this._theme.gridRowStart).map(function (key) { return "row-start-" + key; }), gridRowEnd: Object.keys(_this._theme.gridRowEnd).map(function (key) { return "row-end-" + key; }), gap: ['gap-', 'gap-y-', 'gap-x-'].flatMap(function (x) {
                      // grid gap inherits its values from theme.spacing by default, but theme.gap overrides it.
                      return Object.keys(_.isEmpty(_this._theme.gap) ? _this._theme.spacing : _this._theme.gap).map(function (gapValue) { return x + gapValue; });
                  }) });
          };
          this.spacing = function () {
              var sides = ['', 'y', 'x', 't', 'r', 'b', 'l'];
              return {
                  padding: sides.flatMap(function (side) {
                      return Object.keys(_.isEmpty(_this._theme.padding) ? _this._theme.spacing : _this._theme.padding).map(function (value) {
                          return value.startsWith('-') ? "-p" + side + "-" + value.slice(1) : "p" + side + "-" + value;
                      });
                  }),
                  margin: sides.flatMap(function (side) {
                      return Object.keys(_.isEmpty(_this._theme.margin) ? _this._theme.spacing : _this._theme.margin).map(function (value) {
                          return value.startsWith('-') ? "-m" + side + "-" + value.slice(1) : "m" + side + "-" + value;
                      });
                  }),
                  space: ['x', 'y'].flatMap(function (axis) {
                      return Object.keys(_.isEmpty(_this._theme.space) ? _this._theme.spacing : _this._theme.space)
                          .concat('reverse')
                          .map(function (key) {
                          if (key.startsWith('-')) {
                              key = key.slice(1);
                              return '-space-' + axis + ("-" + key);
                          }
                          else {
                              return "space-" + axis + "-" + key;
                          }
                      });
                  }),
              };
          };
          this.sizing = function () {
              // prettier-ignore
              var extraWidthSizing = ['full', 'screen', 'auto', '1/2', '1/3', '2/3', '1/4', '2/4', '3/4',
                  '1/5', '2/5', '3/5', '4/5', '1/6', '2/6', '3/6', '4/6', '5/6', '1/12', '2/12', '3/12', '4/12',
                  '5/12', '6/12', '7/12', '8/12', '9/12', '10/12', '11/12'];
              var extraHeightSizing = ['full', 'screen'];
              return __assign(__assign({}, nonConfigurableClassNames.sizing), { 
                  // width values come from theme.spacing + `extraWidthSizing` by default
                  // and theme.width overrides this default behaviour.
                  // prettier-ignore
                  width: (_.isEmpty(_this._theme.width)
                      ? Object.keys(_this._theme.spacing).concat(extraWidthSizing)
                      : Object.keys(_this._theme.width)).map(function (x) { return 'w-' + x; }), minWidth: Object.keys(_this._theme.minWidth).map(function (x) { return 'min-w-' + x; }), maxWidth: Object.keys(_this._theme.maxWidth).map(function (x) { return 'max-w-' + x; }), 
                  // height values come from theme.spacing + `extraHeightSizing` by default
                  // and overridden by theme.height.
                  // prettier-ignore
                  height: (_.isEmpty(_this._theme.height)
                      ? Object.keys(_this._theme.spacing).concat(extraHeightSizing)
                      : Object.keys(_this._theme.height)).map(function (x) { return 'h-' + x; }), minHeight: Object.keys(_this._theme.minHeight).map(function (x) { return 'min-h-' + x; }), maxHeight: Object.keys(_this._theme.maxHeight).map(function (x) { return 'max-h-' + x; }) });
          };
          this.typography = function () {
              return __assign(__assign({}, nonConfigurableClassNames.typography), { fontFamily: Object.keys(_this._theme.fontFamily).map(function (value) { return 'font-' + value; }), fontSize: Object.keys(_this._theme.fontSize).map(function (size) { return 'text-' + size; }), fontWeight: Object.keys(_this._theme.fontWeight).map(function (weight) { return 'font-' + weight; }), letterSpacing: Object.keys(_this._theme.letterSpacing).map(function (value) { return 'tracking-' + value; }), lineHeight: Object.keys(_this._theme.lineHeight).map(function (value) { return 'leading-' + value; }), listStyleType: Object.keys(_this._theme.listStyleType).map(function (value) { return 'list-' + value; }), placeholderColor: _this.generateClassesWithColors('placeholderColor'), placeholderOpacity: _this.getGeneratedClassesWithOpacities().placeholderOpacities, textColor: _this.generateClassesWithColors('textColor'), textOpacity: _this.getGeneratedClassesWithOpacities().textOpacities });
          };
          // Generate the types for pseudo classes as hover:, focus: etc.
          // and return them in a string array to be parsed and converted into a template string that
          // will be a part of the final generated file. See `FileContentGenerator` class.
          this.pseudoClasses = function () {
              // Initialise a pseudoclasses variable with empty array value.
              var pseudoClasses = [];
              // prettier-ignore
              var allVariants = [
                  'responsive', 'motion-safe', 'motion-reduce', 'first', 'last', 'odd', 'even', 'visited', 'checked',
                  'group-hover', 'group-focus', 'focus-within', 'hover', 'focus', 'focus-visible', 'active', 'disabled',
                  // Exhaustive pseudo-classess
                  'only', 'first-of-type', 'last-of-type', 'only-of-type', 'target', 'default', 'indeterminate',
                  'placeholder-shown', 'autofill', 'required', 'valid', 'invalid', 'in-range', 'out-of-range',
                  // New peer-*, selection & marker variants and before/after
                  'peer-hover', 'peer-checked', 'peer-focus', 'selection', 'marker', 'before', 'after'
              ];
              // HACK: This block is just to make accessibility object align with other types object shape
              var variantsConfig = Object.entries(_.merge(_this._configParser.getVariants(), {
                  screenReaders: _this._configParser.getVariants().accessibility,
              }));
              var _loop_1 = function (regularClassGroupKey, pseudoClassesVariantsForKey) {
                  // Find all matching names from the generated regular classes with the key of the variants config
                  Object.keys(_this._generatedRegularClassnames).map(function (key) {
                      // If the current key is found to be a member of the generated regular classes group...
                      if (_.has(_this._generatedRegularClassnames[key], regularClassGroupKey)) {
                          // Get the value of the found generated class group
                          var generatedClassGroup = _.get(_this._generatedRegularClassnames, key + "." + regularClassGroupKey);
                          // If JIT compiler mode is enabled...
                          if (_this.isJitModeEnabled()) {
                              // Duplicate classnames with an important (!) prefix
                              var generatedClassGroupWithImportantPrefix = generatedClassGroup.map(function (cls) { return '!' + cls; });
                              // Append the classnames with important prefix to the regular classnames
                              generatedClassGroup = generatedClassGroup.concat(generatedClassGroupWithImportantPrefix);
                              // Append the classnames with important prefix to the pseudo classes array
                              generatedClassGroupWithImportantPrefix.map(function (cls) { return pseudoClasses.push(cls); });
                          }
                          // For every member of the found regular classes group...
                          generatedClassGroup.map(function (classname) {
                              var isDarkModeEnabled = _this._darkMode !== false;
                              // If JIT compiler mode is enabled...
                              if (_this.isJitModeEnabled()) {
                                  // Enable all variants
                                  pseudoClassesVariantsForKey = allVariants;
                                  // Add 'peer' utility classname. used with peer-* classnames
                                  pseudoClasses.push('peer');
                              }
                              // Generate the classname of each variant...
                              pseudoClassesVariantsForKey.map(function (variant) {
                                  if (variant === 'responsive') {
                                      // Get the breakpoints from config
                                      var breakpoints = _this._configParser.getThemeProperty('screens')[0];
                                      // Create the classname for each breakpoint
                                      breakpoints.map(function (breakpointVariant) {
                                          // Push the created classes to the pseudoClasses array
                                          pseudoClasses.push(breakpointVariant + _this._separator + _this._prefix + classname);
                                          // Add stackable dark and responsive pseudoclasses if the key has both variants
                                          if (pseudoClassesVariantsForKey.includes('dark') && isDarkModeEnabled) {
                                              pseudoClasses.push(breakpointVariant +
                                                  _this._separator +
                                                  'dark' +
                                                  _this._separator +
                                                  _this._prefix +
                                                  classname);
                                          }
                                      });
                                  }
                                  // Otherwise if the variant is 'dark'
                                  else if (variant === 'dark') {
                                      // If the dark mode is enabled...
                                      if (isDarkModeEnabled) {
                                          // Add the 'dark' prefix to the classname to create its pseudoclass
                                          pseudoClasses.push(variant + _this._separator + _this._prefix + classname);
                                      }
                                      // Otherwise, do nothing.
                                  }
                                  // Otherwise...
                                  else {
                                      // Append the variant to the classname and push to the pseudoClasses array.
                                      pseudoClasses.push(variant + _this._separator + _this._prefix + classname);
                                      // Add 'group' class if a the variant is group-hover, group-focus etc.
                                      if (variant.startsWith('group') && !pseudoClasses.includes('group'))
                                          pseudoClasses.push('group');
                                      // Add 'dark' class if dark mode stategy is set to "class"
                                      if (_this._darkMode === 'class' && !pseudoClasses.includes('dark'))
                                          pseudoClasses.push('dark');
                                  }
                              });
                          });
                      }
                      // Otherwise, skip and do nothing
                  });
              };
              // For every key-value pair in the variants section in tailwind config...
              // eslint-disable-next-line prefer-const
              for (var _i = 0, variantsConfig_1 = variantsConfig; _i < variantsConfig_1.length; _i++) {
                  var _a = variantsConfig_1[_i], regularClassGroupKey = _a[0], pseudoClassesVariantsForKey = _a[1];
                  _loop_1(regularClassGroupKey, pseudoClassesVariantsForKey);
              }
              // After all is done, return the generated pseudo classes types array
              return pseudoClasses;
          };
          this.generateClassesWithColors = function (property) {
              // Get the key-value pairs of the passed property
              var _a = _this._configParser.getThemeProperty(property), propertyKeys = _a[0], propertyValues = _a[1];
              // Convert the config property names into utility class names
              var utilName = property
                  .replace('Color', '') // gradientColorStops -> gradientStops, borderColor -> border etc.
                  .replace('Stops', '') // gradientStops -> gradient
                  .replace('ringOffset', 'ring-offset')
                  .replace('background', 'bg');
              var classnamesWithColors = propertyKeys
                  // Exclude `DEFAULT` keys from the keys collection as they do not correspond to any classname.
                  .filter(function (k) { return k !== 'DEFAULT'; })
                  // Then, for every key of the property...
                  .flatMap(function (colorName, i) {
                  // Get the value that corresponds to that key. NOTE: It can be `string` or an `object` of shades.
                  var colorValue = propertyValues[i];
                  // If the value is a nested object of color shades...
                  if (typeof colorValue === 'object' && colorValue !== null) {
                      // Loop over the deep objects and return the result for each key of the object.
                      return Object.keys(colorValue).flatMap(function (shade) {
                          if (utilName === 'border' && _this.isJitModeEnabled()) {
                              return ['', 't', 'r', 'b', 'l'].map(function (side) { return utilName + "-" + side + "-" + colorName + "-" + shade; });
                          }
                          else {
                              return utilName + "-" + colorName + "-" + shade;
                          }
                      });
                  }
                  // Otherwise...
                  else {
                      // Return the result of merging the utility name with color value
                      if (utilName === 'border' && _this.isJitModeEnabled()) {
                          return ['', 't', 'r', 'b', 'l'].map(function (side) { return utilName + "-" + (side.length > 0 ? side + '-' : '') + colorName; });
                      }
                      else {
                          return utilName + "-" + colorName;
                      }
                  }
              });
              // Add the opacities short hand suffix `/{opacity}`: "bg-red-100/50"
              var classnamesWithColorsAndOpacitySuffix = Object.keys(_this._configParser.getTheme().opacity).flatMap(function (op) { return classnamesWithColors.map(function (cls) { return cls + '/' + op; }); });
              // Return the result classnames based on whether JIT mode is enabled or not
              if (_this.isJitModeEnabled()) {
                  return classnamesWithColors.concat(classnamesWithColorsAndOpacitySuffix);
              }
              else {
                  return classnamesWithColors;
              }
          };
          this.getGeneratedClassesWithOpacities = function () {
              var allOpacities = _this._configParser.getTheme().opacity;
              var getOpacity = function (themePropertyName, outputNamePrefix) {
                  var generatedOpacities = generateOpacities(allOpacities, _this._theme, themePropertyName);
                  return Object.keys(generatedOpacities).map(function (opacity) { return outputNamePrefix + "-opacity-" + opacity; });
              };
              function generateOpacities(defaultOpacities, theme, property) {
                  var _a;
                  var themeOpacities = _.isEmpty(theme[property]) ? defaultOpacities : theme[property];
                  var extendedThemeOpacities = (_a = theme.extend) === null || _a === void 0 ? void 0 : _a[property];
                  var result = extendedThemeOpacities
                      ? __assign(__assign({}, themeOpacities), extendedThemeOpacities) : themeOpacities;
                  return result;
              }
              return {
                  opacities: Object.keys(allOpacities).map(function (opacity) { return "opacity-" + opacity; }),
                  textOpacities: getOpacity('textOpacity', 'text'),
                  backgroundOpacities: getOpacity('backgroundOpacity', 'bg'),
                  borderOpacities: getOpacity('borderOpacity', 'border'),
                  divideOpacities: getOpacity('divideOpacity', 'divide'),
                  placeholderOpacities: getOpacity('placeholderOpacity', 'placeholder'),
                  ringOpacities: getOpacity('ringOpacity', 'ring'),
              };
          };
          this._configParser = parser;
          this._prefix = this._configParser.getPrefix();
          this._separator = this._configParser.getSeparator();
          this._darkMode = this._configParser.getDarkMode();
          this._theme = this._configParser.getTheme();
          this._generatedRegularClassnames = {
              Accessibility: this.accessibility(),
              Backgrounds: this.backgrounds(),
              Borders: this.borders(),
              Tables: this.tables(),
              Effects: this.effects(),
              TransitionsAndAnimations: this.transitionsAndAnimations(),
              Filters: this.filters(),
              FlexBox: this.flexBox(),
              Grid: this.grid(),
              Spacing: this.spacing(),
              Interactivity: this.interactivity(),
              Layout: this.layout(),
              Sizing: this.sizing(),
              SVG: this.SVG(),
              Transforms: this.transforms(),
              Typography: this.typography(),
          };
          var configPlugins = this._configParser.getPlugins();
          if (configPlugins !== null) {
              this._generatedRegularClassnames.TailwindLabsPlugins = {};
              var pluginCustomForms = tailwindLabsPlugins.pluginCustomForms, pluginTypography = tailwindLabsPlugins.pluginTypography;
              if (!!configPlugins.pluginCustomForms)
                  this._generatedRegularClassnames.TailwindLabsPlugins.pluginCustomForms = pluginCustomForms;
              if (!!configPlugins.pluginTypography)
                  this._generatedRegularClassnames.TailwindLabsPlugins.pluginTypography = pluginTypography;
          }
          this._generatedPseudoClassnames = this.pseudoClasses();
      }
      return ClassnamesGenerator;
  }());
  export { ClassnamesGenerator };
  //# sourceMappingURL=ClassnamesGenerator.js.map