import { resolve } from 'path';
import defaultTailwindTheme, { keyframes as keyframes$1, animation as animation$1 } from 'tailwindcss/defaultTheme';
import tailwindCssRadixPlugin from 'tailwindcss-radix';
import tailwindCssFormsPlugin from '@tailwindcss/forms';
import tailwindCssTypographyPlugin from '@tailwindcss/typography';
import tailwindCssLineClampPlugin from '@tailwindcss/line-clamp';
import tailwindContainerQueriesPlugin from '@tailwindcss/container-queries';
import tailwindGridAreaPlugin from 'tailwindcss-grid-area';
import createVariantGroupTransformer from 'tailwind-group-variant';
import { iconsPlugin, getIconCollections } from '@egoist/tailwindcss-icons';
import plugin from 'tailwindcss/plugin';
import flattenColorPaletteImport from 'tailwindcss/lib/util/flattenColorPalette';
import tailwindColors from 'tailwindcss/colors';

// src/config/tailwindConfig.ts

// src/config/colors/helpers/generateColorGroup.ts
function generateColorGroup(colorGroup) {
  return (props) => {
    const resolvedColorEntries = Object.entries(props).map(([k, v]) => {
      const val = colorGroup[v];
      return [k, val];
    });
    return {
      ...Object.fromEntries(resolvedColorEntries),
      ...colorGroup
    };
  };
}

// src/config/colors/variousColors.ts
var variousColors = {
  "various-blue": generateColorGroup(tailwindColors.blue)({
    DEFAULT: "500",
    dark: "600",
    light: "300",
    soft: "100"
  }),
  "various-emerald": generateColorGroup(tailwindColors.emerald)({
    DEFAULT: "500",
    dark: "600",
    light: "300",
    soft: "100"
  }),
  "various-orange": generateColorGroup(tailwindColors.orange)({
    DEFAULT: "500",
    dark: "600",
    light: "300",
    soft: "100"
  }),
  "various-fuchsia": generateColorGroup(tailwindColors.fuchsia)({
    DEFAULT: "500",
    dark: "600",
    light: "300",
    soft: "100"
  }),
  "various-yellow": generateColorGroup(tailwindColors.yellow)({
    DEFAULT: "500",
    dark: "600",
    light: "300",
    soft: "100"
  }),
  "various-rose": generateColorGroup(tailwindColors.rose)({
    DEFAULT: "500",
    dark: "600",
    light: "300",
    soft: "100"
  }),
  "various-cyan": generateColorGroup(tailwindColors.cyan)({
    DEFAULT: "500",
    dark: "600",
    light: "300",
    soft: "100"
  }),
  "various-violet": generateColorGroup(tailwindColors.violet)({
    DEFAULT: "500",
    dark: "600",
    light: "300",
    soft: "100"
  }),
  "various-teal": generateColorGroup(tailwindColors.teal)({
    DEFAULT: "500",
    dark: "600",
    light: "300",
    soft: "100"
  }),
  "various-pink": generateColorGroup(tailwindColors.pink)({
    DEFAULT: "500",
    dark: "600",
    light: "300",
    soft: "100"
  }),
  "various-lime": generateColorGroup(tailwindColors.lime)({
    DEFAULT: "500",
    dark: "600",
    light: "300",
    soft: "100"
  }),
  "various-gray": generateColorGroup(tailwindColors.gray)({
    DEFAULT: "500",
    dark: "600",
    light: "300",
    soft: "100"
  }),
  "various-neutral": generateColorGroup(tailwindColors.neutral)({
    DEFAULT: "500",
    dark: "600",
    light: "300",
    soft: "100"
  }),
  "various-stone": generateColorGroup(tailwindColors.stone)({
    DEFAULT: "500",
    dark: "600",
    light: "300",
    soft: "100"
  }),
  "various-zinc": generateColorGroup(tailwindColors.zinc)({
    DEFAULT: "500",
    dark: "600",
    light: "300",
    soft: "100"
  }),
  "various-slate": generateColorGroup(tailwindColors.slate)({
    DEFAULT: "500",
    dark: "600",
    light: "300",
    soft: "100"
  })
};

// src/config/colors/colors.constants.ts
var colorScaleKeys = [
  "50",
  "100",
  "200",
  "300",
  "400",
  "500",
  "600",
  "700",
  "800",
  "900"
];
var hexAlphaCodes = {
  "100": "FF",
  "95": "F2",
  "90": "E6",
  "85": "D9",
  "80": "CC",
  "75": "BF",
  "70": "B3",
  "65": "A6",
  "60": "99",
  "55": "8C",
  "50": "80",
  "45": "73",
  "40": "66",
  "35": "59",
  "30": "4D",
  "25": "40",
  "23": "3B",
  "20": "33",
  "15": "26",
  "12": "1F",
  "10": "1A",
  "9": "17",
  "8": "14",
  "7": "12",
  "6": "0F",
  "5": "0D",
  "4": "0A",
  "3": "08",
  "2": "05",
  "1": "03",
  "0": "00"
};
var hexTransparencyPresetMap = {
  tint: "5",
  ghost: "20",
  subtle: "30",
  weak: "50",
  moderate: "70",
  high: "90",
  strong: "95",
  intense: "100"
};

// src/config/colors/helpers/arrayToColorGroup.ts
function arrayToColorGroup(colorArr) {
  const entries = colorArr.map(
    (color, index) => [colorScaleKeys[index], color]
  );
  return Object.fromEntries(entries);
}

// src/config/colors/helpers/generateHexAlpha.ts
function generateHexAlpha(hexColor, options) {
  const hex = hexColor.slice(0, 7);
  let hexAlphaCode;
  if (typeof options === "string") {
    hexAlphaCode = hexAlphaCodes[hexTransparencyPresetMap[options]];
  } else {
    const transparency = getTransparencyOption(options);
    const transparencyPreset = getTransparencyPresetOption(options);
    const code = transparencyPreset ? hexTransparencyPresetMap[transparencyPreset] : transparency;
    hexAlphaCode = code ? hexAlphaCodes[code] : void 0;
  }
  return `${hex}${hexAlphaCode ?? ""}`;
}
function getTransparencyPresetOption(option) {
  function isPreset(option2) {
    return "transparencyPreset" in option2;
  }
  return isPreset(option) ? option.transparencyPreset : void 0;
}
function getTransparencyOption(option) {
  function isPreset(option2) {
    return "transparency" in option2;
  }
  return isPreset(option) ? option.transparency : void 0;
}

// src/config/colors/helpers/generateHexAlphaColorGroup.ts
function generateHexAlphaColorGroup(hex, alphaOverrides, options) {
  const defaultColorGroup = {
    tint: generateHexAlpha(hex, "tint"),
    ghost: generateHexAlpha(hex, "ghost"),
    subtle: generateHexAlpha(hex, "subtle"),
    weak: generateHexAlpha(hex, "weak"),
    moderate: generateHexAlpha(hex, "moderate"),
    high: generateHexAlpha(hex, "high"),
    strong: generateHexAlpha(hex, "strong"),
    intense: generateHexAlpha(hex, "intense"),
    DEFAULT: hex
  };
  const overrides = Object.fromEntries(
    Object.entries(alphaOverrides ?? {}).map(([key, value]) => {
      if (!value)
        return [key, value];
      const { hexColor, ...hexAlphaOptions } = getHexAlphaOverrideOptions({
        hexColor: hex,
        overrideValue: value
      });
      return [key, generateHexAlpha(hexColor, hexAlphaOptions)];
    })
  );
  const colorGroup = Object.fromEntries(
    // eslint-disable-next-line @typescript-eslint/no-unused-vars
    Object.entries({ ...defaultColorGroup, ...overrides }).filter((entry) => Boolean(entry[1])).map(([key, value]) => {
      function getKey() {
        const { prefix: prefix2 } = options ?? {};
        if (!prefix2)
          return key;
        if (key === "DEFAULT")
          return prefix2;
        return `${prefix2}-${key}`;
      }
      return [getKey(), value];
    })
  );
  return colorGroup;
}
function getHexAlphaOverrideOptions({
  hexColor,
  overrideValue
}) {
  if (typeof overrideValue === "string" && overrideValue in hexTransparencyPresetMap) {
    return {
      transparencyPreset: overrideValue,
      hexColor
    };
  }
  if (typeof overrideValue === "string" && overrideValue in hexAlphaCodes) {
    return {
      transparency: overrideValue,
      hexColor
    };
  }
  if (typeof overrideValue === "string") {
    return {
      hexColor: overrideValue
    };
  }
  return {
    hexColor: overrideValue.hexColor ?? hexColor,
    transparencyPreset: getTransparencyPresetOption(overrideValue),
    transparency: getTransparencyOption(overrideValue)
  };
}
function notEmpty(value) {
  return value !== null && value !== void 0;
}

// src/config/colors/helpers/objectMap.ts
function objectMap(obj, fn) {
  return Object.fromEntries(
    Object.entries(obj).map(([k, v]) => fn({ key: k, value: v })).filter(notEmpty)
  );
}

// src/config/colors/colors.ts
var flattenColorPalette = typeof flattenColorPaletteImport === "function" ? flattenColorPaletteImport : flattenColorPaletteImport.default;
var black = "#000000";
var white = "#FFFFFF";
var neutral = generateColorGroup(
  arrayToColorGroup([
    "#f6f7f9",
    "#5e7495",
    "#425571",
    "#46556b",
    "#3d4c62",
    "#324156",
    "#2b374a",
    "#262f3e",
    "#212a38",
    "#1c2532"
  ])
)({
  light: "400",
  DEFAULT: "600",
  dark: "800",
  soft: "100"
});
var contentInverse = generateHexAlphaColorGroup("#e3e5e8", {
  intense: white,
  DEFAULT: "#d2d4d7"
});
var base = {
  DEFAULT: "#F6F6F6",
  inverse: "#0D0E11"
};
var highlightAlphaMap = {
  DEFAULT: "7",
  tint: "2",
  ghost: "4",
  subtle: "7",
  weak: "10",
  moderate: "12",
  high: "15",
  strong: "25",
  intense: "30"
};
var paletteColorsConfig = {
  highlight: generateHexAlphaColorGroup(neutral[500], highlightAlphaMap),
  "highlight-inverse": generateHexAlphaColorGroup(
    variousColors["various-slate"].light,
    highlightAlphaMap
  ),
  white,
  black,
  base,
  neutral,
  heart: generateColorGroup({
    "50": "#fff0fa",
    "100": "#ffe4f7",
    "200": "#ffc9f0",
    "300": "#ff9ce2",
    "400": "#ff5fcc",
    "500": "#ff30b4",
    "600": "#f50d93",
    "700": "#e6007e",
    "800": "#b00460",
    "900": "#920952"
  })({
    DEFAULT: "700",
    dark: "800",
    light: "400",
    soft: "100"
  }),
  info: generateColorGroup(tailwindColors.cyan)({
    DEFAULT: "500",
    dark: "600",
    light: "300",
    soft: "100"
  }),
  caution: generateColorGroup({
    "50": "#ffffea",
    "100": "#fffbc5",
    "200": "#fff885",
    "300": "#ffed46",
    "400": "#ffdf1b",
    "500": "#ffbf00",
    "600": "#e29300",
    "700": "#bb6802",
    "800": "#985008",
    "900": "#7c420b"
  })({ DEFAULT: "500", dark: "600", light: "300", soft: "100" }),
  danger: generateColorGroup({
    "50": "#fff1f2",
    "100": "#ffdfe1",
    "200": "#ffc4c8",
    "300": "#ff9ba2",
    "400": "#ff626e",
    "500": "#ff3140",
    "600": "#f22837",
    "700": "#cb0a18",
    "800": "#a70d18",
    "900": "#8a121b"
  })({ DEFAULT: "500", dark: "700", light: "300", soft: "100" }),
  success: generateColorGroup(tailwindColors.emerald)({
    DEFAULT: "500",
    dark: "600",
    light: "300",
    soft: "100"
  }),
  gray: generateColorGroup(tailwindColors.gray)({
    DEFAULT: "500",
    dark: "600",
    light: "300",
    soft: "100"
  }),
  content: generateHexAlphaColorGroup("#15181E", {
    DEFAULT: "high",
    ghost: { hexColor: neutral["500"], transparencyPreset: "ghost" }
  }),
  "content-inverse": contentInverse,
  boundary: {
    focus: base.inverse,
    ...generateHexAlphaColorGroup(neutral[300], {
      DEFAULT: "subtle"
    })
  },
  "boundary-inverse": {
    focus: contentInverse.weak,
    ...generateHexAlphaColorGroup(base.DEFAULT, { DEFAULT: "subtle" })
  },
  surface: generateColorGroup(
    arrayToColorGroup([
      "#ffffff",
      "#f5f7f9",
      "#eceff3",
      "#e3e7ed",
      "#dae0e8",
      "#d3dae4",
      "#ccd5e0",
      "#c5d0de",
      "#bfccdb",
      "#b9c8d9"
    ])
  )({ DEFAULT: "50", dark: "400", light: "200", soft: "100" }),
  "surface-inverse": generateColorGroup(
    arrayToColorGroup([
      "#2d3542",
      "#282f3a",
      "#232832",
      "#1e222a",
      "#1a1d23",
      "#181b21",
      "#171a20",
      "#16181e",
      "#14171d",
      "#13151b"
    ])
  )({ DEFAULT: "400", dark: "700", light: "200", soft: "500" }),
  distinct: {
    "1": variousColors["various-blue"].DEFAULT,
    "2": variousColors["various-emerald"].DEFAULT,
    "3": variousColors["various-orange"].DEFAULT,
    "4": variousColors["various-fuchsia"].DEFAULT,
    "5": variousColors["various-yellow"].DEFAULT,
    "6": variousColors["various-rose"].DEFAULT,
    "7": variousColors["various-cyan"].DEFAULT,
    "8": variousColors["various-violet"].DEFAULT,
    "9": variousColors["various-teal"].DEFAULT,
    "10": variousColors["various-pink"].DEFAULT,
    "11": variousColors["various-lime"].DEFAULT,
    "12": variousColors["various-gray"].DEFAULT
  },
  ...variousColors
};
var utilityColorsConfig = {
  inherit: tailwindColors.inherit,
  current: tailwindColors.current,
  transparent: tailwindColors.transparent
};
var colorPalette = {
  ...utilityColorsConfig,
  ...objectMap(
    flattenColorPalette(paletteColorsConfig),
    ({ key, value }) => {
      return [`palette-${key}`, value];
    }
  )
};

// src/config/colors/helpers/hexToRgb.ts
var hexCharacters = "a-f\\d";
var match3or4Hex = `#?[${hexCharacters}]{3}[${hexCharacters}]?`;
var match6or8Hex = `#?[${hexCharacters}]{6}([${hexCharacters}]{2})?`;
var nonHexChars = new RegExp(`[^#${hexCharacters}]`, "gi");
var validHexSize = new RegExp(`^${match3or4Hex}$|^${match6or8Hex}$`, "i");
function hexRgb(hex, options = {}) {
  if (typeof hex !== "string" || nonHexChars.test(hex) || !validHexSize.test(hex)) {
    throw new TypeError("Expected a valid hex string");
  }
  hex = hex.replace(/^#/, "");
  let alphaFromHex = 1;
  if (hex.length === 8) {
    alphaFromHex = Number.parseInt(hex.slice(6, 8), 16) / 255;
    hex = hex.slice(0, 6);
  }
  if (hex.length === 4) {
    alphaFromHex = Number.parseInt(hex.slice(3, 4).repeat(2), 16) / 255;
    hex = hex.slice(0, 3);
  }
  if (hex.length === 3) {
    hex = hex[0] + hex[0] + hex[1] + hex[1] + hex[2] + hex[2];
  }
  const number = Number.parseInt(hex, 16);
  const red = number >> 16;
  const green = number >> 8 & 255;
  const blue = number & 255;
  const alpha = typeof options.alpha === "number" ? options.alpha : alphaFromHex;
  return { red, green, blue, alpha };
}

// src/config/colors/helpers/cssVariables.ts
function getCssColorVariable(str) {
  return `--color-${str}`;
}
function getCssAlphaVariable(str) {
  return `--alpha-${str}`;
}
function getCssVariableValue(cssVariable, alphaCssVariable) {
  if (alphaCssVariable) {
    return `rgb(var(${cssVariable}) / var(${alphaCssVariable}))`;
  }
  return `rgb(var(${cssVariable}) / <alpha-value>)`;
}
function getCssVariableRgb(hex) {
  const { red, green, blue, alpha } = hexRgb(hex);
  return { rgb: `${red} ${green} ${blue}`, alpha };
}

// src/config/colors/color-schemes/schemes/common-scheme.ts
var commonScheme = {
  all: {
    heart: "palette-heart",
    "heart-light": "palette-heart-light",
    "heart-dark": "palette-heart-dark",
    "heart-soft": "palette-heart-soft",
    info: "palette-info",
    "info-light": "palette-info-light",
    "info-dark": "palette-info-dark",
    "info-soft": "palette-info-soft",
    success: "palette-success",
    "success-light": "palette-success-light",
    "success-dark": "palette-success-dark",
    "success-soft": "palette-success-soft",
    danger: "palette-danger",
    "danger-light": "palette-danger-light",
    "danger-dark": "palette-danger-dark",
    "danger-soft": "palette-danger-soft",
    caution: "palette-caution",
    "caution-light": "palette-caution-light",
    "caution-dark": "palette-caution-dark",
    "caution-soft": "palette-caution-soft",
    "primary-content": "palette-content-inverse-intense",
    "secondary-content": "palette-content-inverse-intense"
  },
  lightMode: {
    base: "palette-base",
    boundary: "palette-various-slate-300",
    "boundary-tint": "palette-various-slate-50",
    "boundary-ghost": "palette-various-slate-100",
    "boundary-subtle": "palette-various-slate-200",
    "boundary-weak": "palette-various-slate-300",
    "boundary-moderate": "palette-various-slate-400",
    "boundary-high": "palette-various-slate-500",
    "boundary-strong": "palette-various-slate-600",
    "boundary-intense": "palette-various-slate-700",
    highlight: "palette-highlight",
    "highlight-tint": "palette-highlight-tint",
    "highlight-ghost": "palette-highlight-ghost",
    "highlight-subtle": "palette-highlight-subtle",
    "highlight-weak": "palette-highlight-weak",
    "highlight-moderate": "palette-highlight-moderate",
    "highlight-high": "palette-highlight-high",
    "highlight-strong": "palette-highlight-strong",
    "highlight-intense": "palette-highlight-intense",
    content: "palette-content",
    "content-tint": "palette-content-tint",
    "content-ghost": "palette-content-ghost",
    "content-subtle": "palette-content-subtle",
    "content-weak": "palette-content-weak",
    "content-moderate": "palette-content-moderate",
    "content-high": "palette-content-high",
    "content-strong": "palette-content-strong",
    "content-intense": "palette-content-intense",
    "content-min-contrast": "palette-neutral-light",
    "content-max-contrast": "palette-content-intense",
    "inverse-content-max-contrast": "palette-content-inverse-intense",
    "inverse-content-min-contrast": "palette-neutral-light",
    inverse: "palette-surface-inverse",
    "inverse-light": "palette-surface-inverse-light",
    "inverse-dark": "palette-surface-inverse-dark",
    "inverse-soft": "palette-surface-inverse-soft",
    "primary-content-max-contrast": "palette-content-intense",
    "primary-content-min-contrast": "palette-neutral-light",
    "secondary-content-max-contrast": "palette-content-high",
    "secondary-content-min-contrast": "palette-neutral-300",
    "inverse-content": "palette-content-intense"
  },
  darkMode: {
    base: "palette-base-inverse",
    boundary: "palette-various-zinc-700",
    "boundary-tint": "palette-various-zinc-950",
    "boundary-ghost": "palette-various-zinc-900",
    "boundary-subtle": "palette-various-zinc-800",
    "boundary-weak": "palette-various-zinc-700",
    "boundary-moderate": "palette-various-zinc-600",
    "boundary-high": "palette-various-zinc-500",
    "boundary-intense": "palette-various-zinc-400",
    highlight: "palette-highlight-inverse",
    "highlight-tint": "palette-highlight-inverse-tint",
    "highlight-ghost": "palette-highlight-inverse-ghost",
    "highlight-subtle": "palette-highlight-inverse-subtle",
    "highlight-weak": "palette-highlight-inverse-weak",
    "highlight-moderate": "palette-highlight-inverse-moderate",
    "highlight-high": "palette-highlight-inverse-high",
    "highlight-strong": "palette-highlight-inverse-strong",
    "highlight-intense": "palette-highlight-inverse-intense",
    content: "palette-content-inverse",
    "content-tint": "palette-content-inverse-tint",
    "content-ghost": "palette-content-inverse-ghost",
    "content-subtle": "palette-content-inverse-subtle",
    "content-weak": "palette-content-inverse-weak",
    "content-moderate": "palette-content-inverse-moderate",
    "content-high": "palette-content-inverse-high",
    "content-strong": "palette-content-inverse-strong",
    "content-intense": "palette-content-inverse-intense",
    "content-min-contrast": "palette-neutral-50",
    "content-max-contrast": "palette-content-inverse-intense",
    "inverse-content-max-contrast": "palette-content-intense",
    "inverse-content-min-contrast": "palette-neutral",
    inverse: "palette-surface",
    "inverse-light": "palette-surface-light",
    "inverse-dark": "palette-surface-dark",
    "inverse-soft": "palette-surface-soft",
    "primary-content-max-contrast": "palette-content-inverse-intense",
    "primary-content-min-contrast": "palette-various-slate-300",
    "secondary-content-max-contrast": "palette-content-inverse-high",
    "secondary-content-min-contrast": "palette-various-slate-300",
    "inverse-content": "palette-content-inverse-intense"
  }
};

// src/config/colors/color-schemes/color-schemes.helpers.ts
function resolveColorScheme(scheme) {
  return objectMap(scheme, ({ key, value }) => {
    const color = colorPalette[value];
    return [key, color];
  });
}
function getExtendedConfig(options) {
  if ("extend" in options)
    return options.extend;
  return void 0;
}
function defineColorScheme(options) {
  const { name, colorMode, scheme } = options;
  const extendedConfig = getExtendedConfig(options);
  const { scheme: extendedScheme } = extendedConfig ?? {};
  const colorModeScheme = (colorMode ?? extendedConfig?.colorMode) === "dark" ? commonScheme.darkMode : commonScheme.lightMode;
  const resolvedScheme = resolveColorScheme({ ...commonScheme.all, ...colorModeScheme, ...scheme });
  return {
    ...extendedConfig,
    name,
    colorMode,
    scheme: { ...extendedScheme, ...resolvedScheme },
    unresolvedScheme: scheme
  };
}
function defineColorSchemes(resolvedSchemeConfigs) {
  const colorSchemes2 = resolvedSchemeConfigs.reduce((acc, cur) => {
    acc[cur.name] = cur.scheme;
    return acc;
  }, {});
  const colorSchemeCssVariableClasses2 = getColorSchemesCssVariableClasses(colorSchemes2);
  const lightDefault = colorSchemes2.default;
  const rootScheme = colorSchemeCssVariableClasses2[":root"];
  const colorSchemeTokens2 = getColorSchemeTokens(lightDefault, rootScheme);
  return {
    colorSchemes: colorSchemes2,
    colorSchemeCssVariableClasses: colorSchemeCssVariableClasses2,
    colorSchemeTokens: colorSchemeTokens2,
    colorSchemeConfigs: resolvedSchemeConfigs
  };
}
function getColorSchemeTokens(scheme, variableMap) {
  return objectMap(scheme, ({ key: token }) => {
    const cssVariable = getCssColorVariable(token);
    const alphaVariable = getCssAlphaVariable(token);
    return [
      `${token}`,
      getCssVariableValue(cssVariable, alphaVariable in variableMap ? alphaVariable : void 0)
    ];
  });
}
function getColorSchemesCssVariableClasses(colorSchemes2) {
  return Object.fromEntries(
    Object.entries(colorSchemes2).flatMap(([schemeKey, value]) => {
      const cssThemeVariablesMap = Object.fromEntries(
        Object.entries(value).flatMap(([themeToken, hex]) => {
          const colorVariableName = getCssColorVariable(themeToken);
          const alphaVariableName = getCssAlphaVariable(themeToken);
          const { rgb, alpha } = getCssVariableRgb(hex);
          const entries = [[colorVariableName, rgb]];
          if (alpha >= 0 && alpha !== 1) {
            entries.push([alphaVariableName, `${parseFloat(alpha.toFixed(2))}`]);
          }
          return entries;
        })
      );
      return getColorSchemeCssVariableNames(schemeKey).map((cssVariableName) => {
        return [cssVariableName, { color: value.content, ...cssThemeVariablesMap }];
      });
    })
  );
}
function getColorSchemeCssVariableNames(schemeKey) {
  const [mode, ...rest] = schemeKey.split("/");
  const baseSchemeKey = rest.join("/");
  const dataColorSchemeClass = `[data-color-scheme="${schemeKey}"]`;
  const isDarkMode = mode === "dark";
  if (schemeKey === "default") {
    return [":root", dataColorSchemeClass];
  }
  if (schemeKey === "dark/default") {
    return ['[data-mode="dark"]', `[data-mode="dark"] [data-color-scheme="default"]`];
  }
  if (isDarkMode) {
    return [`[data-mode="dark"] [data-color-scheme="${baseSchemeKey}"]`];
  }
  return [dataColorSchemeClass];
}

// src/config/colors/color-schemes/schemes/danger.ts
var dangerScheme = defineColorScheme({
  name: "danger",
  colorMode: "dark",
  scheme: {
    primary: "palette-danger-100",
    "primary-light": "palette-danger-50",
    "primary-soft": "palette-danger-200",
    "primary-dark": "palette-danger-50",
    "primary-content": "palette-danger",
    secondary: "palette-various-rose-800",
    "secondary-dark": "palette-various-rose-900",
    "secondary-light": "palette-various-rose-700",
    "secondary-soft": "palette-various-rose-700",
    "secondary-content": "palette-content-intense",
    surface: "palette-danger-500",
    "surface-soft": "palette-danger-400",
    "surface-light": "palette-danger-300",
    "surface-dark": "palette-danger-600"
  }
});
var danger_default = dangerScheme;

// src/config/colors/color-schemes/schemes/neutral.base.ts
var neutralBaseColors = {
  boundary: "palette-various-slate-600",
  "boundary-tint": "palette-various-slate-900",
  "boundary-ghost": "palette-various-slate-800",
  "boundary-subtle": "palette-various-slate-700",
  "boundary-weak": "palette-various-slate-600",
  "boundary-moderate": "palette-various-slate-500",
  "boundary-high": "palette-various-slate-400",
  "boundary-strong": "palette-various-slate-300",
  "boundary-intense": "palette-various-slate-200",
  surface: "palette-neutral-400",
  "surface-light": "palette-neutral-200",
  "surface-dark": "palette-neutral-dark",
  "surface-soft": "palette-neutral-300",
  primary: "palette-various-slate-400",
  "primary-light": "palette-various-slate-300",
  "primary-dark": "palette-various-slate-500",
  "primary-soft": "palette-various-slate-100",
  secondary: "palette-various-slate-500",
  "secondary-light": "palette-various-slate-400",
  "secondary-dark": "palette-various-slate-600",
  "secondary-soft": "palette-various-slate-400"
};

// src/config/colors/color-schemes/schemes/neutral.ts
var neutral_default = defineColorScheme({
  name: "neutral",
  colorMode: "dark",
  scheme: {
    ...neutralBaseColors,
    surface: "palette-neutral-600",
    "surface-light": "palette-neutral-light",
    "surface-dark": "palette-neutral-dark",
    "surface-soft": "palette-neutral-500",
    secondary: "palette-various-slate-500",
    "secondary-light": "palette-various-slate-400",
    "secondary-dark": "palette-various-slate-600",
    "secondary-soft": "palette-various-slate-400"
  }
});

// src/config/colors/color-schemes/schemes/neutral-dark.ts
var neutral_dark_default = defineColorScheme({
  name: "neutral-dark",
  colorMode: "dark",
  scheme: {
    ...neutralBaseColors,
    surface: "palette-neutral-800",
    "surface-light": "palette-neutral-600",
    "surface-dark": "palette-neutral-900",
    "surface-soft": "palette-neutral-700",
    secondary: "palette-various-slate-500",
    "secondary-light": "palette-various-slate-400",
    "secondary-dark": "palette-various-slate-600",
    "secondary-soft": "palette-various-slate-200"
  }
});

// src/config/colors/color-schemes/schemes/neutral-light.ts
var neutral_light_default = defineColorScheme({
  name: "neutral-light",
  colorMode: "dark",
  scheme: {
    ...neutralBaseColors,
    boundary: "palette-various-slate-500",
    "boundary-tint": "palette-various-slate-800",
    "boundary-ghost": "palette-various-slate-700",
    "boundary-subtle": "palette-various-slate-600",
    "boundary-weak": "palette-various-slate-500",
    "boundary-moderate": "palette-various-slate-400",
    "boundary-high": "palette-various-slate-300",
    "boundary-strong": "palette-various-slate-200",
    "boundary-intense": "palette-various-slate-100",
    surface: "palette-neutral-400",
    "surface-light": "palette-neutral-200",
    "surface-dark": "palette-neutral-dark",
    "surface-soft": "palette-neutral-300",
    secondary: "palette-various-slate-500",
    "secondary-light": "palette-various-slate-400",
    "secondary-dark": "palette-various-slate-600",
    "secondary-soft": "palette-various-slate-400"
  }
});

// src/config/colors/color-schemes/schemes/surface.ts
var surface_default = defineColorScheme({
  name: "surface",
  colorMode: "light",
  scheme: {
    highlight: "palette-highlight",
    "highlight-weak": "palette-highlight-weak",
    "highlight-moderate": "palette-highlight-moderate",
    "highlight-high": "palette-highlight-high",
    "highlight-strong": "palette-highlight-strong",
    surface: "palette-surface",
    "surface-light": "palette-surface-100",
    "surface-dark": "palette-surface-dark",
    "surface-soft": "palette-surface-50",
    primary: "palette-neutral-500",
    "primary-light": "palette-neutral-300",
    "primary-dark": "palette-neutral-600",
    "primary-soft": "palette-various-slate-200",
    secondary: "palette-various-slate-400",
    "secondary-light": "palette-various-slate-300",
    "secondary-dark": "palette-various-slate-500",
    "secondary-soft": "palette-various-slate-100"
  }
});

// src/config/colors/color-schemes/schemes/surface.darkmode.ts
var surface_darkmode_default = defineColorScheme({
  name: "dark/surface",
  colorMode: "dark",
  scheme: {
    surface: "palette-surface-inverse",
    "surface-light": "palette-surface-inverse-300",
    "surface-dark": "palette-surface-inverse-500",
    "surface-soft": "palette-surface-inverse-200",
    primary: "palette-various-slate-500",
    "primary-light": "palette-various-slate-400",
    "primary-dark": "palette-various-slate-600",
    "primary-soft": "palette-various-slate-200",
    secondary: "palette-various-slate-600",
    "secondary-light": "palette-various-slate-500",
    "secondary-dark": "palette-various-slate-500",
    "secondary-soft": "palette-various-slate-300"
  }
});

// src/config/colors/color-schemes/schemes/surface-light.ts
var surface_light_default = defineColorScheme({
  name: "surface-light",
  colorMode: "light",
  scheme: {
    surface: "palette-surface-light",
    "surface-light": "palette-surface-100",
    "surface-dark": "palette-surface-dark",
    "surface-soft": "palette-surface-50",
    primary: "palette-neutral-500",
    "primary-light": "palette-neutral-400",
    "primary-dark": "palette-neutral-600",
    "primary-soft": "palette-various-slate-200",
    secondary: "palette-various-slate-400",
    "secondary-light": "palette-various-slate-300",
    "secondary-dark": "palette-various-slate-500",
    "secondary-soft": "palette-various-slate-100"
  }
});

// src/config/colors/color-schemes/schemes/surface-light.darkmode.ts
var surface_light_darkmode_default = defineColorScheme({
  name: "dark/surface-light",
  colorMode: "dark",
  scheme: {
    surface: "palette-surface-inverse-light",
    "surface-light": "palette-surface-inverse-100",
    "surface-dark": "palette-surface-inverse-300",
    "surface-soft": "palette-surface-inverse-50",
    primary: "palette-various-slate-500",
    "primary-light": "palette-various-slate-400",
    "primary-dark": "palette-various-slate-600",
    "primary-soft": "palette-various-slate-200",
    secondary: "palette-various-slate-600",
    "secondary-light": "palette-various-slate-500",
    "secondary-dark": "palette-various-slate-500",
    "secondary-soft": "palette-various-slate-300"
  }
});

// src/config/colors/color-schemes/schemes/surface-dark.ts
var surface_dark_default = defineColorScheme({
  name: "surface-dark",
  colorMode: "light",
  scheme: {
    surface: "palette-surface-dark",
    "surface-light": "palette-surface-50",
    "surface-dark": "palette-surface-800",
    "surface-soft": "palette-surface-100",
    primary: "palette-neutral-500",
    "primary-light": "palette-neutral-400",
    "primary-dark": "palette-neutral-600",
    "primary-soft": "palette-various-slate-200",
    secondary: "palette-various-slate-400",
    "secondary-light": "palette-various-slate-300",
    "secondary-dark": "palette-various-slate-500",
    "secondary-soft": "palette-various-slate-100"
  }
});

// src/config/colors/color-schemes/schemes/surface-dark.darkmode.ts
var surface_dark_darkmode_default = defineColorScheme({
  name: "dark/surface-dark",
  colorMode: "dark",
  scheme: {
    surface: "palette-surface-inverse-dark",
    "surface-light": "palette-surface-inverse-600",
    "surface-dark": "palette-surface-inverse-800",
    "surface-soft": "palette-surface-inverse-600",
    primary: "palette-various-slate-500",
    "primary-light": "palette-various-slate-400",
    "primary-dark": "palette-various-slate-600",
    "primary-soft": "palette-various-slate-200",
    secondary: "palette-various-slate-600",
    "secondary-light": "palette-various-slate-500",
    "secondary-dark": "palette-various-slate-500",
    "secondary-soft": "palette-various-slate-300"
  }
});

// src/config/colors/color-schemes/schemes/default.ts
var default_default = defineColorScheme({
  name: "default",
  colorMode: "light",
  scheme: surface_default.unresolvedScheme
});

// src/config/colors/color-schemes/schemes/default.darkmode.ts
var default_darkmode_default = defineColorScheme({
  name: "dark/default",
  colorMode: "dark",
  scheme: {
    surface: "palette-surface-inverse",
    "surface-light": "palette-surface-inverse-light",
    "surface-dark": "palette-surface-inverse-dark",
    "surface-soft": "palette-surface-inverse-soft",
    primary: "palette-neutral-500",
    "primary-light": "palette-neutral-300",
    "primary-dark": "palette-neutral-600",
    "primary-soft": "palette-various-slate-200",
    secondary: "palette-neutral-800",
    "secondary-light": "palette-neutral-700",
    "secondary-dark": "palette-neutral-900",
    "secondary-soft": "palette-neutral-500"
  }
});

// src/config/colors/color-schemes/schemes/inverse-scheme.ts
var inverseColorSchemes = [
  defineColorScheme({
    name: "inverse",
    colorMode: "dark",
    extend: surface_darkmode_default
  }),
  defineColorScheme({
    name: "inverse-light",
    colorMode: "dark",
    extend: surface_light_darkmode_default
  }),
  defineColorScheme({
    name: "inverse-dark",
    colorMode: "dark",
    extend: surface_dark_darkmode_default
  }),
  defineColorScheme({
    name: "dark/inverse",
    colorMode: "light",
    extend: surface_default
  }),
  defineColorScheme({
    name: "dark/inverse-light",
    colorMode: "light",
    extend: surface_light_default
  }),
  defineColorScheme({
    name: "dark/inverse-dark",
    colorMode: "light",
    extend: surface_dark_default
  })
];
var inverse_scheme_default = inverseColorSchemes;

// src/config/colors/color-schemes/schemes/state-schemes.ts
var stateColors = ["success", "info", "danger", "caution", "heart"];
var state_schemes_default = stateColors.flatMap((color) => {
  const config2 = {
    name: color,
    colorMode: "light",
    scheme: {
      "primary-content-max-contrast": `palette-${color}-500`,
      "primary-content-min-contrast": `palette-${color}-600`,
      content: `palette-white`,
      surface: `palette-${color}`,
      "surface-light": `palette-${color}-light`,
      "surface-dark": `palette-${color}-dark`,
      "surface-soft": `palette-${color}-soft`,
      primary: `palette-${color}-500`,
      "primary-light": `palette-${color}-300`,
      "primary-dark": `palette-${color}-600`,
      "primary-soft": `palette-${color}-200`,
      secondary: `palette-${color}-400`,
      "secondary-light": `palette-${color}-300`,
      "secondary-dark": `palette-${color}-500`,
      "secondary-soft": `palette-${color}-100`
    }
  };
  const darkConfig = {
    ...config2,
    name: `dark/${color}`,
    colorMode: "dark"
  };
  return [config2, darkConfig].map((e) => defineColorScheme(e));
});

// src/config/colors/color-schemes/schemes/index.ts
var colorSchemeConfigs = [
  default_default,
  default_darkmode_default,
  danger_default,
  neutral_default,
  neutral_dark_default,
  neutral_light_default,
  surface_default,
  surface_light_default,
  surface_dark_default,
  surface_darkmode_default,
  surface_light_darkmode_default,
  surface_dark_darkmode_default,
  ...inverse_scheme_default,
  ...state_schemes_default
];

// src/config/colors/color-schemes/color-schemes.ts
var mainColorSchemeNames = [
  "default",
  "surface",
  "surface-light",
  "surface-dark",
  "neutral",
  "neutral-light",
  "neutral-dark",
  "inverse",
  "inverse-light",
  "inverse-dark"
];
var colorSchemeBaseTokens = [
  "primary",
  "secondary",
  "inverse",
  "surface",
  "heart",
  "info",
  "success",
  "caution",
  "danger",
  "highlight",
  "boundary",
  "content"
];
var appStateColorSchemeNames = [
  "danger",
  "info",
  "danger",
  "caution",
  "success"
];
var colorSchemeNames = [
  ...mainColorSchemeNames,
  ...appStateColorSchemeNames
];
var colorSchemeDataAttributes = Object.fromEntries(
  colorSchemeNames.map((schemeName) => {
    return [`${schemeName}-color-scheme`, `color-scheme=${schemeName}`];
  })
);
var { colorSchemeTokens, colorSchemeCssVariableClasses, colorSchemes } = defineColorSchemes(colorSchemeConfigs);

// src/config/plugins/multi-theme-plugin.ts
function multiThemePlugin() {
  return plugin(({ addBase, theme }) => {
    addBase({
      html: {
        color: theme("colors.content"),
        backgroundColor: theme("colors.base")
      },
      h1: { color: theme("colors.content.strong") },
      h2: { color: theme("colors.content.strong") },
      h3: { color: theme("colors.content.strong") },
      h4: { color: theme("colors.content.strong") },
      h5: { color: theme("colors.content.strong") },
      h6: { color: theme("colors.content.strong") },
      p: { color: theme("colors.content.moderate") },
      strong: { color: theme("colors.content.strong") },
      ...colorSchemeCssVariableClasses
    });
  });
}
function linearGradientMaskImagePlugin() {
  function xyMaskFn(direction) {
    return ({ step }) => `linear-gradient(${direction === "x" ? "to right" : "to bottom"}, transparent, black ${step}%, black ${100 - step}%, transparent)`;
  }
  function vectorMaskFn(direction) {
    return ({ step }) => `linear-gradient(${direction}, rgba(0, 0, 0, 1.0) ${step}%, transparent 100%)`;
  }
  return plugin(({ addUtilities }) => {
    const directions = {
      x: xyMaskFn("x"),
      y: xyMaskFn("y"),
      t: vectorMaskFn("to top"),
      tr: vectorMaskFn("to top right"),
      r: vectorMaskFn("to right"),
      br: vectorMaskFn("to bottom right"),
      b: vectorMaskFn("to bottom"),
      bl: vectorMaskFn("to bottom left"),
      l: vectorMaskFn("to left"),
      tl: vectorMaskFn("to top left")
    };
    const steps = [
      0,
      2,
      5,
      10,
      15,
      20,
      25,
      30,
      35,
      40,
      45,
      50,
      55,
      60,
      65,
      70,
      75,
      80,
      85,
      90,
      95,
      98
    ];
    const utilities = Object.entries(directions).reduce((result, [shorthand, imageMaskFn]) => {
      const gradientMaskClassEntries = steps.map((step) => {
        const className = `.gradient-mask-${shorthand}-${step}`;
        return [
          className,
          {
            maskImage: imageMaskFn({ step })
          }
        ];
      });
      const stepClasses = Object.fromEntries(gradientMaskClassEntries);
      return {
        ...result,
        ...stepClasses
      };
    }, {});
    addUtilities(utilities);
  });
}

// src/config/helpers/create8PtGrid.ts
function create8PtGrid(max = 512) {
  const finalGrid = {
    auto: "auto",
    0: "0px",
    1: "1px"
  };
  let currentGridStep = 2;
  while (currentGridStep <= max) {
    finalGrid[currentGridStep.toString()] = `${currentGridStep}px`;
    if (currentGridStep < 40) {
      currentGridStep += 2;
    } else {
      currentGridStep += 8;
    }
  }
  return finalGrid;
}
var keyframes = {
  // Dropdown menu
  "scale-in": {
    "0%": { opacity: "0", transform: "scale(0)" },
    "100%": { opacity: "1", transform: "scale(1)" }
  },
  "slide-down": {
    "0%": { opacity: "0", transform: "translateY(-10px)" },
    "100%": { opacity: "1", transform: "translateY(0)" }
  },
  "slide-up": {
    "0%": { opacity: "0", transform: "translateY(10px)" },
    "100%": { opacity: "1", transform: "translateY(0)" }
  },
  // Tooltip
  "slide-up-fade": {
    "0%": { opacity: "0", transform: "translateY(2px)" },
    "100%": { opacity: "1", transform: "translateY(0)" }
  },
  "slide-right-fade": {
    "0%": { opacity: "0", transform: "translateX(-2px)" },
    "100%": { opacity: "1", transform: "translateX(0)" }
  },
  "slide-down-fade": {
    "0%": { opacity: "0", transform: "translateY(-2px)" },
    "100%": { opacity: "1", transform: "translateY(0)" }
  },
  "slide-left-fade": {
    "0%": { opacity: "0", transform: "translateX(2px)" },
    "100%": { opacity: "1", transform: "translateX(0)" }
  },
  // Navigation menu
  "enter-from-right": {
    "0%": { transform: "translateX(200px)", opacity: "0" },
    "100%": { transform: "translateX(0)", opacity: "1" }
  },
  "enter-from-left": {
    "0%": { transform: "translateX(-200px)", opacity: "0" },
    "100%": { transform: "translateX(0)", opacity: "1" }
  },
  "exit-to-right": {
    "0%": { transform: "translateX(0)", opacity: "1" },
    "100%": { transform: "translateX(200px)", opacity: "0" }
  },
  "exit-to-left": {
    "0%": { transform: "translateX(0)", opacity: "1" },
    "100%": { transform: "translateX(-200px)", opacity: "0" }
  },
  "scale-in-content": {
    "0%": { transform: "rotateX(-30deg) scale(0.9)", opacity: "0" },
    "100%": { transform: "rotateX(0deg) scale(1)", opacity: "1" }
  },
  "scale-out-content": {
    "0%": { transform: "rotateX(0deg) scale(1)", opacity: "1" },
    "100%": { transform: "rotateX(-10deg) scale(0.95)", opacity: "0" }
  },
  "fade-in": {
    "0%": { opacity: "0" },
    "100%": { opacity: "1" }
  },
  "fade-out": {
    "0%": { opacity: "1" },
    "100%": { opacity: "0" }
  },
  // Toast
  "toast-hide": {
    "0%": { opacity: "1" },
    "100%": { opacity: "0" }
  },
  "toast-slide-in-right": {
    "0%": { transform: `translateX(calc(100% + 1rem))` },
    "100%": { transform: "translateX(0)" }
  },
  "toast-slide-in-bottom": {
    "0%": { transform: `translateY(calc(100% + 1rem))` },
    "100%": { transform: "translateY(0)" }
  },
  "toast-swipe-out-x": {
    "0%": { transform: "translateX(var(--radix-toast-swipe-end-x))" },
    "100%": {
      transform: `translateX(calc(100% + 1rem))`
    }
  },
  "toast-swipe-out-y": {
    "0%": { transform: "translateY(var(--radix-toast-swipe-end-y))" },
    "100%": {
      transform: `translateY(calc(100% + 1rem))`
    }
  },
  ...keyframes$1
};
var animation = {
  // Dropdown menu
  "scale-in": "scale-in 0.2s ease-in-out",
  "slide-down": "slide-down 0.6s cubic-bezier(0.16, 1, 0.3, 1)",
  "slide-up": "slide-up 0.6s cubic-bezier(0.16, 1, 0.3, 1)",
  // Tooltip
  "slide-up-fade": "slide-up-fade 0.4s cubic-bezier(0.16, 1, 0.3, 1)",
  "slide-right-fade": "slide-right-fade 0.4s cubic-bezier(0.16, 1, 0.3, 1)",
  "slide-down-fade": "slide-down-fade 0.4s cubic-bezier(0.16, 1, 0.3, 1)",
  "slide-left-fade": "slide-left-fade 0.4s cubic-bezier(0.16, 1, 0.3, 1)",
  // Navigation menu
  "enter-from-right": "enter-from-right 0.25s ease",
  "enter-from-left": "enter-from-left 0.25s ease",
  "exit-to-right": "exit-to-right 0.25s ease",
  "exit-to-left": "exit-to-left 0.25s ease",
  "scale-in-content": "scale-in-content 0.2s ease",
  "scale-out-content": "scale-out-content 0.2s ease",
  "fade-in": "fade-in 0.2s ease",
  "fade-out": "fade-out 0.2s ease",
  // Toast
  "toast-hide": "toast-hide 100ms ease-in forwards",
  "toast-slide-in-right": "toast-slide-in-right 150ms cubic-bezier(0.16, 1, 0.3, 1)",
  "toast-slide-in-bottom": "toast-slide-in-bottom 150ms cubic-bezier(0.16, 1, 0.3, 1)",
  "toast-swipe-out-x": "toast-swipe-out-x 100ms ease-out forwards",
  "toast-swipe-out-y": "toast-swipe-out-y 100ms ease-out forwards",
  ...animation$1
};

// src/config/data-attributes.ts
var dataAttributes = {
  "data-antribute-list": "divide no-item-gutters no-gap zebra-items rounded-items",
  "data-antribute-card": "padding padding-none"
};
function getDataAttributes(dataAttributeOptions) {
  const entries = Object.entries(dataAttributeOptions).map(([attributeKey, filterValue]) => {
    const dataAttributeValue = dataAttributes[attributeKey];
    if (typeof dataAttributeValue === "string") {
      const filtered = filterStringAttributes(dataAttributeValue, filterValue);
      return [attributeKey, filtered];
    }
    if (typeof dataAttributeValue === "boolean") {
      return [attributeKey, String(filterValue)];
    }
    return [attributeKey, void 0];
  });
  function filterStringAttributes(str, values) {
    return str.split(" ").filter((attribute) => {
      return Boolean(
        values && typeof values === "object" && attribute in values && values[attribute]
      );
    }).join(" ");
  }
  return Object.fromEntries(entries);
}
getDataAttributes({ "data-antribute-card": { "padding-none": true } });
function getTailwindDataAttributeShortcuts() {
  const entries = Object.entries(dataAttributes).flatMap(([key, value]) => {
    const attributeName = key.trim().replace("data-", "");
    function parseStringAttributes(str) {
      return str.split(" ").map((e) => e.trim()).filter(Boolean);
    }
    const attributes = typeof value === "string" ? parseStringAttributes(value) : [value];
    return attributes.map((attribute) => {
      if (typeof attribute === "string") {
        return [`${attributeName}-${attribute}`, `${attributeName}~="${attribute}"`];
      }
      if (typeof attribute === "boolean") {
        return [attribute, `${attributeName}="${String(attribute)}"`];
      }
      return [attribute, `${attributeName}=true`];
    });
  });
  return Object.fromEntries(entries);
}

// src/config/screens.ts
var screens = {
  sm: "640px",
  md: "768px",
  lg: "1024px",
  xl: "1280px",
  "2xl": "1536px"
};

// src/config/helpers/buildBoxShadow.ts
function buildBoxShadow(options) {
  const opts = Array.isArray(options) ? options.filter(Boolean) : [options];
  return opts.map(
    ({
      inset,
      offsetX = 0,
      offsetY = 0,
      blurRadius = 0,
      spreadRadius = 0,
      color = "rgb(0 0 0 / 0.1)"
    }) => {
      return `${inset ? "inset" : ""} ${offsetX} ${offsetY} ${blurRadius} ${spreadRadius} ${color}`;
    }
  ).join(", ");
}

// src/config/helpers/shadowBorder.ts
function shadowBorder(options) {
  const defaultColor = "rgb(var(--color-highlight-subtle) / var(--alpha-highlight-subtle))";
  const boxShadowOptions = options.map((o) => {
    return { inset: true, color: `var(--shadow-color,${defaultColor})`, ...o };
  });
  return buildBoxShadow(boxShadowOptions);
}

// src/config/plugins/custom-classes-plugin/custom-classes-plugin.helpers.ts
function classComponentPreset(prefix2, componentMap) {
  return classComponents(componentMap, prefix2);
}
function classComponentMap(data, fn) {
  const collection = typeof data === "string" ? [data] : data;
  const obj = Array.isArray(collection) ? Object.fromEntries(collection.map((key) => [key, void 0])) : collection;
  const result = Object.fromEntries(
    Object.entries(obj).map(([k, v]) => {
      const { name, className } = fn(k, v);
      const entry = classComponentEntry(name, className);
      return entry;
    }).filter(notEmpty)
  );
  return result;
}
function classComponents(componentMap, prefix2 = "") {
  return classComponentMap(componentMap, (name, className) => ({
    name: `${prefix2}${name}`,
    className
  }));
}
function classComponent(name, twClass) {
  const entry = classComponentEntry(name, twClass);
  return Object.fromEntries([entry]);
}
function classComponentEntry(name, twClass) {
  const clssName = name.startsWith(".") ? name : `.${name}`;
  const component = [
    clssName,
    {
      [getTwClassString(twClass)]: {}
    }
  ];
  return component;
}
function getTwClassString(classString = "") {
  const cleaned = classString.trim().split(" ").filter((token) => token.length > 0).join(" ");
  return `@apply ${cleaned}`;
}

// src/config/plugins/custom-classes-plugin/class-style-utils.ts
function clsx(...args) {
  return args.filter(notEmpty).join(" ");
}
function prefix(prefix2, k) {
  return k ? `${prefix2}-${k}` : `${prefix2}-`;
}

// src/config/helpers/utilities.ts
function mergeObjects(objects) {
  return objects.reduce(
    (acc, obj) => ({ ...acc, ...obj }),
    // @ts-expect-error empty object
    {}
  );
}

// src/config/plugins/custom-classes-plugin/tw-gradient-helpers.ts
var twGradientDirections = ["t", "tr", "tl", "b", "br", "bl", "l", "r"];
function generateGradientDirections(gradient) {
  const gradientDirections = twGradientDirections.map((dir) => {
    return gradient({ dir });
  });
  return mergeObjects(gradientDirections);
}
function generateTwGradientClasses(data, {
  gradientName,
  gradient
}) {
  const gradientClasses = generateGradientDirections(({ dir }) => {
    return classComponentMap(data, (k) => {
      const g = gradient({ color: k, dir });
      return {
        name: `bg-gradient-${k}-${gradientName}-${dir}`,
        className: typeof g === "string" ? g : twGradient({ ...g, dir })
      };
    });
  });
  return gradientClasses;
}
function twGradient({ dir, fromColor, toColor, viaColor }, className) {
  return clsx(
    `bg-gradient-to-${dir}`,
    `from-${fromColor}`,
    viaColor && `via-${viaColor}`,
    `to-${toColor}`,
    className
  );
}
function baseTokensWithLightAndDarkColors({ theme }) {
  const tokens = Object.keys(theme("colors"));
  const lightSuffix = "-light";
  const darkSuffix = "-dark";
  const baseTokens = tokens.filter(
    (token) => !token.endsWith(lightSuffix) && !token.endsWith(darkSuffix)
  );
  return baseTokens.filter((baseToken) => {
    const hasLightToken = hasPair(`${baseToken}${lightSuffix}`, tokens, lightSuffix, darkSuffix);
    const hasDarkToken = hasPair(`${baseToken}${darkSuffix}`, tokens, darkSuffix, lightSuffix);
    return hasLightToken && hasDarkToken;
  });
}
function hasPair(token, list, suffix1, suffix2) {
  if (token.endsWith(suffix1)) {
    const baseToken = token.slice(0, -suffix1.length);
    return list.some((t) => t === baseToken + suffix2);
  }
  return false;
}

// src/config/plugins/custom-classes-plugin/custom-classes-plugin.ts
function customClassesPlugin() {
  return plugin(({ addComponents: addComponentsFn, theme }) => {
    addComponents({
      ...classComponentMap(colorSchemeBaseTokens, (k) => {
        return {
          name: prefix("filled-accent", k),
          className: clsx(`bg-${k} text-palette-white`)
        };
      }),
      ...classComponentMap(variousColors, (key) => {
        return {
          name: prefix("filled-accent", key),
          className: clsx(`bg-palette-${key} text-palette-white`)
        };
      }),
      ...classComponentPreset(prefix("filled-accent"), {
        primary: clsx("bg-primary text-primary-content"),
        secondary: clsx("bg-secondary text-secondary-content"),
        inverse: clsx("bg-inverse text-inverse-content-max-contrast")
      }),
      ...classComponents({
        "gradient-primary": clsx(
          "bg-gradient-to-r from-primary-dark to-primary-light text-primary-content "
        ),
        "gradient-secondary": clsx(
          "bg-gradient-to-r from-secondary-dark to-secondary-light text-secondary-content "
        ),
        "gradient-inverse": clsx(
          "bg-gradient-to-r from-inverse-dark to-inverse-light text-inverse-content-max-contrast "
        ),
        "gradient-heart": clsx(
          "bg-gradient-to-r from-heart-dark to-heart-light text-palette-white "
        ),
        "gradient-info": clsx("bg-gradient-to-r from-info-dark to-info-light text-palette-white "),
        "gradient-success": clsx(
          "bg-gradient-to-r from-success-dark to-success-light text-palette-white "
        ),
        "gradient-caution": clsx(
          "bg-gradient-to-r from-caution-dark to-caution-light text-palette-white "
        ),
        "gradient-danger": clsx(
          "bg-gradient-to-r from-danger-dark to-danger-light text-palette-white "
        )
      })
    });
    addComponents(
      classComponentPreset("filled-hover-accent-", {
        primary: "hover:bg-primary-dark",
        secondary: "hover:bg-secondary-dark",
        inverse: "hover:bg-inverse-light",
        heart: "hover:bg-heart-dark",
        info: "hover:bg-info-dark",
        success: "hover:bg-success-dark",
        caution: "hover:bg-caution-dark",
        danger: "hover:bg-danger-dark"
      })
    );
    addComponents(
      classComponentPreset("outlined-accent-", {
        primary: "bg-surface-soft hover:bg-surface-dark/30 text-primary-content-min-contrast ring-boundary-moderate",
        secondary: "bg-surface-soft hover:bg-surface-dark/30 text-secondary-content-min-contrast ring-boundary-moderate",
        inverse: "bg-surface-soft hover:bg-surface-dark/30 text-inverse ring-inverse",
        heart: "bg-surface-soft hover:bg-surface text-heart ring-heart hover:ring-heart-dark",
        info: "bg-surface-soft hover:bg-surface text-info ring-info hover:ring-info-dark",
        success: "bg-surface-soft hover:bg-surface text-success ring-success hover:ring-success-dark",
        caution: "bg-surface-soft hover:bg-surface text-caution ring-caution hover:ring-caution-dark",
        danger: "bg-surface-soft hover:bg-surface text-danger ring-danger hover:ring-danger-dark"
      })
    );
    addComponents(
      classComponentPreset("glass-accent-", {
        primary: "bg-primary/40 text-content-intense hover:bg-highlight-strong",
        secondary: "bg-highlight-weak text-content-max-contrast hover:bg-highlight-moderate",
        inverse: "bg-inverse/30 text-palette-white hover:bg-inverse/40",
        heart: "bg-heart/10 hover:bg-heart/20 text-heart",
        info: "bg-info/10 hover:bg-info/20 text-info",
        success: "bg-success/10 hover:bg-success/20 text-success",
        caution: "bg-caution/10 hover:bg-caution/20 text-caution contrast-[.85]",
        danger: "bg-danger/10 hover:bg-danger/20 text-danger"
      })
    );
    addComponents(
      classComponentPreset("ghost-accent-", {
        primary: "text-content-strong hover:bg-highlight-weak",
        secondary: "text-content-weak hover:bg-highlight-weak",
        inverse: "text-inverse hover:bg-highlight-weak",
        heart: "text-heart hover:bg-heart/20",
        info: "text-info hover:bg-info/20",
        success: "text-success hover:bg-success/20",
        caution: "text-caution hover:bg-caution/20 contrast-[.85]",
        danger: "text-danger hover:bg-danger/20"
      })
    );
    addComponents(
      generateTwGradientClasses(baseTokensWithLightAndDarkColors({ theme }), {
        gradientName: "dark-to-light",
        gradient: ({ color, dir }) => twGradient({ dir, fromColor: `${color}-dark`, toColor: `${color}-light` })
      })
    );
    addClassComponent("noisy-surface-texture", "before:noisy-texture before-absolute-content");
    addClassComponent(
      "noisy-texture",
      "bg-[url('https://liveblocks.io/images/noise.png')] bg-repeat bg-[length:125px] opacity-[0.015]"
    );
    addClassComponent(
      "absolute-center",
      "absolute top-1/2 left-1/2 transform -translate-x-1/2 -translate-y-1/2"
    );
    addClassComponent(
      "before-absolute-content",
      "before:content-[''] before:absolute before:w-full before:h-full before:pointer-events-none before:inset-0"
    );
    addClassComponent(
      "after-absolute-content",
      "after:content-[''] after:absolute after:w-full after:h-full after:pointer-events-none after:inset-0"
    );
    addClassComponent("inherit-grid-template-areas", "[grid-template-areas:inherit]");
    function addClassComponent(name, twClassName) {
      addComponents(classComponent(name, twClassName));
    }
    function addComponents(p0, options) {
      const { debug, ...p1 } = options ?? {};
      if (debug) {
        console.log(p0);
      }
      addComponentsFn(p0, p1);
    }
  });
}

// src/config/tailwindConfig.ts
var config = {
  plugins: [
    tailwindCssRadixPlugin,
    tailwindCssFormsPlugin,
    tailwindCssLineClampPlugin,
    tailwindCssTypographyPlugin,
    tailwindContainerQueriesPlugin,
    tailwindGridAreaPlugin,
    iconsPlugin({
      collections: getIconCollections(["heroicons", "fa6-brands"])
    }),
    multiThemePlugin(),
    customClassesPlugin(),
    linearGradientMaskImagePlugin(),
    plugin(({ addVariant }) => {
      addVariant("not-first", "&:not(:first-child)");
      addVariant("not-last", "&:not(:last-child)");
      addVariant("middle", "&:not(:first-child):not(:last-child)");
      addVariant("second", "&:nth-child(2)");
      addVariant("second-last", "&:not(:nth-last-child(2))");
    })
  ],
  content: {
    files: [
      resolve(process.cwd(), "*.{htm,html}"),
      resolve(process.cwd(), "public", "**", "*.{htm,html}"),
      resolve(process.cwd(), "src", "**", "*.{js,jsx,mdx,ts,tsx}"),
      resolve(process.cwd(), "node_modules", "@antribute", "ui", "dist", "**", "*.js")
    ],
    transform: createVariantGroupTransformer()
  },
  darkMode: ["class", '[data-mode="dark"]'],
  // safelist: tailwindSafelist,
  presets: [],
  theme: {
    extend: {
      containers: {
        "2xs": "16rem",
        "3xs": "12rem",
        "4xs": "8rem"
      },
      gridTemplateColumns: {
        inherit: "inherit",
        unset: "unset"
      },
      gridTemplateRows: {
        inherit: "inherit",
        unset: "unset"
      },
      gridTemplateAreas: {
        layout: "inherit"
      }
    },
    ...defaultTailwindTheme,
    data: {
      ...colorSchemeDataAttributes,
      ...getTailwindDataAttributeShortcuts()
    },
    screens,
    keyframes,
    animation,
    accentColor: ({ theme }) => ({
      ...theme("colors"),
      auto: "auto"
    }),
    borderColor: ({ theme }) => theme("colors"),
    borderOpacity: ({ theme }) => theme("opacity"),
    borderRadius: {
      none: "0px",
      sm: "0.125rem",
      DEFAULT: "0.25rem",
      md: "0.375rem",
      lg: "0.5rem",
      full: "9999px"
    },
    borderSpacing: ({ theme }) => theme("spacing"),
    borderWidth: {
      DEFAULT: "1px",
      0: "0px",
      2: "2px"
    },
    boxShadow: {
      sm: "0 1px 2px 0 rgb(0 0 0 / 0.05)",
      DEFAULT: "0 1px 3px 0 rgb(0 0 0 / 0.1), 0 1px 2px -1px rgb(0 0 0 / 0.1)",
      md: "0 4px 6px -1px rgb(0 0 0 / 0.1), 0 2px 4px -2px rgb(0 0 0 / 0.1)",
      lg: "0 10px 15px -3px rgb(0 0 0 / 0.1), 0 4px 6px -4px rgb(0 0 0 / 0.1)",
      xl: "0 20px 25px -5px rgb(0 0 0 / 0.1), 0 8px 10px -6px rgb(0 0 0 / 0.1)",
      "2xl": "0 25px 50px -12px rgb(0 0 0 / 0.25)",
      inner: "inset 0 2px 4px 0 rgb(0 0 0 / 0.05)",
      none: "none",
      hover: "0px 2px 5px 0px rgb(64 68 82 / 0.08), 0px 3px 9px 0px rgb(64 68 82 / 0.08)",
      "border-t": shadowBorder([{ offsetY: "1px" }]),
      "border-b": shadowBorder([{ offsetY: "-1px" }]),
      "border-l": shadowBorder([{ offsetX: "1px" }]),
      "border-r": shadowBorder([{ offsetX: "-1px" }]),
      "border-y": shadowBorder([{ offsetY: "1px" }, { offsetY: "-1px" }]),
      "border-x": shadowBorder([{ offsetX: "1px" }, { offsetX: "-1px" }]),
      "border-t-sm": shadowBorder([{ offsetY: "0.5px" }]),
      "border-b-sm": shadowBorder([{ offsetY: "-0.5px" }]),
      "border-l-sm": shadowBorder([{ offsetX: "0.5px" }]),
      "border-r-sm": shadowBorder([{ offsetX: "-0.5px" }]),
      "border-y-sm": shadowBorder([{ offsetY: "0.5px" }, { offsetY: "-0.5px" }]),
      "border-x-sm": shadowBorder([{ offsetX: "0.5px" }, { offsetX: "-0.5px" }]),
      "border-t-2": shadowBorder([{ offsetY: "2px" }]),
      "border-b-2": shadowBorder([{ offsetY: "-2px" }]),
      "border-l-2": shadowBorder([{ offsetX: "2px" }]),
      "border-r-2": shadowBorder([{ offsetX: "-2px" }]),
      "border-y-2": shadowBorder([{ offsetY: "2px" }, { offsetY: "-2px" }]),
      "border-x-2": shadowBorder([{ offsetX: "2px" }, { offsetX: "-2px" }])
    },
    boxShadowColor: ({ theme }) => theme("colors"),
    caretColor: ({ theme }) => theme("colors"),
    colors: { ...colorPalette, ...colorSchemeTokens },
    divideColor: ({ theme }) => theme("borderColor"),
    divideOpacity: ({ theme }) => theme("borderOpacity"),
    divideWidth: ({ theme }) => theme("borderWidth"),
    dropShadow: {
      sm: "0 1px 1px rgb(0 0 0 / 0.05)",
      DEFAULT: ["0 1px 2px rgb(0 0 0 / 0.1)", "0 1px 1px rgb(0 0 0 / 0.06)"],
      md: ["0 4px 3px rgb(0 0 0 / 0.07)", "0 2px 2px rgb(0 0 0 / 0.06)"],
      lg: ["0 10px 8px rgb(0 0 0 / 0.04)", "0 4px 3px rgb(0 0 0 / 0.1)"],
      xl: ["0 20px 13px rgb(0 0 0 / 0.03)", "0 8px 5px rgb(0 0 0 / 0.08)"],
      "2xl": "0 25px 25px rgb(0 0 0 / 0.15)",
      none: "0 0 #0000"
    },
    fill: ({ theme }) => ({
      none: "none",
      ...theme("colors")
    }),
    flexBasis: ({ theme }) => ({
      auto: "auto",
      ...theme("spacing"),
      "1/2": "50%",
      "1/3": "33.333333%",
      "2/3": "66.666667%",
      "1/4": "25%",
      "2/4": "50%",
      "3/4": "75%",
      "1/5": "20%",
      "2/5": "40%",
      "3/5": "60%",
      "4/5": "80%",
      "1/6": "16.666667%",
      "2/6": "33.333333%",
      "3/6": "50%",
      "4/6": "66.666667%",
      "5/6": "83.333333%",
      "1/12": "8.333333%",
      "2/12": "16.666667%",
      "3/12": "25%",
      "4/12": "33.333333%",
      "5/12": "41.666667%",
      "6/12": "50%",
      "7/12": "58.333333%",
      "8/12": "66.666667%",
      "9/12": "75%",
      "10/12": "83.333333%",
      "11/12": "91.666667%",
      full: "100%"
    }),
    fontFamily: {
      display: [
        "Cal Sans",
        "sans-serif",
        '"Apple Color Emoji"',
        '"Segoe UI Emoji"',
        '"Segoe UI Symbol"',
        '"Noto Color Emoji"'
      ],
      body: [
        "Figtree",
        "sans-serif",
        '"Apple Color Emoji"',
        '"Segoe UI Emoji"',
        '"Segoe UI Symbol"',
        '"Noto Color Emoji"'
      ],
      heading: [
        "Inter",
        "sans-serif",
        '"Apple Color Emoji"',
        '"Segoe UI Emoji"',
        '"Segoe UI Symbol"',
        '"Noto Color Emoji"'
      ],
      mono: [
        "ui-monospace",
        "SFMono-Regular",
        "Menlo",
        "Monaco",
        "Consolas",
        '"Liberation Mono"',
        '"Courier New"',
        "monospace"
      ]
    },
    fontSize: {
      h1: ["67px", { lineHeight: "80px" }],
      h2: ["50px", { lineHeight: "56px" }],
      h3: ["38px", { lineHeight: "48px" }],
      h4: ["23px", { lineHeight: "32px" }],
      h5: ["21px", { lineHeight: "24px" }],
      h6: ["18px", { lineHeight: "24px" }],
      lg: ["21px", { lineHeight: "32px" }],
      md: ["16px", { lineHeight: "24px" }],
      sm: ["14px", { lineHeight: "18px" }],
      xs: ["12px", { lineHeight: "16px" }]
    },
    fontWeight: {
      body: "400",
      regular: "400",
      medium: "500",
      bold: "600",
      heading: "700"
    },
    gap: ({ theme }) => theme("spacing"),
    gradientColorStops: ({ theme }) => theme("colors"),
    height: ({ theme }) => ({
      auto: "auto",
      ...theme("spacing"),
      "1/2": "50%",
      "1/3": "33.333333%",
      "2/3": "66.666667%",
      "1/4": "25%",
      "2/4": "50%",
      "3/4": "75%",
      "1/5": "20%",
      "2/5": "40%",
      "3/5": "60%",
      "4/5": "80%",
      "1/6": "16.666667%",
      "2/6": "33.333333%",
      "3/6": "50%",
      "4/6": "66.666667%",
      "5/6": "83.333333%",
      full: "100%",
      screen: "100vh",
      min: "min-content",
      max: "max-content",
      fit: "fit-content"
    }),
    inset: ({ theme }) => ({
      auto: "auto",
      ...theme("spacing"),
      "1/2": "50%",
      "1/3": "33.333333%",
      "2/3": "66.666667%",
      "1/4": "25%",
      "2/4": "50%",
      "3/4": "75%",
      full: "100%"
    }),
    lineHeight: {
      none: "0px",
      h1: "80px",
      h2: "56px",
      h3: "48px",
      h4: "32px",
      h5: "24px",
      h6: "24px",
      lg: "32px",
      md: "24px",
      sm: "16px",
      xs: "12px"
    },
    margin: ({ theme }) => ({
      auto: "auto",
      ...theme("spacing")
    }),
    maxHeight: ({ theme }) => ({
      ...theme("spacing"),
      full: "100%",
      screen: "100vh",
      min: "min-content",
      max: "max-content",
      fit: "fit-content"
    }),
    maxWidth: ({ theme, breakpoints }) => ({
      none: "none",
      0: "0px",
      full: "100%",
      min: "min-content",
      max: "max-content",
      fit: "fit-content",
      prose: "65ch",
      ...theme("spacing"),
      ...breakpoints(theme("screens"))
    }),
    outlineColor: ({ theme }) => theme("colors", "var(--color-content-high)"),
    padding: ({ theme }) => theme("spacing"),
    placeholderColor: ({ theme }) => theme("colors"),
    placeholderOpacity: ({ theme }) => theme("opacity"),
    ringColor: ({ theme }) => ({
      DEFAULT: theme(
        "colors.highlight.moderate",
        colorSchemeTokens["highlight-moderate"]
      ),
      ...theme("colors")
    }),
    ringOffsetColor: ({ theme }) => theme("colors"),
    ringOpacity: ({ theme }) => ({
      DEFAULT: "0.5",
      ...theme("opacity")
    }),
    scrollMargin: ({ theme }) => ({
      ...theme("spacing")
    }),
    scrollPadding: ({ theme }) => theme("spacing"),
    space: ({ theme }) => ({
      ...theme("spacing")
    }),
    spacing: {
      px: "1px",
      navbar: "63px",
      sidebar: "288px",
      narrowbar: "40px",
      pageheader: "77px",
      aside: "388px",
      ...create8PtGrid()
    },
    stroke: ({ theme }) => ({
      none: "none",
      ...theme("colors")
    }),
    textColor: ({ theme }) => theme("colors"),
    textDecorationColor: ({ theme }) => theme("colors"),
    textIndent: ({ theme }) => ({
      ...theme("spacing")
    }),
    textOpacity: ({ theme }) => theme("opacity"),
    translate: ({ theme }) => ({
      ...theme("spacing"),
      "1/2": "50%",
      "1/3": "33.333333%",
      "2/3": "66.666667%",
      "1/4": "25%",
      "2/4": "50%",
      "3/4": "75%",
      full: "100%"
    }),
    width: ({ theme }) => ({
      auto: "auto",
      ...theme("spacing"),
      "1/2": "50%",
      "1/3": "33.333333%",
      "2/3": "66.666667%",
      "1/4": "25%",
      "2/4": "50%",
      "3/4": "75%",
      "1/5": "20%",
      "2/5": "40%",
      "3/5": "60%",
      "4/5": "80%",
      "1/6": "16.666667%",
      "2/6": "33.333333%",
      "3/6": "50%",
      "4/6": "66.666667%",
      "5/6": "83.333333%",
      "1/12": "8.333333%",
      "2/12": "16.666667%",
      "3/12": "25%",
      "4/12": "33.333333%",
      "5/12": "41.666667%",
      "6/12": "50%",
      "7/12": "58.333333%",
      "8/12": "66.666667%",
      "9/12": "75%",
      "10/12": "83.333333%",
      "11/12": "91.666667%",
      full: "100%",
      screen: "100vw",
      min: "min-content",
      max: "max-content",
      fit: "fit-content"
    })
  }
};
var tailwindConfig_default = config;

export { tailwindConfig_default as default };
//# sourceMappingURL=out.js.map
//# sourceMappingURL=tailwindConfig.js.map