vaderjs 1.1.1 → 1.1.2

package/website/node_modules/daisyui/src/index.js

@@ -0,0 +1,186 @@
+const tailwindColors = require("tailwindcss/colors")
+
+const postcssJs = require("postcss-js")
+const postcssPrefix = require("./lib/addPrefix")
+
+const daisyuiInfo = require("../package.json")
+const colors = require("./theming/index")
+const utilities = require("../dist/utilities")
+const base = require("../dist/base")
+const unstyled = require("../dist/unstyled")
+const unstyledRtl = require("../dist/unstyled.rtl")
+const styled = require("../dist/styled")
+const styledRtl = require("../dist/styled.rtl")
+const utilitiesUnstyled = require("../dist/utilities-unstyled")
+const utilitiesStyled = require("../dist/utilities-styled")
+const themes = require("./theming/themes")
+const colorFunctions = require("./theming/functions")
+
+const mainFunction = ({ addBase, addComponents, config }) => {
+  let logs = false
+  if (config("daisyui.logs") != false) {
+    logs = true
+  }
+  if (logs) {
+    console.log()
+    console.log(
+      "\x1b[35m%s\x1b[0m",
+      "🌼 daisyUI " + daisyuiInfo.version,
+      "\x1b[0m" + daisyuiInfo.homepage
+    )
+  }
+
+  // inject @base style
+  if (config("daisyui.base") != false) {
+    addBase(base)
+  }
+
+  // inject components
+  // because rollupjs doesn't supprt dynamic require
+  let file = styled
+  if (config("daisyui.styled") == false && config("daisyui.rtl") != true) {
+    file = unstyled
+  } else if (config("daisyui.styled") == false && config("daisyui.rtl") == true) {
+    file = unstyledRtl
+  } else if (config("daisyui.styled") != false && config("daisyui.rtl") != true) {
+    file = styled
+  } else if (config("daisyui.styled") !== false && config("daisyui.rtl") == true) {
+    file = styledRtl
+  }
+
+  // add prefix to class names if specified
+  const prefix = config("daisyui.prefix")
+  let postcssJsProcess
+  if (prefix) {
+    try {
+      postcssJsProcess = postcssJs.sync(postcssPrefix({ prefix, ignore: [] }))
+    } catch (error) {
+      logs && console.error(`Error occurred and prevent applying the "prefix" option:`, error)
+    }
+  }
+  const shouldApplyPrefix = prefix && postcssJsProcess
+  if (shouldApplyPrefix) {
+    file = postcssJsProcess(file)
+  }
+
+  addComponents(file)
+
+  const themeInjectorHsl = colorFunctions.injectThemes(addBase, config, themes, "hsl")
+  themeInjectorHsl
+
+  // inject @utilities style needed by components
+  if (config("daisyui.utils") != false) {
+    addComponents(utilities, { variants: ["responsive"] })
+
+    let toAdd = utilitiesUnstyled // shadow clone here to avoid mutate the original
+    if (shouldApplyPrefix) {
+      toAdd = postcssJsProcess(toAdd)
+    }
+    addComponents(toAdd, { variants: ["responsive"] })
+
+    toAdd = utilitiesStyled
+    if (shouldApplyPrefix) {
+      toAdd = postcssJsProcess(toAdd)
+    }
+    addComponents(toAdd, { variants: ["responsive"] })
+  }
+
+  if (logs) {
+    console.log("╰╮")
+    if (config("daisyui.styled") == false) {
+      console.log(
+        " ├─",
+        "\x1b[33m" + "◆" + "\x1b[0m" + "\x1b[2m",
+        "daisyui.styled",
+        "\x1b[0m" + "config is",
+        "\x1b[2m" + "false" + "\x1b[0m",
+        "– your components will have no design decisions" + "\n │"
+      )
+    }
+    if (config("daisyui.utils") == false) {
+      console.log(
+        " ├─",
+        "\x1b[33m" + "◆" + "\x1b[0m" + "\x1b[2m",
+        "daisyui.utils",
+        "\x1b[0m" + "config is",
+        "\x1b[2m" + "false" + "\x1b[0m",
+        "– daisyUI modifier utility classes are disabled" + "\n │"
+      )
+    }
+    if (config("daisyui.prefix") && config("daisyui.prefix") !== "") {
+      console.log(
+        " ├─",
+        "\x1b[32m" + "✔︎" + "\x1b[0m",
+        "Prefix is enabled, daisyUI classnames must use",
+        "\x1b[2m" + `${config("daisyui.prefix")}`,
+        "\x1b[0m" + "prefix. like:",
+        "\x1b[2m" + `${config("daisyui.prefix")}btn`,
+        "\x1b[0m" + "\n │    https://daisyui.com/docs/config" + "\n │"
+      )
+    }
+    if (config("daisyui.rtl") == true) {
+      console.log(
+        " ├─",
+        "\x1b[32m" + "✔︎" + "\x1b[0m",
+        "Using RTL, make sure you're using",
+        "\x1b[2m" + "<html dir=rtl>" + "\x1b[0m",
+        "and you have",
+        "\x1b[2m",
+        "tailwindcss-flip",
+        "\x1b[0m",
+        "plugin",
+        "\n │  https://daisyui.com/docs/config" + "\n │"
+      )
+    }
+    if (themeInjectorHsl.themeOrder.length > 0) {
+      console.log(
+        " ╰─",
+        "\x1b[32m" + "✔︎" + "\x1b[0m",
+        "\x1b[2m" +
+          "[ " +
+          "\x1b[0m" +
+          `${themeInjectorHsl.themeOrder.length}` +
+          "\x1b[2m" +
+          " ]" +
+          "\x1b[0m" +
+          ` ${themeInjectorHsl.themeOrder.length > 1 ? "themes are" : "theme is"}` +
+          ` enabled. You can add more themes or make your own theme:` +
+          "\n      https://daisyui.com/docs/themes"
+      )
+    }
+    if (themeInjectorHsl.themeOrder.length === 0) {
+      console.log(
+        " ╰─",
+        "\x1b[33m" + "◆" + "\x1b[0m",
+        `All themes are disabled in the config. You can add themes or make your own theme:` +
+          "\n      https://daisyui.com/docs/themes"
+      )
+    }
+    console.log(
+      "\n\x1b[32m%s\x1b[0m",
+      "    ❤︎ Support daisyUI" + "\x1b[0m" + `: ${daisyuiInfo.funding.url}`
+    )
+    console.log()
+  }
+}
+
+module.exports = require("tailwindcss/plugin")(mainFunction, {
+  theme: {
+    extend: {
+      colors: {
+        ...colors,
+        // adding all Tailwind `neutral` shades here so they don't get overridden by daisyUI `neutral` color
+        "neutral-50": tailwindColors.neutral[50],
+        "neutral-100": tailwindColors.neutral[100],
+        "neutral-200": tailwindColors.neutral[200],
+        "neutral-300": tailwindColors.neutral[300],
+        "neutral-400": tailwindColors.neutral[400],
+        "neutral-500": tailwindColors.neutral[500],
+        "neutral-600": tailwindColors.neutral[600],
+        "neutral-700": tailwindColors.neutral[700],
+        "neutral-800": tailwindColors.neutral[800],
+        "neutral-900": tailwindColors.neutral[900],
+      },
+    },
+  },
+})

package/website/node_modules/daisyui/src/lib/addPrefix.js

@@ -0,0 +1,104 @@
+const Tokenizer = require("css-selector-tokenizer")
+
+function itMatchesOne(arr, term) {
+  return arr.some((i) => term.search(i) >= 0)
+}
+
+function parseAttrSelector(node) {
+  const { content } = node
+  const regex =
+    /(^class|^id)([*^?~|$=]*)+(?:("\s*)([^"\\]*?(?:\\.[^"\\]*)*?)(\s*")|('\s*)([^'\\]*?(?:\\.[^'\\]*)*?)(\s*'))/i
+
+  const [type, operator, head, classes, foot] = content.split(regex).filter((part) => part)
+
+  return {
+    type,
+    operator,
+    head,
+    classes: classes ? classes.split(" ").map((c) => c.replace(/"|'/g, "")) : [],
+    foot,
+  }
+}
+
+function attrStringify({ type, operator, head, classes, foot }) {
+  return `${type}${operator || ""}${head || ""}${classes.join(" ")}${foot || ""}`
+}
+
+function prefixNode(node, prefix) {
+  if (["class", "id"].includes(node.type)) {
+    return {
+      ...node,
+      name: `${prefix}${node.name}`,
+    }
+  }
+
+  if (["attribute"].includes(node.type) && node.content) {
+    const { type, operator, head, classes, foot } = parseAttrSelector(node)
+
+    if (!["class", "id"].includes(type)) return node
+
+    return {
+      ...node,
+      content: attrStringify({
+        type,
+        operator,
+        head,
+        classes: classes.map((cls) => `${prefix}${cls}`),
+        foot,
+      }),
+    }
+  }
+
+  return node
+}
+
+function iterateSelectorNodes(selector, options) {
+  const { prefix, ignore } = options
+  return {
+    ...selector,
+    nodes: selector.nodes.map((node) => {
+      if (["selector", "nested-pseudo-class"].includes(node.type)) {
+        return iterateSelectorNodes(node, options)
+      }
+
+      if (itMatchesOne(ignore, Tokenizer.stringify(node))) return node
+
+      return prefixNode(node, prefix)
+    }),
+  }
+}
+
+/**
+ * @type {import('postcss').PluginCreator}
+ */
+module.exports = (opts = {}) => {
+  const { prefix, ignore } = {
+    prefix: "",
+    ignore: [],
+    ...opts,
+  }
+
+  if (typeof prefix !== "string") {
+    throw new Error("prefix option should be of type string.")
+  }
+
+  if (!Array.isArray(ignore)) {
+    throw new Error("ignore options should be an Array.")
+  }
+
+  if (!prefix.length) return
+
+  return {
+    postcssPlugin: "addprefix",
+    Root(root, postcss) {
+      root.walkRules((rule) => {
+        const parsed = Tokenizer.parse(rule.selector)
+        const selector = iterateSelectorNodes(parsed, { prefix, ignore })
+
+        rule.selector = Tokenizer.stringify(selector)
+      })
+    },
+  }
+}
+
+module.exports.postcss = true

package/website/node_modules/daisyui/src/lib/responsiveRegex.js

@@ -0,0 +1,45 @@
+// regext for all daisyUI colors
+// ((primary|secondary|accent|neutral)(-focus|-content|))|((info|success|warning|error)(-content|))|(base)(-100|-200|-300|-content)
+
+// regex for all Tailwind CSS color utilities
+// (bg|to|via|from|text|ring|fill|caret|stroke|border|divide|accent|shadow|outline|decoration|placeholder|ring-offset)
+
+module.exports = [
+  {
+    pattern: /.*/,
+  },
+  {
+    // responsive utilites for daisyUI responsive modifiers
+    pattern: /.(sm|md|lg|xl)/,
+    variants: ["sm", "md", "lg", "xl"],
+  },
+  {
+    // responsive utilites for daisyUI components
+    pattern:
+      /(drawer-open|modal-middle|modal-top|modal-bottom|card-side|card-compact|card-normal|stats|divider-horizontal|divider-vertical)/,
+    variants: ["sm", "md", "lg", "xl"],
+  },
+  {
+    // color utilities for daisyUI colors
+    pattern:
+      /(bg|to|via|from|text|fill|stroke|border|outline)-((primary|secondary|accent|neutral)(-focus|-content|))|((info|success|warning|error)(-content|))|(base)(-100|-200|-300|-content)/,
+    variants: [
+      // "first",
+      // "last",
+      // "odd",
+      // "even",
+      // "visited",
+      // "checked",
+      // "empty",
+      // "read-only",
+      // "group-hover",
+      // "group-focus",
+      // "focus-within",
+      "hover",
+      "focus",
+      // "focus-visible",
+      // "active",
+      // "disabled",
+    ],
+  },
+]

package/website/node_modules/daisyui/src/theming/colorNames.js

@@ -0,0 +1,34 @@
+module.exports = {
+  "primary": "--p",
+  "primary-focus": "--pf",
+  "primary-content": "--pc",
+
+  "secondary": "--s",
+  "secondary-focus": "--sf",
+  "secondary-content": "--sc",
+
+  "accent": "--a",
+  "accent-focus": "--af",
+  "accent-content": "--ac",
+
+  "neutral": "--n",
+  "neutral-focus": "--nf",
+  "neutral-content": "--nc",
+
+  "base-100": "--b1",
+  "base-200": "--b2",
+  "base-300": "--b3",
+  "base-content": "--bc",
+
+  "info": "--in",
+  "info-content": "--inc",
+
+  "success": "--su",
+  "success-content": "--suc",
+
+  "warning": "--wa",
+  "warning-content": "--wac",
+
+  "error": "--er",
+  "error-content": "--erc",
+}

package/website/node_modules/daisyui/src/theming/functions.js

@@ -0,0 +1,269 @@
+const colorNames = require("./colorNames")
+const themeDefaults = require("./themeDefaults")
+
+const { colord, getFormat, extend } = require("colord")
+const mixPlugin = require("colord/plugins/mix")
+const namesPlugin = require("colord/plugins/names")
+const lchPlugin = require("colord/plugins/lch")
+const hwbPlugin = require("colord/plugins/hwb")
+const labPlugin = require("colord/plugins/lab")
+const xyzPlugin = require("colord/plugins/xyz")
+
+extend([mixPlugin, namesPlugin, lchPlugin, hwbPlugin, labPlugin, xyzPlugin])
+
+module.exports = {
+  changeColorValuesToObject: function (input) {
+    const [h, s, l] = input.match(/\d+(\.\d+)?%|\d+(\.\d+)?/g).map(parseFloat)
+    return { h, s, l, a: 1 }
+  },
+
+  turnColorValuesToString: function (input) {
+    const [h, s, l] = input.match(/\d+(\.\d+)?%|\d+(\.\d+)?/g).map(parseFloat)
+    return `${h} ${s}% ${l}%`
+  },
+
+  generateForegroundColorFrom: function (input, percentage = 0.8) {
+    const str = colord(input)
+      .mix(colord(input).isDark() ? "white" : "black", percentage)
+      .toHslString()
+    return this.turnColorValuesToString(str)
+  },
+
+  generateDarkenColorFrom: function (input, percentage = 0.07) {
+    const str = colord(input).darken(percentage).toHslString()
+    return this.turnColorValuesToString(str)
+  },
+
+  convertColorFormat: function (input, colorFunction = "hsl") {
+    if (typeof input !== "object" || input === null) {
+      return input
+    }
+
+    const resultObj = {}
+
+    Object.entries(input).forEach(([rule, value]) => {
+      // if (!Object.hasOwn(colorNames, rule)) {
+      // resultObj[rule] = value
+      // } else {
+      //   let arr
+      //   if (getFormat(value) === "lch") {
+      //     arr = this.changeColorValuesToObject(value)
+      //   } else {
+      //     arr = colord(value).toLch()
+      //   }
+      //   resultObj[colorNames[rule]] = arr.l + " " + arr.c + " " + arr.h
+      // }
+
+      if (colorNames.hasOwnProperty(rule)) {
+        const hslArray = colord(value).toHsl()
+        resultObj[colorNames[rule]] = `${hslArray.h} ${hslArray.s}% ${hslArray.l}%`
+      } else {
+        resultObj[rule] = value
+      }
+
+      // if (getFormat("lch(" + value + ")") === "lch") {
+      //   resultObj[rule] = value
+      //   if (colorFunction === "hsl") {
+      //     let arr = colord("lch(" + value + ")").toHsl()
+      //     resultObj[rule] = arr.h + " " + arr.s + "% " + arr.l + "%"
+      //   }
+      // }
+
+      // auto generate focus colors
+      if (!Object.hasOwn(input, "primary-focus")) {
+        resultObj["--pf"] = this.generateDarkenColorFrom(input["primary"])
+      }
+      if (!Object.hasOwn(input, "secondary-focus")) {
+        resultObj["--sf"] = this.generateDarkenColorFrom(input["secondary"])
+      }
+      if (!Object.hasOwn(input, "accent-focus")) {
+        resultObj["--af"] = this.generateDarkenColorFrom(input["accent"])
+      }
+      if (!Object.hasOwn(input, "neutral-focus")) {
+        resultObj["--nf"] = this.generateDarkenColorFrom(input["neutral"])
+      }
+
+      // auto generate base colors
+      if (!Object.hasOwn(input, "base-100")) {
+        resultObj["--b1"] = "100 0 0"
+      }
+      if (!Object.hasOwn(input, "base-200")) {
+        resultObj["--b2"] = this.generateDarkenColorFrom(input["base-100"])
+      }
+      if (!Object.hasOwn(input, "base-300")) {
+        if (Object.hasOwn(input, "base-200")) {
+          resultObj["--b3"] = this.generateDarkenColorFrom(input["base-200"])
+        } else {
+          resultObj["--b3"] = this.generateDarkenColorFrom(input["base-100"], 0.14)
+        }
+      }
+
+      // auto generate state colors
+
+      if (!Object.hasOwn(input, "info")) {
+        resultObj["--in"] = 198 + " " + 93 + "%" + " " + 60 + "%"
+      }
+      if (!Object.hasOwn(input, "success")) {
+        resultObj["--su"] = 158 + " " + 64 + "%" + " " + 52 + "%"
+      }
+      if (!Object.hasOwn(input, "warning")) {
+        resultObj["--wa"] = 43 + " " + 96 + "%" + " " + 56 + "%"
+      }
+      if (!Object.hasOwn(input, "error")) {
+        resultObj["--er"] = 0 + " " + 91 + "%" + " " + 71 + "%"
+      }
+
+      // auto generate content colors
+      if (!Object.hasOwn(input, "base-content")) {
+        resultObj["--bc"] = this.generateForegroundColorFrom(input["base-100"])
+      }
+      if (!Object.hasOwn(input, "primary-content")) {
+        resultObj["--pc"] = this.generateForegroundColorFrom(input["primary"])
+      }
+      if (!Object.hasOwn(input, "secondary-content")) {
+        resultObj["--sc"] = this.generateForegroundColorFrom(input["secondary"])
+      }
+      if (!Object.hasOwn(input, "accent-content")) {
+        resultObj["--ac"] = this.generateForegroundColorFrom(input["accent"])
+      }
+      if (!Object.hasOwn(input, "neutral-content")) {
+        resultObj["--nc"] = this.generateForegroundColorFrom(input["neutral"])
+      }
+      if (!Object.hasOwn(input, "info-content")) {
+        if (Object.hasOwn(input, "info")) {
+          resultObj["--inc"] = this.generateForegroundColorFrom(input["info"])
+        } else {
+          resultObj["--inc"] = 198 + " " + 100 + "%" + " " + 12 + "%"
+        }
+      }
+      if (!Object.hasOwn(input, "success-content")) {
+        if (Object.hasOwn(input, "success")) {
+          resultObj["--suc"] = this.generateForegroundColorFrom(input["success"])
+        } else {
+          resultObj["--suc"] = 158 + " " + 100 + "%" + " " + 10 + "%"
+        }
+      }
+      if (!Object.hasOwn(input, "warning-content")) {
+        if (Object.hasOwn(input, "warning")) {
+          resultObj["--wac"] = this.generateForegroundColorFrom(input["warning"])
+        } else {
+          resultObj["--wac"] = 43 + " " + 100 + "%" + " " + 11 + "%"
+        }
+      }
+      if (!Object.hasOwn(input, "error-content")) {
+        if (Object.hasOwn(input, "error")) {
+          resultObj["--erc"] = this.generateForegroundColorFrom(input["error"])
+        } else {
+          resultObj["--erc"] = 0 + " " + 100 + "%" + " " + 14 + "%"
+        }
+      }
+
+      // add css variables if not exist
+      Object.entries(themeDefaults.variables).forEach((item) => {
+        const [variable, value] = item
+        if (!Object.hasOwn(input, variable)) {
+          resultObj[variable] = value
+        }
+      })
+
+      // add other custom styles
+      if (!colorNames.hasOwnProperty(rule)) {
+        resultObj[rule] = value
+      }
+    })
+
+    return resultObj
+  },
+
+  injectThemes: function (addBase, config, themes, colorFunction) {
+    const includedThemesObj = {}
+    // includedThemesObj["@supports (not(color: lch(0 0 0)))"] = {}
+    // add default themes
+    Object.entries(themes).forEach(([theme, value]) => {
+      if (colorFunction === "lch") {
+        includedThemesObj[theme] = this.convertColorFormat(value)
+      }
+      if (colorFunction === "hsl") {
+        includedThemesObj[theme] = this.convertColorFormat(value, "hsl")
+      }
+    })
+
+    // add custom themes
+    if (Array.isArray(config("daisyui.themes"))) {
+      config("daisyui.themes").forEach((item) => {
+        if (typeof item === "object" && item !== null) {
+          Object.entries(item).forEach(([customThemeName, customThemevalue]) => {
+            includedThemesObj["[data-theme=" + customThemeName + "]"] =
+              this.convertColorFormat(customThemevalue)
+          })
+        }
+      })
+    }
+
+    let themeOrder = []
+    if (Array.isArray(config("daisyui.themes"))) {
+      config("daisyui.themes").forEach((theme) => {
+        if (typeof theme === "object" && theme !== null) {
+          Object.keys(theme).forEach((customThemeName) => {
+            themeOrder.push(customThemeName)
+          })
+        } else if (Object.hasOwn(includedThemesObj, "[data-theme=" + theme + "]")) {
+          themeOrder.push(theme)
+        }
+      })
+    } else if (config("daisyui.themes") === true) {
+      themeOrder = themeDefaults.themeOrder
+    } else {
+      themeOrder = ["light", "dark"]
+    }
+
+    // inject themes in order
+    const themesToInject = {}
+    themeOrder.forEach((themeName, index) => {
+      if (index === 0) {
+        // first theme as root
+        themesToInject[":root"] = includedThemesObj["[data-theme=" + themeName + "]"]
+      } else if (index === 1) {
+        // auto dark
+        if (config("daisyui.darkTheme")) {
+          if (
+            themeOrder[0] !== config("daisyui.darkTheme") &&
+            themeOrder.includes(config("daisyui.darkTheme"))
+          ) {
+            themesToInject["@media (prefers-color-scheme: dark)"] = {
+              [":root"]: includedThemesObj[`[data-theme=${config("daisyui.darkTheme")}]`],
+            }
+          }
+        } else if (config("daisyui.darkTheme") === false) {
+          // disables prefers-color-scheme: dark
+        } else {
+          if (themeOrder[0] !== "dark" && themeOrder.includes("dark")) {
+            themesToInject["@media (prefers-color-scheme: dark)"] = {
+              [":root"]: includedThemesObj["[data-theme=dark]"],
+            }
+          }
+        }
+        // theme 0 with name
+        themesToInject["[data-theme=" + themeOrder[0] + "]"] =
+          includedThemesObj["[data-theme=" + themeOrder[0] + "]"]
+        // theme 1 with name
+        themesToInject["[data-theme=" + themeOrder[1] + "]"] =
+          includedThemesObj["[data-theme=" + themeOrder[1] + "]"]
+      } else {
+        themesToInject["[data-theme=" + themeName + "]"] =
+          includedThemesObj["[data-theme=" + themeName + "]"]
+      }
+    })
+    if (colorFunction === "lch") {
+      addBase({ "@supports (color: lch(0 0 0))": themesToInject })
+    }
+    if (colorFunction === "hsl") {
+      addBase(themesToInject)
+    }
+
+    return {
+      includedThemesObj,
+      themeOrder,
+    }
+  },
+}

package/website/node_modules/daisyui/src/theming/index.js

@@ -0,0 +1,39 @@
+let colorObject = {
+  "transparent": "transparent",
+  "current": "currentColor",
+
+  "primary": "hsl(var(--p) / <alpha-value>)",
+  "primary-focus": "hsl(var(--pf) / <alpha-value>)",
+  "primary-content": "hsl(var(--pc) / <alpha-value>)",
+
+  "secondary": "hsl(var(--s) / <alpha-value>)",
+  "secondary-focus": "hsl(var(--sf) / <alpha-value>)",
+  "secondary-content": "hsl(var(--sc) / <alpha-value>)",
+
+  "accent": "hsl(var(--a) / <alpha-value>)",
+  "accent-focus": "hsl(var(--af) / <alpha-value>)",
+  "accent-content": "hsl(var(--ac) / <alpha-value>)",
+
+  "neutral": "hsl(var(--n) / <alpha-value>)",
+  "neutral-focus": "hsl(var(--nf) / <alpha-value>)",
+  "neutral-content": "hsl(var(--nc) / <alpha-value>)",
+
+  "base-100": "hsl(var(--b1) / <alpha-value>)",
+  "base-200": "hsl(var(--b2) / <alpha-value>)",
+  "base-300": "hsl(var(--b3) / <alpha-value>)",
+  "base-content": "hsl(var(--bc) / <alpha-value>)",
+
+  "info": "hsl(var(--in) / <alpha-value>)",
+  "info-content": "hsl(var(--inc) / <alpha-value>)",
+
+  "success": "hsl(var(--su) / <alpha-value>)",
+  "success-content": "hsl(var(--suc) / <alpha-value>)",
+
+  "warning": "hsl(var(--wa) / <alpha-value>)",
+  "warning-content": "hsl(var(--wac) / <alpha-value>)",
+
+  "error": "hsl(var(--er) / <alpha-value>)",
+  "error-content": "hsl(var(--erc) / <alpha-value>)",
+}
+
+module.exports = colorObject