@shalomormsby/ui 0.0.5

package/dist/utils.mjs

@@ -0,0 +1,805 @@
+"use client";
+
+// src/lib/animations.ts
+var durations = {
+  instant: 0,
+  fast: 0.15,
+  normal: 0.3,
+  slow: 0.5,
+  slower: 0.7
+};
+var easings = {
+  // Standard easing - default for most transitions
+  standard: [0.4, 0, 0.2, 1],
+  // Deceleration - use when objects enter screen
+  decelerate: [0, 0, 0.2, 1],
+  // Acceleration - use when objects exit screen
+  accelerate: [0.4, 0, 1, 1],
+  // Sharp - use for very quick transitions
+  sharp: [0.4, 0, 0.6, 1],
+  // Bounce - playful animation
+  bounce: [0.68, -0.55, 0.265, 1.55]
+};
+var transitions = {
+  default: {
+    duration: durations.normal,
+    ease: easings.standard
+  },
+  fast: {
+    duration: durations.fast,
+    ease: easings.standard
+  },
+  slow: {
+    duration: durations.slow,
+    ease: easings.standard
+  },
+  bounce: {
+    duration: durations.normal,
+    ease: easings.bounce
+  },
+  spring: {
+    type: "spring",
+    damping: 20,
+    stiffness: 300
+  },
+  springBouncy: {
+    type: "spring",
+    damping: 10,
+    stiffness: 100
+  }
+};
+var fadeVariants = {
+  hidden: { opacity: 0 },
+  visible: { opacity: 1 },
+  exit: { opacity: 0 }
+};
+var slideVariants = {
+  fromLeft: {
+    hidden: { x: -20, opacity: 0 },
+    visible: { x: 0, opacity: 1 },
+    exit: { x: -20, opacity: 0 }
+  },
+  fromRight: {
+    hidden: { x: 20, opacity: 0 },
+    visible: { x: 0, opacity: 1 },
+    exit: { x: 20, opacity: 0 }
+  },
+  fromTop: {
+    hidden: { y: -20, opacity: 0 },
+    visible: { y: 0, opacity: 1 },
+    exit: { y: -20, opacity: 0 }
+  },
+  fromBottom: {
+    hidden: { y: 20, opacity: 0 },
+    visible: { y: 0, opacity: 1 },
+    exit: { y: 20, opacity: 0 }
+  }
+};
+var scaleVariants = {
+  default: {
+    hidden: { scale: 0.95, opacity: 0 },
+    visible: { scale: 1, opacity: 1 },
+    exit: { scale: 0.95, opacity: 0 }
+  },
+  grow: {
+    hidden: { scale: 0.8, opacity: 0 },
+    visible: { scale: 1, opacity: 1 },
+    exit: { scale: 0.8, opacity: 0 }
+  },
+  pop: {
+    hidden: { scale: 0 },
+    visible: { scale: 1 },
+    exit: { scale: 0 }
+  }
+};
+var rotateVariants = {
+  default: {
+    hidden: { rotate: -10, opacity: 0 },
+    visible: { rotate: 0, opacity: 1 },
+    exit: { rotate: 10, opacity: 0 }
+  },
+  flip: {
+    hidden: { rotateX: 90, opacity: 0 },
+    visible: { rotateX: 0, opacity: 1 },
+    exit: { rotateX: -90, opacity: 0 }
+  }
+};
+var listVariants = {
+  container: {
+    hidden: { opacity: 0 },
+    visible: {
+      opacity: 1,
+      transition: {
+        staggerChildren: 0.1
+      }
+    }
+  },
+  item: {
+    hidden: { y: 20, opacity: 0 },
+    visible: {
+      y: 0,
+      opacity: 1
+    }
+  }
+};
+var modalVariants = {
+  overlay: {
+    hidden: { opacity: 0 },
+    visible: { opacity: 1 },
+    exit: { opacity: 0 }
+  },
+  content: {
+    hidden: { scale: 0.95, opacity: 0, y: 20 },
+    visible: { scale: 1, opacity: 1, y: 0 },
+    exit: { scale: 0.95, opacity: 0, y: 20 }
+  }
+};
+var drawerVariants = {
+  fromLeft: {
+    hidden: { x: "-100%" },
+    visible: { x: 0 },
+    exit: { x: "-100%" }
+  },
+  fromRight: {
+    hidden: { x: "100%" },
+    visible: { x: 0 },
+    exit: { x: "100%" }
+  },
+  fromTop: {
+    hidden: { y: "-100%" },
+    visible: { y: 0 },
+    exit: { y: "-100%" }
+  },
+  fromBottom: {
+    hidden: { y: "100%" },
+    visible: { y: 0 },
+    exit: { y: "100%" }
+  }
+};
+var collapseVariants = {
+  collapsed: {
+    height: 0,
+    opacity: 0,
+    transition: { duration: durations.fast }
+  },
+  expanded: {
+    height: "auto",
+    opacity: 1,
+    transition: { duration: durations.normal }
+  }
+};
+var presets = {
+  /**
+   * Fade in/out animation
+   */
+  fade: {
+    initial: "hidden",
+    animate: "visible",
+    exit: "exit",
+    variants: fadeVariants,
+    transition: transitions.default
+  },
+  /**
+   * Slide from bottom animation
+   */
+  slideUp: {
+    initial: "hidden",
+    animate: "visible",
+    exit: "exit",
+    variants: slideVariants.fromBottom,
+    transition: transitions.default
+  },
+  /**
+   * Scale animation
+   */
+  scale: {
+    initial: "hidden",
+    animate: "visible",
+    exit: "exit",
+    variants: scaleVariants.default,
+    transition: transitions.default
+  },
+  /**
+   * Modal animation (overlay + content)
+   */
+  modal: {
+    overlay: {
+      initial: "hidden",
+      animate: "visible",
+      exit: "exit",
+      variants: modalVariants.overlay,
+      transition: transitions.fast
+    },
+    content: {
+      initial: "hidden",
+      animate: "visible",
+      exit: "exit",
+      variants: modalVariants.content,
+      transition: transitions.default
+    }
+  },
+  /**
+   * List stagger animation
+   */
+  list: {
+    container: {
+      initial: "hidden",
+      animate: "visible",
+      variants: listVariants.container
+    },
+    item: {
+      variants: listVariants.item
+    }
+  }
+};
+function createAnimation(variants, transition = transitions.default) {
+  return {
+    initial: "hidden",
+    animate: "visible",
+    exit: "exit",
+    variants,
+    transition
+  };
+}
+function scaleDuration(duration, scale) {
+  return duration * (scale / 10);
+}
+
+// src/lib/breadcrumbs.ts
+function generateBreadcrumbs(hash, routeConfig, baseUrl = "#") {
+  const cleanHash = hash.replace(/^#/, "").trim();
+  if (!cleanHash) {
+    return [{ label: "Home", href: baseUrl }];
+  }
+  const segments = cleanHash.split("/").filter(Boolean);
+  const breadcrumbs = [{ label: "Home", href: baseUrl }];
+  let currentPath = "";
+  let currentConfig = routeConfig;
+  for (let i = 0; i < segments.length; i++) {
+    const segment = segments[i];
+    const isLast = i === segments.length - 1;
+    currentPath += (currentPath ? "/" : "") + segment;
+    const config = currentConfig[segment];
+    if (!config) {
+      const label = segment.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+      breadcrumbs.push({
+        label,
+        // No href for the last item (current page)
+        href: isLast ? void 0 : `${baseUrl}${currentPath}`
+      });
+    } else {
+      breadcrumbs.push({
+        label: config.label,
+        // No href for the last item (current page)
+        href: isLast ? void 0 : `${baseUrl}${currentPath}`
+      });
+      if (config.children) {
+        currentConfig = config.children;
+      }
+    }
+  }
+  return breadcrumbs;
+}
+
+// src/lib/colors.ts
+var colorTokens = {
+  // Background colors
+  background: "var(--color-background)",
+  backgroundSecondary: "var(--color-background-secondary)",
+  backgroundTertiary: "var(--color-background-tertiary)",
+  surface: "var(--color-surface)",
+  // Foreground/Text colors
+  foreground: "var(--color-foreground)",
+  foregroundSecondary: "var(--color-foreground-secondary)",
+  foregroundTertiary: "var(--color-foreground-tertiary)",
+  textPrimary: "var(--color-text-primary)",
+  textSecondary: "var(--color-text-secondary)",
+  textMuted: "var(--color-text-muted)",
+  // Brand colors
+  primary: "var(--color-primary)",
+  primaryForeground: "var(--color-primary-foreground)",
+  secondary: "var(--color-secondary)",
+  secondaryForeground: "var(--color-secondary-foreground)",
+  accent: "var(--color-accent)",
+  accentForeground: "var(--color-accent-foreground)",
+  // Semantic colors
+  success: "var(--color-success)",
+  successForeground: "var(--color-success-foreground)",
+  warning: "var(--color-warning)",
+  warningForeground: "var(--color-warning-foreground)",
+  error: "var(--color-error)",
+  errorForeground: "var(--color-error-foreground)",
+  info: "var(--color-info)",
+  infoForeground: "var(--color-info-foreground)",
+  // Borders
+  border: "var(--color-border)",
+  borderSubtle: "var(--color-border-subtle)",
+  // Interactive states
+  hover: "var(--color-hover)",
+  active: "var(--color-active)",
+  focus: "var(--color-focus)",
+  // Links
+  link: "var(--color-link)",
+  linkHover: "var(--color-link-hover)",
+  linkHoverForeground: "var(--color-link-hover-foreground)"
+};
+function getCSSVariable(variableName, element = document.documentElement) {
+  const name = variableName.startsWith("--") ? variableName : `--${variableName}`;
+  return getComputedStyle(element).getPropertyValue(name).trim();
+}
+function setCSSVariable(variableName, value, element = document.documentElement) {
+  const name = variableName.startsWith("--") ? variableName : `--${variableName}`;
+  element.style.setProperty(name, value);
+}
+function getForegroundColor(backgroundToken) {
+  const token = backgroundToken.replace(/var\(|\)/g, "");
+  const foregroundMap = {
+    "--color-primary": "var(--color-primary-foreground)",
+    "--color-secondary": "var(--color-secondary-foreground)",
+    "--color-accent": "var(--color-accent-foreground)",
+    "--color-success": "var(--color-success-foreground)",
+    "--color-warning": "var(--color-warning-foreground)",
+    "--color-error": "var(--color-error-foreground)",
+    "--color-info": "var(--color-info-foreground)",
+    "--color-background": "var(--color-foreground)",
+    "--color-surface": "var(--color-text-primary)"
+  };
+  return foregroundMap[token] || "var(--color-text-primary)";
+}
+var semanticColors = {
+  /**
+   * Status colors for indicating states
+   */
+  status: {
+    success: {
+      bg: colorTokens.success,
+      fg: colorTokens.successForeground
+    },
+    warning: {
+      bg: colorTokens.warning,
+      fg: colorTokens.warningForeground
+    },
+    error: {
+      bg: colorTokens.error,
+      fg: colorTokens.errorForeground
+    },
+    info: {
+      bg: colorTokens.info,
+      fg: colorTokens.infoForeground
+    }
+  },
+  /**
+   * Brand colors for primary UI elements
+   */
+  brand: {
+    primary: {
+      bg: colorTokens.primary,
+      fg: colorTokens.primaryForeground
+    },
+    secondary: {
+      bg: colorTokens.secondary,
+      fg: colorTokens.secondaryForeground
+    },
+    accent: {
+      bg: colorTokens.accent,
+      fg: colorTokens.accentForeground
+    }
+  },
+  /**
+   * Interactive state colors
+   */
+  interactive: {
+    default: {
+      bg: colorTokens.background,
+      fg: colorTokens.foreground
+    },
+    hover: {
+      bg: colorTokens.hover,
+      fg: colorTokens.foreground
+    },
+    active: {
+      bg: colorTokens.active,
+      fg: colorTokens.foreground
+    },
+    focus: {
+      border: colorTokens.focus
+    }
+  }
+};
+function getSemanticColorPair(type) {
+  if (type === "primary" || type === "secondary" || type === "accent") {
+    return semanticColors.brand[type];
+  }
+  return semanticColors.status[type];
+}
+function hexToRgb(hex) {
+  const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+  return result ? {
+    r: parseInt(result[1], 16),
+    g: parseInt(result[2], 16),
+    b: parseInt(result[3], 16)
+  } : null;
+}
+function getLuminance(r, g, b) {
+  const [rs, gs, bs] = [r, g, b].map((c) => {
+    const srgb = c / 255;
+    return srgb <= 0.03928 ? srgb / 12.92 : Math.pow((srgb + 0.055) / 1.055, 2.4);
+  });
+  return 0.2126 * rs + 0.7152 * gs + 0.0722 * bs;
+}
+function getContrastRatio(hex1, hex2) {
+  const rgb1 = hexToRgb(hex1);
+  const rgb2 = hexToRgb(hex2);
+  if (!rgb1 || !rgb2) return 0;
+  const lum1 = getLuminance(rgb1.r, rgb1.g, rgb1.b);
+  const lum2 = getLuminance(rgb2.r, rgb2.g, rgb2.b);
+  const lighter = Math.max(lum1, lum2);
+  const darker = Math.min(lum1, lum2);
+  return (lighter + 0.05) / (darker + 0.05);
+}
+function meetsContrastRequirements(foreground, background, level = "AA", size = "normal") {
+  const ratio = getContrastRatio(foreground, background);
+  const requirements = {
+    AA: { normal: 4.5, large: 3 },
+    AAA: { normal: 7, large: 4.5 }
+  };
+  return ratio >= requirements[level][size];
+}
+function hexToHSL(hex) {
+  const rgb = hexToRgb(hex);
+  if (!rgb) return { h: 0, s: 0, l: 0 };
+  const r = rgb.r / 255;
+  const g = rgb.g / 255;
+  const b = rgb.b / 255;
+  const max = Math.max(r, g, b);
+  const min = Math.min(r, g, b);
+  let h = 0, s = 0, l = (max + min) / 2;
+  if (max !== min) {
+    const d = max - min;
+    s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+    switch (max) {
+      case r:
+        h = ((g - b) / d + (g < b ? 6 : 0)) / 6;
+        break;
+      case g:
+        h = ((b - r) / d + 2) / 6;
+        break;
+      case b:
+        h = ((r - g) / d + 4) / 6;
+        break;
+    }
+  }
+  return {
+    h: Math.round(h * 360),
+    s: Math.round(s * 100),
+    l: Math.round(l * 100)
+  };
+}
+function hslToHex(h, s, l) {
+  h = h / 360;
+  s = s / 100;
+  l = l / 100;
+  let r, g, b;
+  if (s === 0) {
+    r = g = b = l;
+  } else {
+    const hue2rgb = (p2, q2, t) => {
+      if (t < 0) t += 1;
+      if (t > 1) t -= 1;
+      if (t < 1 / 6) return p2 + (q2 - p2) * 6 * t;
+      if (t < 1 / 2) return q2;
+      if (t < 2 / 3) return p2 + (q2 - p2) * (2 / 3 - t) * 6;
+      return p2;
+    };
+    const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+    const p = 2 * l - q;
+    r = hue2rgb(p, q, h + 1 / 3);
+    g = hue2rgb(p, q, h);
+    b = hue2rgb(p, q, h - 1 / 3);
+  }
+  const toHex = (x) => {
+    const hex = Math.round(x * 255).toString(16);
+    return hex.length === 1 ? "0" + hex : hex;
+  };
+  return `#${toHex(r)}${toHex(g)}${toHex(b)}`;
+}
+function adjustLightness(hex, percent) {
+  const hsl = hexToHSL(hex);
+  const newL = Math.max(0, Math.min(100, hsl.l + percent));
+  return hslToHex(hsl.h, hsl.s, newL);
+}
+function adjustSaturation(hex, percent) {
+  const hsl = hexToHSL(hex);
+  const newS = Math.max(0, Math.min(100, hsl.s + percent));
+  return hslToHex(hsl.h, newS, hsl.l);
+}
+function rotateHue(hex, degrees) {
+  const hsl = hexToHSL(hex);
+  const newH = (hsl.h + degrees) % 360;
+  return hslToHex(newH, hsl.s, hsl.l);
+}
+function adjustOpacity(hex, opacity) {
+  const rgb = hexToRgb(hex);
+  if (!rgb) return hex;
+  return `rgba(${rgb.r}, ${rgb.g}, ${rgb.b}, ${opacity})`;
+}
+function getOptimalForeground(bgHex, whiteHex = "#ffffff", blackHex = "#000000") {
+  const whiteRatio = getContrastRatio(bgHex, whiteHex);
+  const blackRatio = getContrastRatio(bgHex, blackHex);
+  return whiteRatio > blackRatio ? whiteHex : blackHex;
+}
+function generateColorScale(baseHex) {
+  const hsl = hexToHSL(baseHex);
+  return {
+    50: hslToHex(hsl.h, Math.max(hsl.s - 10, 20), 95),
+    100: hslToHex(hsl.h, Math.max(hsl.s - 5, 30), 90),
+    200: hslToHex(hsl.h, hsl.s, 80),
+    300: hslToHex(hsl.h, hsl.s, 70),
+    400: hslToHex(hsl.h, hsl.s, 60),
+    500: baseHex,
+    // Base color
+    600: hslToHex(hsl.h, Math.min(hsl.s + 5, 100), 45),
+    700: hslToHex(hsl.h, Math.min(hsl.s + 10, 100), 35),
+    800: hslToHex(hsl.h, Math.min(hsl.s + 15, 100), 25),
+    900: hslToHex(hsl.h, Math.min(hsl.s + 20, 100), 15)
+  };
+}
+var colorUtils = {
+  getCSSVariable,
+  setCSSVariable,
+  getForegroundColor,
+  getSemanticColorPair,
+  hexToRgb,
+  hexToHSL,
+  hslToHex,
+  adjustLightness,
+  adjustSaturation,
+  rotateHue,
+  adjustOpacity,
+  getOptimalForeground,
+  generateColorScale,
+  getContrastRatio,
+  meetsContrastRequirements
+};
+
+// src/lib/utils.ts
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+function cn(...inputs) {
+  return twMerge(clsx(inputs));
+}
+
+// src/lib/validation.ts
+var patterns = {
+  email: {
+    value: /^[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}$/i,
+    message: "Invalid email address"
+  },
+  url: {
+    value: /^https?:\/\/.+\..+/,
+    message: "Invalid URL"
+  },
+  phone: {
+    value: /^[\d\s\-\+\(\)]+$/,
+    message: "Invalid phone number"
+  },
+  alphanumeric: {
+    value: /^[a-zA-Z0-9]+$/,
+    message: "Only letters and numbers allowed"
+  },
+  noSpaces: {
+    value: /^\S+$/,
+    message: "Spaces are not allowed"
+  }
+};
+function validateField(value, rules2) {
+  if (rules2.required) {
+    const isEmpty = value === void 0 || value === null || value === "" || Array.isArray(value) && value.length === 0;
+    if (isEmpty) {
+      return typeof rules2.required === "string" ? rules2.required : "This field is required";
+    }
+  }
+  if (!value && !rules2.required) {
+    return void 0;
+  }
+  if (rules2.minLength && value.length < rules2.minLength.value) {
+    return rules2.minLength.message;
+  }
+  if (rules2.maxLength && value.length > rules2.maxLength.value) {
+    return rules2.maxLength.message;
+  }
+  if (rules2.pattern && !rules2.pattern.value.test(value)) {
+    return rules2.pattern.message;
+  }
+  if (rules2.custom) {
+    for (const rule of rules2.custom) {
+      if (!rule.validate(value)) {
+        return rule.message;
+      }
+    }
+  }
+  return void 0;
+}
+function validateForm(values, validations) {
+  const errors = {};
+  for (const [field, rules2] of Object.entries(validations)) {
+    const error = validateField(values[field], rules2);
+    if (error) {
+      errors[field] = error;
+    }
+  }
+  return errors;
+}
+function hasErrors(errors) {
+  return Object.values(errors).some((error) => error !== void 0);
+}
+var rules = {
+  required: (message = "This field is required") => ({
+    required: message
+  }),
+  email: (message = "Invalid email address") => ({
+    pattern: { value: patterns.email.value, message }
+  }),
+  minLength: (length, message) => ({
+    minLength: {
+      value: length,
+      message: message || `Minimum ${length} characters required`
+    }
+  }),
+  maxLength: (length, message) => ({
+    maxLength: {
+      value: length,
+      message: message || `Maximum ${length} characters allowed`
+    }
+  }),
+  match: (otherValue, message = "Values do not match") => ({
+    custom: [
+      {
+        validate: (value) => value === otherValue,
+        message
+      }
+    ]
+  })
+};
+
+// src/lib/syntax-parser/patterns.ts
+var TOKEN_PATTERNS = [
+  // Single-line comments
+  { type: "comment", pattern: /\/\/.*$/gm },
+  // Multi-line comments
+  { type: "comment", pattern: /\/\*[\s\S]*?\*\//g },
+  // Template literals and strings
+  { type: "string", pattern: /`(?:\\.|[^`\\])*`/g },
+  { type: "string", pattern: /"(?:\\.|[^"\\])*"/g },
+  { type: "string", pattern: /'(?:\\.|[^'\\])*'/g },
+  // JSX/TSX tags
+  { type: "tag", pattern: /<\/?[A-Z][a-zA-Z0-9]*(?=[\s>])/g },
+  { type: "tag", pattern: /<\/?[a-z][a-zA-Z0-9-]*(?=[\s>])/g },
+  // Keywords
+  {
+    type: "keyword",
+    pattern: /\b(const|let|var|function|return|if|else|for|while|do|switch|case|break|continue|throw|try|catch|finally|new|typeof|instanceof|void|delete|async|await|yield|export|import|from|default|class|extends|implements|interface|type|enum|namespace|declare|public|private|protected|static|readonly|abstract|as|is|in|of|null|undefined)\b/g
+  },
+  // Booleans
+  { type: "boolean", pattern: /\b(true|false)\b/g },
+  // Numbers
+  { type: "number", pattern: /\b\d+\.?\d*(?:e[+-]?\d+)?(?:n)?\b/gi },
+  { type: "number", pattern: /\b0x[0-9a-f]+\b/gi },
+  // Function calls
+  { type: "function", pattern: /\b[a-zA-Z_$][a-zA-Z0-9_$]*(?=\s*\()/g },
+  // Class names (PascalCase identifiers)
+  { type: "className", pattern: /\b[A-Z][a-zA-Z0-9]*\b/g },
+  // JSX attributes
+  { type: "attribute", pattern: /\b[a-z][a-zA-Z0-9]*(?=\s*=)/g },
+  // Object properties (after dot)
+  { type: "property", pattern: /(?<=\.)[a-zA-Z_$][a-zA-Z0-9_$]*/g },
+  // Operators
+  {
+    type: "operator",
+    pattern: /[+\-*/%=!<>&|^~?:]+|&&|\|\||\.\.\.|\?\?|===|!==|==|!=|<=|>=|<<|>>|>>>/g
+  },
+  // Punctuation
+  { type: "punctuation", pattern: /[{}[\](),.;]/g }
+];
+
+// src/lib/syntax-parser/tokenizer.ts
+function tokenize(code, language = "typescript") {
+  if (!code || code.trim() === "") {
+    return [{ text: code, type: "plain" }];
+  }
+  const matches = [];
+  for (const { type, pattern } of TOKEN_PATTERNS) {
+    pattern.lastIndex = 0;
+    let match;
+    while ((match = pattern.exec(code)) !== null) {
+      matches.push({
+        text: match[0],
+        type,
+        index: match.index
+      });
+    }
+  }
+  matches.sort((a, b) => a.index - b.index);
+  const nonOverlapping = [];
+  let lastEnd = 0;
+  for (const match of matches) {
+    if (match.index >= lastEnd) {
+      nonOverlapping.push(match);
+      lastEnd = match.index + match.text.length;
+    }
+  }
+  const tokens = [];
+  let position = 0;
+  for (const match of nonOverlapping) {
+    if (match.index > position) {
+      const plainText = code.slice(position, match.index);
+      tokens.push({ text: plainText, type: "plain" });
+    }
+    tokens.push({ text: match.text, type: match.type });
+    position = match.index + match.text.length;
+  }
+  if (position < code.length) {
+    tokens.push({ text: code.slice(position), type: "plain" });
+  }
+  return tokens;
+}
+function detectLanguage(code, filename) {
+  if (filename) {
+    if (filename.endsWith(".tsx")) return "tsx";
+    if (filename.endsWith(".jsx")) return "jsx";
+    if (filename.endsWith(".js")) return "javascript";
+  }
+  return "typescript";
+}
+
+// src/lib/syntax-parser/index.ts
+function parseCode(code, language) {
+  const lang = language || detectLanguage(code);
+  return tokenize(code, lang);
+}
+export {
+  adjustLightness,
+  adjustOpacity,
+  adjustSaturation,
+  cn,
+  collapseVariants,
+  colorTokens,
+  colorUtils,
+  createAnimation,
+  detectLanguage,
+  drawerVariants,
+  durations,
+  easings,
+  fadeVariants,
+  generateBreadcrumbs,
+  generateColorScale,
+  getCSSVariable,
+  getContrastRatio,
+  getForegroundColor,
+  getLuminance,
+  getOptimalForeground,
+  getSemanticColorPair,
+  hasErrors,
+  hexToHSL,
+  hexToRgb,
+  hslToHex,
+  listVariants,
+  meetsContrastRequirements,
+  modalVariants,
+  parseCode,
+  patterns,
+  presets,
+  rotateHue,
+  rotateVariants,
+  rules,
+  scaleDuration,
+  scaleVariants,
+  semanticColors,
+  setCSSVariable,
+  slideVariants,
+  tokenize,
+  transitions,
+  validateField,
+  validateForm
+};
+//# sourceMappingURL=utils.mjs.map