app-studio 0.1.44 → 0.2.2

package/dist/appstudio.cjs.development.js

@@ -0,0 +1,2130 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
+
+var React = require('react');
+var React__default = _interopDefault(React);
+var Color = _interopDefault(require('color-convert'));
+
+const palette = {
+  white: {
+    50: 'rgba(255, 255, 255, 0.04)',
+    100: 'rgba(255, 255, 255, 0.08)',
+    200: 'rgba(255, 255, 255, 0.16)',
+    300: 'rgba(255, 255, 255, 0.24)',
+    400: 'rgba(255, 255, 255, 0.36)',
+    500: 'rgba(255, 255, 255, 0.48)',
+    600: 'rgba(255, 255, 255, 0.64)',
+    700: 'rgba(255, 255, 255, 0.80)',
+    800: 'rgba(255, 255, 255, 0.92)',
+    900: 'rgba(255, 255, 255, 1)'
+  },
+  black: {
+    50: 'rgba(0, 0, 0, 0.04)',
+    100: 'rgba(0, 0, 0, 0.08)',
+    200: 'rgba(0, 0, 0, 0.16)',
+    300: 'rgba(0, 0, 0, 0.24)',
+    400: 'rgba(0, 0, 0, 0.36)',
+    500: 'rgba(0, 0, 0, 0.48)',
+    600: 'rgba(0, 0, 0, 0.64)',
+    700: 'rgba(0, 0, 0, 0.80)',
+    800: 'rgba(0, 0, 0, 0.92)',
+    900: 'rgba(0, 0, 0, 1)'
+  },
+  rose: {
+    50: '#fff1f2',
+    100: '#ffe4e6',
+    200: '#fecdd3',
+    300: '#fda4af',
+    400: '#fb7185',
+    500: '#f43f5e',
+    600: '#e11d48',
+    700: '#be123c',
+    800: '#9f1239',
+    900: '#881337'
+  },
+  pink: {
+    50: '#fdf2f8',
+    100: '#fce7f3',
+    200: '#fbcfe8',
+    300: '#f9a8d4',
+    400: '#f472b6',
+    500: '#ec4899',
+    600: '#db2777',
+    700: '#be185d',
+    800: '#9d174d',
+    900: '#831843'
+  },
+  fuchsia: {
+    50: '#fdf4ff',
+    100: '#fae8ff',
+    200: '#f5d0fe',
+    300: '#f0abfc',
+    400: '#e879f9',
+    500: '#d946ef',
+    600: '#c026d3',
+    700: '#a21caf',
+    800: '#86198f',
+    900: '#701a75'
+  },
+  purple: {
+    50: '#faf5ff',
+    100: '#f3e8ff',
+    200: '#e9d5ff',
+    300: '#d8b4fe',
+    400: '#c084fc',
+    500: '#a855f7',
+    600: '#9333ea',
+    700: '#7e22ce',
+    800: '#6b21a8',
+    900: '#581c87'
+  },
+  violet: {
+    50: '#f5f3ff',
+    100: '#ede9fe',
+    200: '#ddd6fe',
+    300: '#c4b5fd',
+    400: '#a78bfa',
+    500: '#8b5cf6',
+    600: '#7c3aed',
+    700: '#6d28d9',
+    800: '#5b21b6',
+    900: '#4c1d95'
+  },
+  indigo: {
+    50: '#eef2ff',
+    100: '#e0e7ff',
+    200: '#c7d2fe',
+    300: '#a5b4fc',
+    400: '#818cf8',
+    500: '#6366f1',
+    600: '#4f46e5',
+    700: '#4338ca',
+    800: '#3730a3',
+    900: '#312e81'
+  },
+  blue: {
+    50: '#eff6ff',
+    100: '#dbeafe',
+    200: '#bfdbfe',
+    300: '#93c5fd',
+    400: '#60a5fa',
+    500: '#3b82f6',
+    600: '#2563eb',
+    700: '#1d4ed8',
+    800: '#1e40af',
+    900: '#1e3a8a'
+  },
+  lightBlue: {
+    50: '#f0f9ff',
+    100: '#e0f2fe',
+    200: '#bae6fd',
+    300: '#7dd3fc',
+    400: '#38bdf8',
+    500: '#0ea5e9',
+    600: '#0284c7',
+    700: '#0369a1',
+    800: '#075985',
+    900: '#0c4a6e'
+  },
+  cyan: {
+    50: '#ecfeff',
+    100: '#cffafe',
+    200: '#a5f3fc',
+    300: '#67e8f9',
+    400: '#22d3ee',
+    500: '#06b6d4',
+    600: '#0891b2',
+    700: '#0e7490',
+    800: '#155e75',
+    900: '#164e63'
+  },
+  teal: {
+    50: '#f0fdfa',
+    100: '#ccfbf1',
+    200: '#99f6e4',
+    300: '#5eead4',
+    400: '#2dd4bf',
+    500: '#14b8a6',
+    600: '#0d9488',
+    700: '#0f766e',
+    800: '#115e59',
+    900: '#134e4a'
+  },
+  emerald: {
+    50: '#ecfdf5',
+    100: '#d1fae5',
+    200: '#a7f3d0',
+    300: '#6ee7b7',
+    400: '#34d399',
+    500: '#10b981',
+    600: '#059669',
+    700: '#047857',
+    800: '#065f46',
+    900: '#064e3b'
+  },
+  green: {
+    50: '#f0fdf4',
+    100: '#dcfce7',
+    200: '#bbf7d0',
+    300: '#86efac',
+    400: '#4ade80',
+    500: '#22c55e',
+    600: '#16a34a',
+    700: '#15803d',
+    800: '#166534',
+    900: '#14532d'
+  },
+  lime: {
+    50: '#f7fee7',
+    100: '#ecfccb',
+    200: '#d9f99d',
+    300: '#bef264',
+    400: '#a3e635',
+    500: '#84cc16',
+    600: '#65a30d',
+    700: '#4d7c0f',
+    800: '#3f6212',
+    900: '#365314'
+  },
+  yellow: {
+    50: '#fefce8',
+    100: '#fef9c3',
+    200: '#fef08a',
+    300: '#fde047',
+    400: '#facc15',
+    500: '#eab308',
+    600: '#ca8a04',
+    700: '#a16207',
+    800: '#854d0e',
+    900: '#713f12'
+  },
+  amber: {
+    50: '#fffbeb',
+    100: '#fef3c7',
+    200: '#fde68a',
+    300: '#fcd34d',
+    400: '#fbbf24',
+    500: '#f59e0b',
+    600: '#d97706',
+    700: '#b45309',
+    800: '#92400e',
+    900: '#78350f'
+  },
+  orange: {
+    50: '#fff7ed',
+    100: '#ffedd5',
+    200: '#fed7aa',
+    300: '#fdba74',
+    400: '#fb923c',
+    500: '#f97316',
+    600: '#ea580c',
+    700: '#c2410c',
+    800: '#9a3412',
+    900: '#7c2d12'
+  },
+  red: {
+    50: '#fef2f2',
+    100: '#fee2e2',
+    200: '#fecaca',
+    300: '#fca5a5',
+    400: '#f87171',
+    500: '#ef4444',
+    600: '#dc2626',
+    700: '#b91c1c',
+    800: '#991b1b',
+    900: '#7f1d1d'
+  },
+  warmGray: {
+    50: '#fafaf9',
+    100: '#f5f5f4',
+    200: '#e7e5e4',
+    300: '#d6d3d1',
+    400: '#a8a29e',
+    500: '#78716c',
+    600: '#57534e',
+    700: '#44403c',
+    800: '#292524',
+    900: '#1c1917'
+  },
+  trueGray: {
+    50: '#fafafa',
+    100: '#f5f5f5',
+    200: '#e5e5e5',
+    300: '#d4d4d4',
+    400: '#a3a3a3',
+    500: '#737373',
+    600: '#525252',
+    700: '#404040',
+    800: '#262626',
+    900: '#171717'
+  },
+  gray: {
+    50: '#fafafa',
+    100: '#f4f4f5',
+    200: '#e4e4e7',
+    300: '#d4d4d8',
+    400: '#a1a1aa',
+    500: '#71717a',
+    600: '#52525b',
+    700: '#3f3f46',
+    800: '#27272a',
+    900: '#18181b'
+  },
+  dark: {
+    50: '#18181b',
+    100: '#27272a',
+    200: '#3f3f46',
+    300: '#52525b',
+    400: '#71717a',
+    500: '#a1a1aa',
+    600: '#d4d4d8',
+    700: '#e4e4e7',
+    800: '#f4f4f5',
+    900: '#fafafa'
+  },
+  coolGray: {
+    50: '#f9fafb',
+    100: '#f3f4f6',
+    200: '#e5e7eb',
+    300: '#d1d5db',
+    400: '#9ca3af',
+    500: '#6b7280',
+    600: '#4b5563',
+    700: '#374151',
+    800: '#1f2937',
+    900: '#111827'
+  },
+  blueGray: {
+    50: '#f8fafc',
+    100: '#f1f5f9',
+    200: '#e2e8f0',
+    300: '#cbd5e1',
+    400: '#94a3b8',
+    500: '#64748b',
+    600: '#475569',
+    700: '#334155',
+    800: '#1e293b',
+    900: '#0f172a'
+  }
+};
+
+const defaultThemeMain = {
+  primary: 'color.black',
+  secondary: 'color.blue',
+  success: 'color.green.500',
+  error: 'color.red.500',
+  warning: 'color.orange.500',
+  disabled: 'color.gray.500',
+  loading: 'color.dark.500'
+};
+const defaultColors = {
+  white: '#FFFFFF',
+  black: '#000000',
+  red: '#FF0000',
+  green: '#00FF00',
+  blue: '#0000FF',
+  yellow: '#FFFF00',
+  cyan: '#00FFFF',
+  magenta: '#FF00FF',
+  grey: '#808080',
+  orange: '#FFA500',
+  brown: '#A52A2A',
+  purple: '#800080',
+  pink: '#FFC0CB',
+  lime: '#00FF00',
+  teal: '#008080',
+  navy: '#000080',
+  olive: '#808000',
+  maroon: '#800000',
+  gold: '#FFD700',
+  silver: '#C0C0C0',
+  indigo: '#4B0082',
+  violet: '#EE82EE',
+  beige: '#F5F5DC',
+  turquoise: '#40E0D0',
+  coral: '#FF7F50',
+  chocolate: '#D2691E',
+  skyBlue: '#87CEEB',
+  plum: '#DDA0DD',
+  darkGreen: '#006400',
+  salmon: '#FA8072'
+};
+const ThemeContext = /*#__PURE__*/React.createContext({
+  getColor: name => {
+    return name;
+  },
+  colors: {
+    main: defaultColors,
+    palette: palette
+  },
+  theme: {
+    main: defaultThemeMain,
+    components: {}
+  }
+});
+const useTheme = () => React.useContext(ThemeContext);
+const ThemeProvider = _ref => {
+  let {
+    theme = {
+      main: defaultThemeMain,
+      components: {}
+    },
+    colors = {
+      main: defaultColors,
+      palette: palette
+    },
+    children
+  } = _ref;
+  const getColor = name => {
+    if (name === 'transparent') return name;
+    try {
+      // Si le nom commence par "theme.", nous recherchons dans les couleurs du thème
+      if (name.startsWith('theme.')) {
+        const keys = name.split('.');
+        if (keys[1] !== undefined && typeof theme.components[keys[1]] == 'object' && theme.components[keys[1]][keys[2]] !== undefined) {
+          return getColor(theme.components[keys[1]][keys[2]]);
+        } else if (theme.main[keys[1]] && theme.main[keys[1]] !== undefined) {
+          return getColor(theme.main[keys[1]]);
+        } else {
+          console.log('Color ' + name + ' not found');
+        }
+      }
+      // Si le nom commence par "color.", nous recherchons dans la palette
+      else if (name.startsWith('color.')) {
+        const keys = name.split('.'); // Retirer le préfixe "color."
+        if (colors.palette && colors.palette[keys[1]][keys[2]] !== undefined) {
+          return colors.palette[keys[1]][keys[2]];
+        } else if (colors.palette && colors.palette[keys[1]][parseInt(keys[2])] !== undefined) {
+          return colors.palette[keys[1]][parseInt(keys[2])];
+        } else if (colors.main && colors.main[keys[1]] !== undefined) {
+          return colors.main[keys[1]];
+        } else {
+          console.log('Color ' + name + ' not found');
+        }
+      }
+    } catch (e) {}
+    return name;
+  };
+  return /*#__PURE__*/React__default.createElement(ThemeContext.Provider, {
+    value: {
+      getColor,
+      theme: {
+        main: {
+          ...defaultThemeMain,
+          ...theme.main
+        },
+        components: {
+          ...theme.components
+        }
+      },
+      colors: {
+        main: {
+          ...defaultColors,
+          ...colors.main
+        },
+        palette: {
+          ...palette,
+          ...colors.palette
+        }
+      }
+    }
+  }, children);
+};
+
+const defaultBreakpointsConfig = {
+  xs: 0,
+  sm: 340,
+  md: 560,
+  lg: 1080,
+  xl: 1300
+};
+const defaultDeviceConfig = {
+  mobile: ['xs', 'sm'],
+  tablet: ['md', 'lg'],
+  desktop: ['lg', 'xl']
+};
+const getMediaQueries = b => {
+  const defaultKeys = Object.keys(b);
+  const breakpointValue = defaultKeys.map(breakpoint => {
+    const value = {
+      breakpoint: breakpoint,
+      min: b[breakpoint],
+      max: 0
+    };
+    return value;
+  }).sort((a, b) => a.min - b.min);
+  breakpointValue.reduce((a, b) => {
+    if (b) a.max = b.min;
+    return b;
+  });
+  const query = {};
+  breakpointValue.map(sizeScreen => {
+    query[sizeScreen.breakpoint] = `only screen ${sizeScreen.min && sizeScreen.min >= 0 ? 'and (min-width:' + sizeScreen.min + 'px)' : ''} ${sizeScreen.max && sizeScreen.max >= 0 ? 'and (max-width:' + sizeScreen.max + 'px)' : ''}`;
+  });
+  return query;
+};
+const defaultScreenConfig = {
+  breakpoints: defaultBreakpointsConfig,
+  devices: defaultDeviceConfig,
+  mediaQueries: /*#__PURE__*/getMediaQueries(defaultBreakpointsConfig)
+};
+const ResponsiveContext = /*#__PURE__*/React.createContext(defaultScreenConfig);
+const useResponsiveContext = () => React.useContext(ResponsiveContext);
+const ResponsiveProvider = _ref => {
+  let {
+    breakpoints = defaultBreakpointsConfig,
+    devices = defaultDeviceConfig,
+    children
+  } = _ref;
+  return /*#__PURE__*/React__default.createElement(ResponsiveContext.Provider, {
+    value: {
+      breakpoints,
+      devices,
+      mediaQueries: getMediaQueries(breakpoints)
+    }
+  }, children);
+};
+
+// List of numeric properties that don't need 'px' suffix
+const NumberProps = /*#__PURE__*/new Set(['numberOfLines', 'fontWeight', 'timeStamp', 'flex', 'flexGrow', 'flexShrink', 'order', 'zIndex', 'aspectRatio', 'shadowOpacity', 'shadowRadius', 'scale', 'opacity', 'min', 'max', 'now']);
+// Keys to exclude when passing props to the component
+const excludedKeys = /*#__PURE__*/new Set(['on', 'shadow', 'only', 'media', 'css', 'size', 'paddingHorizontal', 'paddingVertical', 'marginHorizontal', 'marginVertical', 'animate']);
+// Keys to exclude when passing props to the component
+const extraKeys = /*#__PURE__*/new Set(['on', 'shadow', 'only', 'media', 'css']);
+const includeKeys = /*#__PURE__*/new Set(['src', 'alt', 'style', 'as']);
+
+// styleHelpers.ts
+// Function to convert style object to CSS string
+const styleObjectToCss = styleObj => {
+  return Object.entries(styleObj).map(_ref => {
+    let [key, value] = _ref;
+    return `${toKebabCase(key)}: ${value};`;
+  }).join(' ');
+};
+// Function to convert camelCase to kebab-case
+const toKebabCase = str => str.replace(/([A-Z])/g, match => '-' + match.toLowerCase());
+// Function to check if a property is a style prop
+const isStyleProp = prop => {
+  // Implement your logic to determine if a prop is a style prop
+  // For simplicity, we assume all props not in excludedKeys are style props
+  return !excludedKeys.has(prop);
+};
+// Function to process and normalize style properties
+const processStyleProperty = (property, value, getColor) => {
+  if (typeof value === 'number' && !NumberProps.has(property)) {
+    return `${value}px`;
+  } else if (property.toLowerCase().includes('color')) {
+    return getColor(value);
+  } else {
+    return value;
+  }
+};
+
+/* eslint-disable @typescript-eslint/no-unused-vars */
+let keyframesCounter = 0;
+const keyframesCache = /*#__PURE__*/new Map();
+const generateKeyframes = animation => {
+  // Exclure les propriétés qui ne font pas partie des keyframes
+  const {
+    duration,
+    timingFunction,
+    delay,
+    iterationCount,
+    direction,
+    fillMode,
+    playState,
+    ...keyframesDef
+  } = animation;
+  // Générer une clé pour le cache basée sur les keyframes
+  const animationConfigString = JSON.stringify(keyframesDef);
+  if (keyframesCache.has(animationConfigString)) {
+    const keyframesName = keyframesCache.get(animationConfigString);
+    return {
+      keyframesName,
+      keyframes: ''
+    }; // Les keyframes existent déjà
+  }
+
+  const keyframesName = `animation-${keyframesCounter++}`;
+  keyframesCache.set(animationConfigString, keyframesName);
+  const keyframesContent = [];
+  // Trier les clés pour assurer un ordre cohérent
+  const keyframeKeys = Object.keys(keyframesDef).sort((a, b) => {
+    const getPercentage = key => {
+      if (key === 'from') return 0;
+      if (key === 'to' || key === 'enter') return 100;
+      return parseInt(key.replace('%', ''), 10);
+    };
+    return getPercentage(a) - getPercentage(b);
+  });
+  keyframeKeys.forEach(key => {
+    const cssKey = key === 'enter' ? 'to' : key; // Remplacer 'enter' par 'to'
+    const styles = keyframesDef[key];
+    keyframesContent.push(`${cssKey} { ${styleObjectToCss(styles)} }`);
+  });
+  const keyframes = `
+    @keyframes ${keyframesName} {
+      ${keyframesContent.join('\n')}
+    }
+  `;
+  return {
+    keyframesName,
+    keyframes
+  };
+};
+
+const Shadows = {
+  0: {
+    shadowColor: '#000',
+    shadowOffset: {
+      width: 1,
+      height: 2
+    },
+    shadowOpacity: 0.18,
+    shadowRadius: 1.0
+  },
+  1: {
+    shadowColor: '#000',
+    shadowOffset: {
+      width: 2,
+      height: 2
+    },
+    shadowOpacity: 0.2,
+    shadowRadius: 1.41
+  },
+  2: {
+    shadowColor: '#000',
+    shadowOffset: {
+      width: 3,
+      height: 3
+    },
+    shadowOpacity: 0.22,
+    shadowRadius: 2.22
+  },
+  3: {
+    shadowColor: '#000',
+    shadowOffset: {
+      width: 4,
+      height: 4
+    },
+    shadowOpacity: 0.23,
+    shadowRadius: 2.62
+  },
+  4: {
+    shadowColor: '#000',
+    shadowOffset: {
+      width: 5,
+      height: 5
+    },
+    shadowOpacity: 0.25,
+    shadowRadius: 3.84
+  },
+  5: {
+    shadowColor: '#000',
+    shadowOffset: {
+      width: 6,
+      height: 6
+    },
+    shadowOpacity: 0.27,
+    shadowRadius: 4.65
+  },
+  6: {
+    shadowColor: '#000',
+    shadowOffset: {
+      width: 7,
+      height: 7
+    },
+    shadowOpacity: 0.29,
+    shadowRadius: 4.65
+  },
+  7: {
+    shadowColor: '#000',
+    shadowOffset: {
+      width: 8,
+      height: 8
+    },
+    shadowOpacity: 0.3,
+    shadowRadius: 4.65
+  },
+  8: {
+    shadowColor: '#000',
+    shadowOffset: {
+      width: 9,
+      height: 9
+    },
+    shadowOpacity: 0.32,
+    shadowRadius: 5.46
+  },
+  9: {
+    shadowColor: '#000',
+    shadowOffset: {
+      width: 10,
+      height: 10
+    },
+    shadowOpacity: 0.34,
+    shadowRadius: 6.27
+  }
+};
+
+// Element.tsx
+const styleSheet = /*#__PURE__*/(() => {
+  if (typeof document !== 'undefined') {
+    let styleTag = /*#__PURE__*/document.getElementById('dynamic-styles');
+    if (!styleTag) {
+      styleTag = /*#__PURE__*/document.createElement('style');
+      styleTag.id = 'dynamic-styles';
+      document.head.appendChild(styleTag);
+    }
+    return styleTag.sheet;
+  }
+  return null;
+})();
+const classCache = /*#__PURE__*/new Map();
+const cssRulesCache = /*#__PURE__*/new Map();
+let classNameCounter = 0;
+const generateClassName = styleProps => {
+  const serialized = JSON.stringify(styleProps);
+  if (classCache.has(serialized)) {
+    return classCache.get(serialized);
+  } else {
+    const className = 'clz-' + classNameCounter++;
+    classCache.set(serialized, className);
+    return className;
+  }
+};
+const useDynamicStyles = cssRules => {
+  React.useEffect(() => {
+    if (!styleSheet) return;
+    cssRules.forEach(rule => {
+      try {
+        if (Array.from(styleSheet.cssRules).some(cssRule => cssRule.cssText === rule)) {
+          return;
+        }
+        styleSheet.insertRule(rule, styleSheet.cssRules.length);
+      } catch (error) {
+        console.error('Error inserting CSS rule:', rule, error);
+      }
+    });
+  }, [cssRules]);
+};
+const generateCssRules = (selector, styles, getColor, mediaQueries) => {
+  const rules = [];
+  const mainStyles = {};
+  const nestedMediaQueries = {};
+  Object.keys(styles).forEach(key => {
+    const value = styles[key];
+    if (key.startsWith('@media ')) {
+      const mediaQuery = key;
+      if (!nestedMediaQueries[mediaQuery]) {
+        nestedMediaQueries[mediaQuery] = {};
+      }
+      Object.assign(nestedMediaQueries[mediaQuery], value);
+    } else if (key.startsWith('&:')) {
+      const pseudoSelector = key.slice(1);
+      const nestedStyles = styles[key];
+      const nestedRules = generateCssRules(`${selector}${pseudoSelector}`, nestedStyles, getColor
+      // Ne pas passer mediaQueries ici
+      );
+
+      rules.push(...nestedRules);
+    } else {
+      mainStyles[key] = value;
+    }
+  });
+  // Gestion des media queries
+  // eslint-disable-next-line prefer-const
+  let mediaBreakpoints = {};
+  if (mediaQueries) {
+    for (const query in mediaQueries) {
+      const queries = mediaQueries[query].trim();
+      mediaBreakpoints['@media ' + queries] = query;
+    }
+  }
+  if (Object.keys(mainStyles).length > 0 || Object.keys(nestedMediaQueries).length > 0) {
+    const processedStyles = {};
+    for (const property in mainStyles) {
+      processedStyles[property] = processStyleProperty(property, mainStyles[property], getColor);
+    }
+    const cssRule = `${selector} { ${styleObjectToCss(processedStyles)} }`;
+    rules.push(cssRule);
+    for (let mediaQuery in nestedMediaQueries) {
+      mediaQuery = mediaQuery.trim();
+      const mediaStyles = nestedMediaQueries[mediaQuery];
+      const processedMediaStyles = {};
+      for (const property in mediaStyles) {
+        processedMediaStyles[property] = processStyleProperty(property, mediaStyles[property], getColor);
+      }
+      const cssProperties = styleObjectToCss(processedMediaStyles);
+      const mediaRule = `${mediaQuery} { ${selector} { ${cssProperties} } }`;
+      rules.push(mediaRule);
+      if (mediaBreakpoints[mediaQuery]) {
+        const breakpoint = mediaBreakpoints[mediaQuery];
+        const bpRule = `.${breakpoint} ${selector} { ${cssProperties} }`;
+        rules.push(bpRule);
+      }
+    }
+  }
+  return rules;
+};
+// Function to apply styles to a component
+const applyStyle = (props, getColor, mediaQueries, devices) => {
+  const styleProps = {};
+  const keyframesList = [];
+  // Gestion de la taille de l'élément
+  const size = props.height !== undefined && props.width !== undefined && props.height === props.width ? props.height : props.size ? props.size : null;
+  if (size) {
+    styleProps.height = styleProps.width = size;
+  }
+  // Gestion du padding et de la marge
+  if (props.paddingHorizontal) {
+    styleProps.paddingLeft = props.paddingHorizontal;
+    styleProps.paddingRight = props.paddingHorizontal;
+  }
+  if (props.marginHorizontal) {
+    styleProps.marginLeft = props.marginHorizontal;
+    styleProps.marginRight = props.marginHorizontal;
+  }
+  if (props.paddingVertical) {
+    styleProps.paddingTop = props.paddingVertical;
+    styleProps.paddingBottom = props.paddingVertical;
+  }
+  if (props.marginVertical) {
+    styleProps.marginTop = props.marginVertical;
+    styleProps.marginBottom = props.marginVertical;
+  }
+  // Application des ombres si spécifié
+  if (props.shadow) {
+    if (typeof props.shadow === 'number' || typeof props.shadow === 'boolean') {
+      const shadowValue = typeof props.shadow === 'number' && Shadows[props.shadow] !== undefined ? props.shadow : 2;
+      if (Shadows[shadowValue]) {
+        const shadowColor = Color.hex.rgb(Shadows[shadowValue].shadowColor) || [];
+        styleProps['boxShadow'] = `${Shadows[shadowValue].shadowOffset.height}px ${Shadows[shadowValue].shadowOffset.width}px ${Shadows[shadowValue].shadowRadius}px rgba(${shadowColor.join(',')},${Shadows[shadowValue].shadowOpacity})`;
+      }
+    } else {
+      const shadowColor = Color.hex.rgb(props.shadow.shadowColor) || [];
+      styleProps['boxShadow'] = `${props.shadow.shadowOffset.height}px ${props.shadow.shadowOffset.width}px ${props.shadow.shadowRadius}px rgba(${shadowColor.join(',')},${props.shadow.shadowOpacity})`;
+    }
+  }
+  // Gestion des animations
+  if (props.animate) {
+    const animation = props.animate;
+    const {
+      keyframesName,
+      keyframes
+    } = generateKeyframes(animation);
+    if (keyframes) {
+      keyframesList.push(keyframes);
+    }
+    styleProps.animationName = keyframesName;
+    styleProps.animationDuration = animation.duration || '1s';
+    styleProps.animationTimingFunction = animation.timingFunction || 'ease';
+    styleProps.animationDelay = animation.delay || '0s';
+    styleProps.animationIterationCount = `${animation.iterationCount || '1'}`;
+    styleProps.animationDirection = animation.direction || 'normal';
+    styleProps.animationFillMode = animation.fillMode || 'both';
+    styleProps.animationPlayState = animation.playState || 'running';
+  }
+  // Traitement des propriétés de style
+  Object.keys(props).forEach(property => {
+    if (property !== 'style' && (isStyleProp(property) || extraKeys.has(property))) {
+      const value = props[property];
+      if (typeof value === 'object' && value !== null) {
+        // Pour les propriétés comme 'on', 'media'
+        if (property === 'on') {
+          // Pseudo-sélecteurs
+          for (const event in value) {
+            if (!styleProps[`&:${event}`]) {
+              styleProps[`&:${event}`] = {};
+            }
+            const nestedResult = applyStyle(value[event], getColor, mediaQueries, devices);
+            Object.assign(styleProps[`&:${event}`], nestedResult.styleProps);
+            keyframesList.push(...(nestedResult.keyframes || []));
+          }
+        } else if (property === 'media') {
+          // Media queries
+          for (const screenOrDevices in value) {
+            const mediaValue = value[screenOrDevices];
+            if (mediaQueries[screenOrDevices]) {
+              const mediaQuery = '@media ' + mediaQueries[screenOrDevices];
+              if (!styleProps[mediaQuery]) {
+                styleProps[mediaQuery] = {};
+              }
+              const nestedResult = applyStyle(mediaValue, getColor, mediaQueries, devices);
+              Object.assign(styleProps[mediaQuery], nestedResult.styleProps);
+              keyframesList.push(...(nestedResult.keyframes || []));
+            } else if (devices[screenOrDevices]) {
+              const deviceScreens = devices[screenOrDevices];
+              deviceScreens.forEach(screen => {
+                if (mediaQueries[screen]) {
+                  const mediaQuery = '@media ' + mediaQueries[screen];
+                  if (!styleProps[mediaQuery]) {
+                    styleProps[mediaQuery] = {};
+                  }
+                  const nestedResult = applyStyle(mediaValue, getColor, mediaQueries, devices);
+                  Object.assign(styleProps[mediaQuery], nestedResult.styleProps);
+                  keyframesList.push(...(nestedResult.keyframes || []));
+                }
+              });
+            }
+          }
+        } else {
+          // Styles imbriqués
+          const nestedResult = applyStyle(value, getColor, mediaQueries, devices);
+          styleProps[property] = nestedResult.styleProps;
+          keyframesList.push(...(nestedResult.keyframes || []));
+        }
+      } else {
+        // Propriété de style simple
+        styleProps[property] = value;
+      }
+    }
+  });
+  return {
+    styleProps,
+    keyframes: keyframesList
+  };
+};
+const getStyledProps = (props, getColor, mediaQueries, devices) => {
+  const {
+    styleProps,
+    keyframes
+  } = applyStyle(props, getColor, mediaQueries, devices);
+  const className = generateClassName(styleProps);
+  let cssRules = [];
+  if (cssRulesCache.has(className)) {
+    cssRules = cssRulesCache.get(className);
+  } else {
+    cssRules = generateCssRules(`.${className}`, styleProps, getColor, mediaQueries);
+    if (keyframes && keyframes.length > 0) {
+      cssRules = keyframes.concat(cssRules);
+    }
+    cssRulesCache.set(className, cssRules);
+  }
+  const {
+    style,
+    ...restProps
+  } = props;
+  const newProps = Object.keys(restProps).reduce((acc, key) => {
+    if (!excludedKeys.has(key) && !isStyleProp(key) || includeKeys.has(key)) {
+      acc[key] = restProps[key];
+    }
+    return acc;
+  }, {});
+  if (className) {
+    newProps.className = className;
+  }
+  if (style) {
+    newProps.style = style;
+  }
+  return {
+    newProps,
+    className,
+    cssRules
+  };
+};
+const Element = props => {
+  const {
+    onPress,
+    ...rest
+  } = props;
+  const {
+    getColor
+  } = useTheme();
+  const {
+    mediaQueries,
+    devices
+  } = useResponsiveContext();
+  const {
+    newProps,
+    cssRules
+  } = React.useMemo(() => getStyledProps(rest, getColor, mediaQueries, devices), [rest, getColor, mediaQueries, devices]);
+  if (onPress) {
+    newProps.onClick = onPress;
+  }
+  useDynamicStyles(cssRules);
+  const Component = newProps.as || 'div';
+  delete newProps.as;
+  return /*#__PURE__*/React__default.createElement(Component, Object.assign({}, newProps), props.children);
+};
+
+const View = /*#__PURE__*/React__default.memo(props => /*#__PURE__*/React__default.createElement(Element, Object.assign({}, props)));
+const Div = View;
+const SafeArea = View;
+const Scroll = /*#__PURE__*/React__default.memo(props => /*#__PURE__*/React__default.createElement(View, Object.assign({
+  overflow: 'auto'
+}, props)));
+const Span = /*#__PURE__*/React__default.memo(props => /*#__PURE__*/React__default.createElement(Element, Object.assign({}, props, {
+  as: "span"
+})));
+
+const Image = /*#__PURE__*/React__default.memo(props => /*#__PURE__*/React__default.createElement(Element, Object.assign({}, props, {
+  as: "img"
+})));
+
+const Text = /*#__PURE__*/React__default.memo(props => {
+  return /*#__PURE__*/React__default.createElement(Element, Object.assign({}, props));
+});
+
+// Utilisation de React.memo pour une meilleure performance
+const Form = /*#__PURE__*/React__default.memo(props => /*#__PURE__*/React__default.createElement(Element, Object.assign({}, props, {
+  as: "form"
+})));
+const Input = /*#__PURE__*/React__default.memo(props => /*#__PURE__*/React__default.createElement(Element, Object.assign({}, props, {
+  as: "input"
+})));
+const Button = /*#__PURE__*/React__default.memo(props => /*#__PURE__*/React__default.createElement(Element, Object.assign({}, props, {
+  as: "button"
+})));
+
+// animations.ts
+const fadeIn = function (duration, timingFunction) {
+  if (duration === void 0) {
+    duration = '1s';
+  }
+  if (timingFunction === void 0) {
+    timingFunction = 'ease';
+  }
+  return {
+    from: {
+      opacity: 0
+    },
+    enter: {
+      opacity: 1
+    },
+    duration,
+    timingFunction
+  };
+};
+const fadeOut = function (duration, timingFunction) {
+  if (duration === void 0) {
+    duration = '1s';
+  }
+  if (timingFunction === void 0) {
+    timingFunction = 'ease';
+  }
+  return {
+    from: {
+      opacity: 1
+    },
+    enter: {
+      opacity: 0
+    },
+    duration,
+    timingFunction
+  };
+};
+const slideInLeft = function (duration, timingFunction) {
+  if (duration === void 0) {
+    duration = '0.5s';
+  }
+  if (timingFunction === void 0) {
+    timingFunction = 'ease-out';
+  }
+  return {
+    from: {
+      transform: 'translateX(-100%)'
+    },
+    enter: {
+      transform: 'translateX(0)'
+    },
+    duration,
+    timingFunction
+  };
+};
+const slideInRight = function (duration, timingFunction) {
+  if (duration === void 0) {
+    duration = '0.5s';
+  }
+  if (timingFunction === void 0) {
+    timingFunction = 'ease-out';
+  }
+  return {
+    from: {
+      transform: 'translateX(100%)'
+    },
+    enter: {
+      transform: 'translateX(0)'
+    },
+    duration,
+    timingFunction
+  };
+};
+const slideInDown = function (duration, timingFunction) {
+  if (duration === void 0) {
+    duration = '0.5s';
+  }
+  if (timingFunction === void 0) {
+    timingFunction = 'ease-out';
+  }
+  return {
+    from: {
+      transform: 'translateY(-100%)'
+    },
+    enter: {
+      transform: 'translateY(0)'
+    },
+    duration,
+    timingFunction
+  };
+};
+const slideInUp = function (duration, timingFunction) {
+  if (duration === void 0) {
+    duration = '0.5s';
+  }
+  if (timingFunction === void 0) {
+    timingFunction = 'ease-out';
+  }
+  return {
+    from: {
+      transform: 'translateY(100%)'
+    },
+    enter: {
+      transform: 'translateY(0)'
+    },
+    duration,
+    timingFunction
+  };
+};
+const bounce = function (duration, timingFunction, iterationCount) {
+  if (duration === void 0) {
+    duration = '2s';
+  }
+  if (timingFunction === void 0) {
+    timingFunction = 'ease';
+  }
+  if (iterationCount === void 0) {
+    iterationCount = 'infinite';
+  }
+  return {
+    from: {
+      transform: 'translateY(0)'
+    },
+    '20%': {
+      transform: 'translateY(-30px)'
+    },
+    '40%': {
+      transform: 'translateY(0)'
+    },
+    '60%': {
+      transform: 'translateY(-15px)'
+    },
+    '80%': {
+      transform: 'translateY(0)'
+    },
+    enter: {
+      transform: 'translateY(0)'
+    },
+    duration,
+    timingFunction,
+    iterationCount
+  };
+};
+const rotate = function (duration, timingFunction, iterationCount) {
+  if (duration === void 0) {
+    duration = '1s';
+  }
+  if (timingFunction === void 0) {
+    timingFunction = 'linear';
+  }
+  if (iterationCount === void 0) {
+    iterationCount = 'infinite';
+  }
+  return {
+    from: {
+      transform: 'rotate(0deg)'
+    },
+    enter: {
+      transform: 'rotate(360deg)'
+    },
+    duration,
+    timingFunction,
+    iterationCount
+  };
+};
+const pulse = function (duration, timingFunction, iterationCount) {
+  if (duration === void 0) {
+    duration = '1s';
+  }
+  if (timingFunction === void 0) {
+    timingFunction = 'ease-in-out';
+  }
+  if (iterationCount === void 0) {
+    iterationCount = 'infinite';
+  }
+  return {
+    from: {
+      transform: 'scale(1)'
+    },
+    '50%': {
+      transform: 'scale(1.05)'
+    },
+    enter: {
+      transform: 'scale(1)'
+    },
+    duration,
+    timingFunction,
+    iterationCount
+  };
+};
+const zoomIn = function (duration, timingFunction) {
+  if (duration === void 0) {
+    duration = '0.5s';
+  }
+  if (timingFunction === void 0) {
+    timingFunction = 'ease-out';
+  }
+  return {
+    from: {
+      transform: 'scale(0)'
+    },
+    enter: {
+      transform: 'scale(1)'
+    },
+    duration,
+    timingFunction
+  };
+};
+const zoomOut = function (duration, timingFunction) {
+  if (duration === void 0) {
+    duration = '0.5s';
+  }
+  if (timingFunction === void 0) {
+    timingFunction = 'ease-out';
+  }
+  return {
+    from: {
+      transform: 'scale(1)'
+    },
+    enter: {
+      transform: 'scale(0)'
+    },
+    duration,
+    timingFunction
+  };
+};
+const flash = function (duration, iterationCount) {
+  if (duration === void 0) {
+    duration = '1s';
+  }
+  if (iterationCount === void 0) {
+    iterationCount = 'infinite';
+  }
+  return {
+    from: {
+      opacity: 1
+    },
+    '50%': {
+      opacity: 0
+    },
+    enter: {
+      opacity: 1
+    },
+    duration,
+    iterationCount
+  };
+};
+const shake = function (duration, iterationCount) {
+  if (duration === void 0) {
+    duration = '0.5s';
+  }
+  if (iterationCount === void 0) {
+    iterationCount = 'infinite';
+  }
+  return {
+    from: {
+      transform: 'translateX(0)'
+    },
+    '10%': {
+      transform: 'translateX(-10px)'
+    },
+    '20%': {
+      transform: 'translateX(10px)'
+    },
+    '30%': {
+      transform: 'translateX(-10px)'
+    },
+    '40%': {
+      transform: 'translateX(10px)'
+    },
+    '50%': {
+      transform: 'translateX(-10px)'
+    },
+    '60%': {
+      transform: 'translateX(10px)'
+    },
+    '70%': {
+      transform: 'translateX(-10px)'
+    },
+    '80%': {
+      transform: 'translateX(10px)'
+    },
+    '90%': {
+      transform: 'translateX(-10px)'
+    },
+    enter: {
+      transform: 'translateX(0)'
+    },
+    duration,
+    iterationCount
+  };
+};
+const swing = function (duration, iterationCount) {
+  if (duration === void 0) {
+    duration = '1s';
+  }
+  if (iterationCount === void 0) {
+    iterationCount = 'infinite';
+  }
+  return {
+    from: {
+      transform: 'rotate(0deg)'
+    },
+    '20%': {
+      transform: 'rotate(15deg)'
+    },
+    '40%': {
+      transform: 'rotate(-10deg)'
+    },
+    '60%': {
+      transform: 'rotate(5deg)'
+    },
+    '80%': {
+      transform: 'rotate(-5deg)'
+    },
+    enter: {
+      transform: 'rotate(0deg)'
+    },
+    duration,
+    iterationCount
+  };
+};
+const rubberBand = function (duration, timingFunction) {
+  if (duration === void 0) {
+    duration = '1s';
+  }
+  if (timingFunction === void 0) {
+    timingFunction = 'ease-in-out';
+  }
+  return {
+    from: {
+      transform: 'scale3d(1, 1, 1)'
+    },
+    '30%': {
+      transform: 'scale3d(1.25, 0.75, 1)'
+    },
+    '40%': {
+      transform: 'scale3d(0.75, 1.25, 1)'
+    },
+    '50%': {
+      transform: 'scale3d(1.15, 0.85, 1)'
+    },
+    '65%': {
+      transform: 'scale3d(0.95, 1.05, 1)'
+    },
+    '75%': {
+      transform: 'scale3d(1.05, 0.95, 1)'
+    },
+    enter: {
+      transform: 'scale3d(1, 1, 1)'
+    },
+    duration,
+    timingFunction
+  };
+};
+const wobble = function (duration) {
+  if (duration === void 0) {
+    duration = '1s';
+  }
+  return {
+    from: {
+      transform: 'translateX(0%)'
+    },
+    '15%': {
+      transform: 'translateX(-25%) rotate(-5deg)'
+    },
+    '30%': {
+      transform: 'translateX(20%) rotate(3deg)'
+    },
+    '45%': {
+      transform: 'translateX(-15%) rotate(-3deg)'
+    },
+    '60%': {
+      transform: 'translateX(10%) rotate(2deg)'
+    },
+    '75%': {
+      transform: 'translateX(-5%) rotate(-1deg)'
+    },
+    enter: {
+      transform: 'translateX(0%)'
+    },
+    duration
+  };
+};
+const flip = function (duration) {
+  if (duration === void 0) {
+    duration = '1s';
+  }
+  return {
+    from: {
+      transform: 'perspective(400px) rotateY(0deg)'
+    },
+    '40%': {
+      transform: 'perspective(400px) rotateY(-180deg)'
+    },
+    enter: {
+      transform: 'perspective(400px) rotateY(-360deg)'
+    },
+    duration
+  };
+};
+const heartBeat = function (duration, iterationCount) {
+  if (duration === void 0) {
+    duration = '1.3s';
+  }
+  if (iterationCount === void 0) {
+    iterationCount = 'infinite';
+  }
+  return {
+    from: {
+      transform: 'scale(1)'
+    },
+    '14%': {
+      transform: 'scale(1.3)'
+    },
+    '28%': {
+      transform: 'scale(1)'
+    },
+    '42%': {
+      transform: 'scale(1.3)'
+    },
+    '70%': {
+      transform: 'scale(1)'
+    },
+    enter: {
+      transform: 'scale(1)'
+    },
+    duration,
+    iterationCount
+  };
+};
+const rollIn = function (duration) {
+  if (duration === void 0) {
+    duration = '1s';
+  }
+  return {
+    from: {
+      opacity: 0,
+      transform: 'translateX(-100%) rotate(-120deg)'
+    },
+    enter: {
+      opacity: 1,
+      transform: 'translateX(0px) rotate(0deg)'
+    },
+    duration
+  };
+};
+const rollOut = function (duration) {
+  if (duration === void 0) {
+    duration = '1s';
+  }
+  return {
+    from: {
+      opacity: 1,
+      transform: 'translateX(0px) rotate(0deg)'
+    },
+    enter: {
+      opacity: 0,
+      transform: 'translateX(100%) rotate(120deg)'
+    },
+    duration
+  };
+};
+const lightSpeedIn = function (duration, timingFunction) {
+  if (duration === void 0) {
+    duration = '1s';
+  }
+  if (timingFunction === void 0) {
+    timingFunction = 'ease-out';
+  }
+  return {
+    from: {
+      transform: 'translateX(100%) skewX(-30deg)',
+      opacity: 0
+    },
+    '60%': {
+      transform: 'skewX(20deg)',
+      opacity: 1
+    },
+    '80%': {
+      transform: 'skewX(-5deg)'
+    },
+    enter: {
+      transform: 'translateX(0)',
+      opacity: 1
+    },
+    duration,
+    timingFunction
+  };
+};
+const lightSpeedOut = function (duration, timingFunction) {
+  if (duration === void 0) {
+    duration = '1s';
+  }
+  if (timingFunction === void 0) {
+    timingFunction = 'ease-in';
+  }
+  return {
+    from: {
+      opacity: 1
+    },
+    '20%': {
+      opacity: 1,
+      transform: 'translateX(-20%) skewX(20deg)'
+    },
+    enter: {
+      opacity: 0,
+      transform: 'translateX(-100%) skewX(30deg)'
+    },
+    duration,
+    timingFunction
+  };
+};
+const hinge = function (duration, timingFunction) {
+  if (duration === void 0) {
+    duration = '2s';
+  }
+  if (timingFunction === void 0) {
+    timingFunction = 'ease-in-out';
+  }
+  return {
+    from: {
+      transform: 'rotate(0deg)',
+      transformOrigin: 'top left',
+      opacity: 1
+    },
+    '20%': {
+      transform: 'rotate(80deg)',
+      opacity: 1
+    },
+    '40%': {
+      transform: 'rotate(60deg)',
+      opacity: 1
+    },
+    '60%': {
+      transform: 'rotate(80deg)',
+      opacity: 1
+    },
+    '80%': {
+      transform: 'rotate(60deg)',
+      opacity: 1
+    },
+    enter: {
+      transform: 'translateY(700px)',
+      opacity: 0
+    },
+    duration,
+    timingFunction
+  };
+};
+const jackInTheBox = function (duration, timingFunction) {
+  if (duration === void 0) {
+    duration = '1s';
+  }
+  if (timingFunction === void 0) {
+    timingFunction = 'ease';
+  }
+  return {
+    from: {
+      opacity: 0,
+      transform: 'scale(0.1) rotate(30deg)',
+      transformOrigin: 'center bottom'
+    },
+    '50%': {
+      transform: 'rotate(-10deg)'
+    },
+    '70%': {
+      transform: 'rotate(3deg)'
+    },
+    enter: {
+      opacity: 1,
+      transform: 'scale(1) rotate(0deg)'
+    },
+    duration,
+    timingFunction
+  };
+};
+const flipInX = function (duration, timingFunction) {
+  if (duration === void 0) {
+    duration = '1s';
+  }
+  if (timingFunction === void 0) {
+    timingFunction = 'ease-in';
+  }
+  return {
+    from: {
+      transform: 'perspective(400px) rotateX(90deg)',
+      opacity: 0
+    },
+    '40%': {
+      transform: 'perspective(400px) rotateX(-10deg)',
+      opacity: 1
+    },
+    enter: {
+      transform: 'perspective(400px) rotateX(0deg)'
+    },
+    duration,
+    timingFunction
+  };
+};
+const flipInY = function (duration, timingFunction) {
+  if (duration === void 0) {
+    duration = '1s';
+  }
+  if (timingFunction === void 0) {
+    timingFunction = 'ease-in';
+  }
+  return {
+    from: {
+      transform: 'perspective(400px) rotateY(90deg)',
+      opacity: 0
+    },
+    '40%': {
+      transform: 'perspective(400px) rotateY(-10deg)',
+      opacity: 1
+    },
+    enter: {
+      transform: 'perspective(400px) rotateY(0deg)'
+    },
+    duration,
+    timingFunction
+  };
+};
+const headShake = function (duration, iterationCount) {
+  if (duration === void 0) {
+    duration = '1s';
+  }
+  if (iterationCount === void 0) {
+    iterationCount = 'infinite';
+  }
+  return {
+    from: {
+      transform: 'translateX(0)'
+    },
+    '6.5%': {
+      transform: 'translateX(-6px) rotateY(-9deg)'
+    },
+    '18.5%': {
+      transform: 'translateX(5px) rotateY(7deg)'
+    },
+    '31.5%': {
+      transform: 'translateX(-3px) rotateY(-5deg)'
+    },
+    '43.5%': {
+      transform: 'translateX(2px) rotateY(3deg)'
+    },
+    '50%': {
+      transform: 'translateX(0)'
+    },
+    duration,
+    iterationCount
+  };
+};
+const tada = function (duration, iterationCount) {
+  if (duration === void 0) {
+    duration = '1s';
+  }
+  if (iterationCount === void 0) {
+    iterationCount = 'infinite';
+  }
+  return {
+    from: {
+      transform: 'scale3d(1, 1, 1)',
+      opacity: 1
+    },
+    '10%, 20%': {
+      transform: 'scale3d(0.9, 0.9, 0.9) rotate(-3deg)'
+    },
+    '30%, 50%, 70%, 90%': {
+      transform: 'scale3d(1.1, 1.1, 1.1) rotate(3deg)'
+    },
+    '40%, 60%, 80%': {
+      transform: 'scale3d(1.1, 1.1, 1.1) rotate(-3deg)'
+    },
+    enter: {
+      transform: 'scale3d(1, 1, 1)',
+      opacity: 1
+    },
+    duration,
+    iterationCount
+  };
+};
+const jello = function (duration, iterationCount) {
+  if (duration === void 0) {
+    duration = '1s';
+  }
+  if (iterationCount === void 0) {
+    iterationCount = 'infinite';
+  }
+  return {
+    from: {
+      transform: 'none'
+    },
+    '11.1%': {
+      transform: 'skewX(-12.5deg) skewY(-12.5deg)'
+    },
+    '22.2%': {
+      transform: 'skewX(6.25deg) skewY(6.25deg)'
+    },
+    '33.3%': {
+      transform: 'skewX(-3.125deg) skewY(-3.125deg)'
+    },
+    '44.4%': {
+      transform: 'skewX(1.5625deg) skewY(1.5625deg)'
+    },
+    '55.5%': {
+      transform: 'skewX(-0.78125deg) skewY(-0.78125deg)'
+    },
+    '66.6%': {
+      transform: 'skewX(0.390625deg) skewY(0.390625deg)'
+    },
+    '77.7%': {
+      transform: 'skewX(-0.1953125deg) skewY(-0.1953125deg)'
+    },
+    '88.8%': {
+      transform: 'skewX(0.09765625deg) skewY(0.09765625deg)'
+    },
+    enter: {
+      transform: 'none'
+    },
+    duration,
+    iterationCount
+  };
+};
+const fadeInDown = function (duration, timingFunction) {
+  if (duration === void 0) {
+    duration = '1s';
+  }
+  if (timingFunction === void 0) {
+    timingFunction = 'ease-out';
+  }
+  return {
+    from: {
+      opacity: 0,
+      transform: 'translateY(-100%)'
+    },
+    enter: {
+      opacity: 1,
+      transform: 'translateY(0)'
+    },
+    duration,
+    timingFunction
+  };
+};
+const fadeInUp = function (duration, timingFunction) {
+  if (duration === void 0) {
+    duration = '1s';
+  }
+  if (timingFunction === void 0) {
+    timingFunction = 'ease-out';
+  }
+  return {
+    from: {
+      opacity: 0,
+      transform: 'translateY(100%)'
+    },
+    enter: {
+      opacity: 1,
+      transform: 'translateY(0)'
+    },
+    duration,
+    timingFunction
+  };
+};
+const bounceIn = function (duration, timingFunction) {
+  if (duration === void 0) {
+    duration = '0.75s';
+  }
+  if (timingFunction === void 0) {
+    timingFunction = 'ease-in';
+  }
+  return {
+    from: {
+      opacity: 0,
+      transform: 'scale(0.3)'
+    },
+    '50%': {
+      opacity: 1,
+      transform: 'scale(1.05)'
+    },
+    '70%': {
+      transform: 'scale(0.9)'
+    },
+    enter: {
+      transform: 'scale(1)'
+    },
+    duration,
+    timingFunction
+  };
+};
+const bounceOut = function (duration, timingFunction) {
+  if (duration === void 0) {
+    duration = '0.75s';
+  }
+  if (timingFunction === void 0) {
+    timingFunction = 'ease-out';
+  }
+  return {
+    from: {
+      transform: 'scale(1)'
+    },
+    '20%': {
+      transform: 'scale(0.9)'
+    },
+    '50%, 55%': {
+      opacity: 1,
+      transform: 'scale(1.1)'
+    },
+    enter: {
+      opacity: 0,
+      transform: 'scale(0.3)'
+    },
+    duration,
+    timingFunction
+  };
+};
+const slideOutLeft = function (duration, timingFunction) {
+  if (duration === void 0) {
+    duration = '0.5s';
+  }
+  if (timingFunction === void 0) {
+    timingFunction = 'ease-in';
+  }
+  return {
+    from: {
+      transform: 'translateX(0)'
+    },
+    enter: {
+      transform: 'translateX(-100%)'
+    },
+    duration,
+    timingFunction
+  };
+};
+const slideOutRight = function (duration, timingFunction) {
+  if (duration === void 0) {
+    duration = '0.5s';
+  }
+  if (timingFunction === void 0) {
+    timingFunction = 'ease-in';
+  }
+  return {
+    from: {
+      transform: 'translateX(0)'
+    },
+    enter: {
+      transform: 'translateX(100%)'
+    },
+    duration,
+    timingFunction
+  };
+};
+const zoomInDown = function (duration, timingFunction) {
+  if (duration === void 0) {
+    duration = '1s';
+  }
+  if (timingFunction === void 0) {
+    timingFunction = 'ease-out';
+  }
+  return {
+    from: {
+      opacity: 0,
+      transform: 'scale(0.1) translateY(-1000px)'
+    },
+    '60%': {
+      opacity: 1,
+      transform: 'scale(0.475) translateY(60px)'
+    },
+    enter: {
+      transform: 'scale(1) translateY(0)'
+    },
+    duration,
+    timingFunction
+  };
+};
+const zoomOutUp = function (duration, timingFunction) {
+  if (duration === void 0) {
+    duration = '1s';
+  }
+  if (timingFunction === void 0) {
+    timingFunction = 'ease-in';
+  }
+  return {
+    from: {
+      opacity: 1,
+      transform: 'scale(1) translateY(0)'
+    },
+    '40%': {
+      opacity: 1,
+      transform: 'scale(0.475) translateY(-60px)'
+    },
+    enter: {
+      opacity: 0,
+      transform: 'scale(0.1) translateY(-1000px)'
+    },
+    duration,
+    timingFunction
+  };
+};
+const backInDown = function (duration, timingFunction) {
+  if (duration === void 0) {
+    duration = '1s';
+  }
+  if (timingFunction === void 0) {
+    timingFunction = 'ease-in';
+  }
+  return {
+    from: {
+      opacity: 0.7,
+      transform: 'translateY(-2000px) scaleY(2.5) scaleX(0.2)'
+    },
+    enter: {
+      opacity: 1,
+      transform: 'translateY(0) scaleY(1) scaleX(1)'
+    },
+    duration,
+    timingFunction
+  };
+};
+const backOutUp = function (duration, timingFunction) {
+  if (duration === void 0) {
+    duration = '1s';
+  }
+  if (timingFunction === void 0) {
+    timingFunction = 'ease-in';
+  }
+  return {
+    from: {
+      opacity: 1,
+      transform: 'translateY(0)'
+    },
+    '80%': {
+      opacity: 0.7,
+      transform: 'translateY(-20px)'
+    },
+    enter: {
+      opacity: 0,
+      transform: 'translateY(-2000px)'
+    },
+    duration,
+    timingFunction
+  };
+};
+
+var Animation = {
+  __proto__: null,
+  fadeIn: fadeIn,
+  fadeOut: fadeOut,
+  slideInLeft: slideInLeft,
+  slideInRight: slideInRight,
+  slideInDown: slideInDown,
+  slideInUp: slideInUp,
+  bounce: bounce,
+  rotate: rotate,
+  pulse: pulse,
+  zoomIn: zoomIn,
+  zoomOut: zoomOut,
+  flash: flash,
+  shake: shake,
+  swing: swing,
+  rubberBand: rubberBand,
+  wobble: wobble,
+  flip: flip,
+  heartBeat: heartBeat,
+  rollIn: rollIn,
+  rollOut: rollOut,
+  lightSpeedIn: lightSpeedIn,
+  lightSpeedOut: lightSpeedOut,
+  hinge: hinge,
+  jackInTheBox: jackInTheBox,
+  flipInX: flipInX,
+  flipInY: flipInY,
+  headShake: headShake,
+  tada: tada,
+  jello: jello,
+  fadeInDown: fadeInDown,
+  fadeInUp: fadeInUp,
+  bounceIn: bounceIn,
+  bounceOut: bounceOut,
+  slideOutLeft: slideOutLeft,
+  slideOutRight: slideOutRight,
+  zoomInDown: zoomInDown,
+  zoomOutUp: zoomOutUp,
+  backInDown: backInDown,
+  backOutUp: backOutUp
+};
+
+const Typography = {
+  letterSpacings: {
+    tighter: -0.08,
+    tight: -0.4,
+    normal: 0,
+    wide: 0.4,
+    wider: 0.8,
+    widest: 1.6
+  },
+  lineHeights: {
+    xs: 10,
+    sm: 12,
+    md: 14,
+    lg: 16,
+    xl: 20,
+    '2xl': 24,
+    '3xl': 30,
+    '4xl': 36,
+    '5xl': 48,
+    '6xl': 64
+  },
+  fontWeights: {
+    hairline: 100,
+    thin: 200,
+    light: 300,
+    normal: 400,
+    medium: 500,
+    semiBold: 600,
+    bold: 700,
+    extraBold: 800,
+    black: 900
+  },
+  fontSizes: {
+    xs: 10,
+    sm: 12,
+    md: 14,
+    lg: 16,
+    xl: 20,
+    '2xl': 24,
+    '3xl': 30,
+    '4xl': 36,
+    '5xl': 48,
+    '6xl': 64
+  }
+};
+
+/**
+ * whether in browser env
+ */
+const isBrowser = () => typeof window !== 'undefined' && typeof window.document !== 'undefined' && typeof window.document.createElement !== 'undefined';
+/**
+ * get window.g_initialProps
+ */
+const getWindowInitialProps = () => isBrowser() ? window.g_initialProps : undefined;
+/**
+ * whether SSR success in client
+ */
+const isSSR = ! /*#__PURE__*/isBrowser();
+function isDev() {
+  let dev = false;
+  if (isBrowser()) {
+    dev = !(window.location.hostname.indexOf('localhost') === -1);
+  }
+  return dev;
+}
+function isProd() {
+  if (isBrowser()) {
+    if (window && window.location && window.location.hostname) {
+      return window.location.hostname.includes('localhost') || window.location.hostname.includes('develop');
+    }
+  }
+  return false;
+}
+function isMobile() {
+  return navigator.userAgent.match(/(iPhone|iPod|Android|ios|iPad)/i);
+}
+
+const useMount = callback => {
+  React.useEffect(() => {
+    callback();
+  }, []);
+};
+
+const createQuery = (keyScreen, query, set) => {
+  const mql = window.matchMedia(query);
+  const onChange = () => {
+    if (!!mql.matches) {
+      set(keyScreen);
+    }
+  };
+  mql.addListener(onChange);
+  if (!!mql.matches) {
+    set(keyScreen);
+  }
+  return () => {
+    mql.removeListener(onChange);
+  };
+};
+const useResponsive = () => {
+  const {
+    breakpoints,
+    devices,
+    mediaQueries
+  } = useResponsiveContext();
+  const [screen, setScreen] = React.useState('xs');
+  const [orientation, setOrientation] = React.useState('landscape');
+  useMount(() => {
+    for (const screenSize in mediaQueries) {
+      createQuery(screenSize, mediaQueries[screenSize], setScreen);
+    }
+    createQuery('landscape', 'only screen and (orientation: landscape)', setOrientation);
+    createQuery('portrait', 'only screen and (orientation: portrait)', setOrientation);
+  });
+  const on = device => {
+    return devices[device].includes(screen);
+  };
+  const is = s => {
+    return s == screen;
+  };
+  return {
+    breakpoints,
+    devices,
+    orientation,
+    screen,
+    on,
+    is
+  };
+};
+
+exports.Animation = Animation;
+exports.Button = Button;
+exports.Div = Div;
+exports.Element = Element;
+exports.Form = Form;
+exports.Image = Image;
+exports.Input = Input;
+exports.ResponsiveContext = ResponsiveContext;
+exports.ResponsiveProvider = ResponsiveProvider;
+exports.SafeArea = SafeArea;
+exports.Scroll = Scroll;
+exports.Shadows = Shadows;
+exports.Span = Span;
+exports.Text = Text;
+exports.ThemeContext = ThemeContext;
+exports.ThemeProvider = ThemeProvider;
+exports.Typography = Typography;
+exports.View = View;
+exports.createQuery = createQuery;
+exports.defaultColors = defaultColors;
+exports.defaultThemeMain = defaultThemeMain;
+exports.getWindowInitialProps = getWindowInitialProps;
+exports.isBrowser = isBrowser;
+exports.isDev = isDev;
+exports.isMobile = isMobile;
+exports.isProd = isProd;
+exports.isSSR = isSSR;
+exports.palette = palette;
+exports.useMount = useMount;
+exports.useResponsive = useResponsive;
+exports.useResponsiveContext = useResponsiveContext;
+exports.useTheme = useTheme;
+//# sourceMappingURL=appstudio.cjs.development.js.map