app-studio 0.7.2 → 0.7.5

package/dist/app-studio.cjs.development.js

@@ -757,15 +757,15 @@ const defaultDarkColors = {
   black: '#FFFFFF'
 };
 // Centralized regex for color token detection
-// Matches color.x.y.z or theme.x.y
-const COLOR_TOKEN_REGEX = /(color\.[a-zA-Z0-9.]+|theme\.[a-zA-Z0-9.]+)/g;
+// Matches color-x-y-z or theme-x-y (dash notation)
+const COLOR_TOKEN_REGEX = /(color-[a-zA-Z0-9-]+|theme-[a-zA-Z0-9-]+)/g;
 /**
  * Checks if a value contains color tokens.
  * @param value - The string to check.
  * @returns True if the value contains color tokens.
  */
 const hasColorToken = value => {
-  return value.includes('color.') || value.includes('theme.');
+  return value.includes('color-') || value.includes('theme-');
 };
 /**
  * Replaces color tokens in a string with values returned by a resolver function.
@@ -783,8 +783,11 @@ const replaceColorTokens = (value, resolver) => {
 };
 
 // --- Constants ---
-const THEME_PREFIX = 'theme.';
-const COLOR_PREFIX = 'color.';
+// Public API prefixes (dash notation: theme-primary, color-blue-500)
+const THEME_PREFIX = 'theme-';
+const COLOR_PREFIX = 'color-';
+const LIGHT_PREFIX = 'light-';
+const DARK_PREFIX = 'dark-';
 const TRANSPARENT = 'transparent';
 // --- CSS Variable Injection Helper ---
 const generateCSSVariables = (theme, lightColors, darkColors) => {
@@ -828,21 +831,17 @@ const generateCSSVariables = (theme, lightColors, darkColors) => {
   collectGenericNames(lightColors.main, 'color');
   collectGenericNames(lightColors.palette, 'color');
   // 3. Process Theme variables (references)
+  // Theme config uses dash notation (color-blue-500, theme-primary)
   const processTheme = (obj, prefix) => {
     Object.keys(obj).forEach(key => {
       const value = obj[key];
-      const variableName = `${prefix}-${key}`.replace(/\./g, '-');
+      const variableName = `${prefix}-${key}`;
       if (typeof value === 'object' && value !== null) {
         processTheme(value, variableName);
       } else if (typeof value === 'string') {
-        if (value.startsWith(COLOR_PREFIX)) {
-          // Convert 'color.blue.500' -> 'var(--color-blue-500)'
-          // The underlying --color-blue-500 will change based on scope!
-          const refVar = value.replace(/\./g, '-');
-          themeVariables.push(`--${variableName}: var(--${refVar});`);
-        } else if (value.startsWith(THEME_PREFIX)) {
-          const refVar = value.replace(/\./g, '-');
-          themeVariables.push(`--${variableName}: var(--${refVar});`);
+        if (value.startsWith('color-') || value.startsWith('theme-')) {
+          // Convert 'color-blue-500' -> 'var(--color-blue-500)'
+          themeVariables.push(`--${variableName}: var(--${value});`);
         } else {
           themeVariables.push(`--${variableName}: ${value};`);
         }
@@ -878,14 +877,16 @@ const generateCSSVariables = (theme, lightColors, darkColors) => {
   return css;
 };
 // --- Default Configuration ---
+// Theme values use dash notation (color-X or color-X-shade)
+// which gets resolved to CSS variables (var(--color-X-shade))
 const defaultThemeMain = {
-  primary: `${COLOR_PREFIX}black`,
-  secondary: `${COLOR_PREFIX}blue`,
-  success: `${COLOR_PREFIX}green.500`,
-  error: `${COLOR_PREFIX}red.500`,
-  warning: `${COLOR_PREFIX}orange.500`,
-  disabled: `${COLOR_PREFIX}gray.500`,
-  loading: `${COLOR_PREFIX}dark.500`
+  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 defaultLightColorConfig = {
   main: defaultLightColors,
@@ -943,9 +944,9 @@ const convertToRgba = (color, alpha) => {
   // Handle rgb/rgba colors
   if (color.startsWith('rgb')) {
     // Extract the values from rgb() or rgba()
-    const match = color.match(/rgba?\(([^)]+)\)/);
-    if (match) {
-      const values = match[1].split(',').map(v => v.trim());
+    const rgbMatch = color.match(/rgba?\(([^)]+)\)/);
+    if (rgbMatch) {
+      const values = rgbMatch[1].split(',').map(v => v.trim());
       const r = values[0];
       const g = values[1];
       const b = values[2];
@@ -1100,83 +1101,111 @@ const ThemeProvider = _ref => {
     if (token === TRANSPARENT) return token;
     if (depth > 25) return token;
     const effectiveTheme = override?.theme ? deepMerge(mergedTheme, override.theme) : mergedTheme;
-    // Resolve theme.* tokens recursively
+    // Convert dash notation to internal format for resolution
+    // theme-primary-100 -> parts for processing
     if (token.startsWith(THEME_PREFIX)) {
-      const themeKey = token.substring(THEME_PREFIX.length);
+      const parts = token.substring(THEME_PREFIX.length).split('-');
+      const lastPart = parts[parts.length - 1];
+      const maybeAlpha = parseInt(lastPart, 10);
+      // Check for alpha suffix: theme-primary-100 (2+ parts after prefix, last is 0-1000)
+      if (parts.length >= 2 && !isNaN(maybeAlpha) && maybeAlpha >= 0 && maybeAlpha <= 1000) {
+        const themeKey = parts.slice(0, -1).join('-');
+        const baseToken = `${THEME_PREFIX}${themeKey}`;
+        const resolvedBase = resolveColorTokenForMode(baseToken, mode, override, depth + 1);
+        return convertToRgba(resolvedBase, maybeAlpha);
+      }
+      const themeKey = parts.join('-');
       const themeValue = effectiveTheme[themeKey];
       if (typeof themeValue === 'string') {
+        // Theme values use dash notation (color-blue-500)
         return resolveColorTokenForMode(themeValue, mode, override, depth + 1);
       }
       return token;
     }
-    // Resolve explicit mode paths like "light.blue.500" / "dark.blue.500"
-    if (token.startsWith('light.') || token.startsWith('dark.')) {
-      const explicitMode = token.startsWith('light.') ? 'light' : 'dark';
-      const prefixLength = token.startsWith('light.') ? 6 : 5;
-      const modifiedName = `${COLOR_PREFIX}${token.substring(prefixLength)}`;
-      return resolveColorTokenForMode(modifiedName, explicitMode, override, depth + 1);
-    }
-    // Resolve color.* tokens
+    // Handle dash notation: color-blue-500, light-blue-500, dark-blue-500
     if (token.startsWith(COLOR_PREFIX)) {
-      const keys = token.substring(COLOR_PREFIX.length).split('.');
+      const parts = token.substring(COLOR_PREFIX.length).split('-');
       const colorsToUse = themeColors[mode];
       const palette = deepMerge(colorsToUse.palette, override?.colors?.palette || {});
       const main = deepMerge(colorsToUse.main, override?.colors?.main || {});
-      if (keys.length === 3) {
-        // e.g. color.blue.500.200 (alpha)
-        const [colorName, variant, alphaStr] = keys;
-        const base = palette?.[colorName]?.[variant];
-        const alpha = parseInt(alphaStr, 10);
-        if (typeof base === 'string' && !isNaN(alpha)) {
-          return convertToRgba(base, alpha);
+      // color-blue-500-200 (alpha)
+      if (parts.length >= 3) {
+        const lastPart = parts[parts.length - 1];
+        const maybeAlpha = parseInt(lastPart, 10);
+        if (!isNaN(maybeAlpha) && maybeAlpha >= 0 && maybeAlpha <= 1000) {
+          const colorName = parts[0];
+          const variant = parts[1];
+          const base = palette?.[colorName]?.[variant];
+          if (typeof base === 'string') {
+            return convertToRgba(base, maybeAlpha);
+          }
         }
-        return token;
       }
-      if (keys.length === 2) {
-        const [colorName, variant] = keys;
+      // color-blue-500
+      if (parts.length === 2) {
+        const [colorName, variant] = parts;
         const value = palette?.[colorName]?.[variant];
         return typeof value === 'string' ? value : token;
       }
-      if (keys.length === 1) {
-        const [colorName] = keys;
-        const value = main?.[colorName];
+      // color-blue
+      if (parts.length === 1) {
+        const value = main?.[parts[0]];
         return typeof value === 'string' ? value : token;
       }
       return token;
     }
+    // Handle light-* and dark-* tokens
+    if (token.startsWith(LIGHT_PREFIX) || token.startsWith(DARK_PREFIX)) {
+      const explicitMode = token.startsWith(LIGHT_PREFIX) ? 'light' : 'dark';
+      const prefix = token.startsWith(LIGHT_PREFIX) ? LIGHT_PREFIX : DARK_PREFIX;
+      const colorPart = token.substring(prefix.length);
+      return resolveColorTokenForMode(`${COLOR_PREFIX}${colorPart}`, explicitMode, override, depth + 1);
+    }
     return token;
   }, [mergedTheme, themeColors]);
   // --- Helper function to resolve color tokens to actual values ---
+  // This is used internally and handles dash notation (public API)
   const resolveColorToken = React.useCallback(token => {
     if (!token || typeof token !== 'string') return String(token);
     if (token === TRANSPARENT) return token;
     const colors = currentColors;
-    // Resolve color.* tokens
+    // Handle dash notation: color-blue-500
     if (token.startsWith(COLOR_PREFIX)) {
-      const keys = token.substring(COLOR_PREFIX.length).split('.');
-      if (keys.length === 1) {
-        // e.g., "color.blue" -> main color
-        const colorValue = colors.main[keys[0]];
-        return typeof colorValue === 'string' ? colorValue : token;
-      } else if (keys.length === 2) {
-        // e.g., "color.blue.500" -> palette color
-        const [colorName, shade] = keys;
+      const parts = token.substring(COLOR_PREFIX.length).split('-');
+      // color-blue-500-200 (alpha)
+      if (parts.length >= 3) {
+        const lastPart = parts[parts.length - 1];
+        const maybeAlpha = parseInt(lastPart, 10);
+        if (!isNaN(maybeAlpha) && maybeAlpha >= 0 && maybeAlpha <= 1000) {
+          const percentage = Math.round(maybeAlpha / 1000 * 100);
+          const baseVar = `color-${parts.slice(0, -1).join('-')}`;
+          return `color-mix(in srgb, var(--${baseVar}) ${percentage}%, transparent)`;
+        }
+      }
+      // color-blue-500
+      if (parts.length === 2) {
+        const [colorName, shade] = parts;
         const shadeValue = colors.palette[colorName]?.[Number(shade)];
         return typeof shadeValue === 'string' ? shadeValue : token;
-      } else if (keys.length === 3) {
-        // e.g., "color.blue.500.200" -> palette color with alpha
-        // Use color-mix() to apply alpha via CSS variables
-        const [colorName, shade, alphaStr] = keys;
-        const alpha = parseInt(alphaStr, 10);
-        if (!isNaN(alpha)) {
-          const percentage = Math.round(alpha / 1000 * 100);
-          return `color-mix(in srgb, var(--color-${colorName}-${shade}) ${percentage}%, transparent)`;
-        }
+      }
+      // color-blue
+      if (parts.length === 1) {
+        const colorValue = colors.main[parts[0]];
+        return typeof colorValue === 'string' ? colorValue : token;
       }
     }
-    // Resolve theme.* tokens (recursive resolution)
+    // Handle dash notation: theme-primary, theme-primary-100
     if (token.startsWith(THEME_PREFIX)) {
-      const themeKey = token.substring(THEME_PREFIX.length);
+      const parts = token.substring(THEME_PREFIX.length).split('-');
+      const lastPart = parts[parts.length - 1];
+      const maybeAlpha = parseInt(lastPart, 10);
+      // theme-primary-100 (alpha)
+      if (parts.length >= 2 && !isNaN(maybeAlpha) && maybeAlpha >= 0 && maybeAlpha <= 1000) {
+        const percentage = Math.round(maybeAlpha / 1000 * 100);
+        const baseVar = `theme-${parts.slice(0, -1).join('-')}`;
+        return `color-mix(in srgb, var(--${baseVar}) ${percentage}%, transparent)`;
+      }
+      const themeKey = parts.join('-');
       const themeValue = mergedTheme[themeKey];
       if (typeof themeValue === 'string') {
         return resolveColorToken(themeValue);
@@ -1185,86 +1214,46 @@ const ThemeProvider = _ref => {
     return token;
   }, [currentColors, mergedTheme]);
   // The mode is now handled by the data-attribute on the container
-  // --- Memoized getColor function - Revised for Robustness ---
-  const getColor = React.useCallback((name, override) => {
-    if (!name || typeof name !== 'string') return String(name); // Handle invalid input
+  // --- Memoized getColor function - Dash notation only ---
+  const getColor = React.useCallback(name => {
+    if (!name || typeof name !== 'string') return String(name);
     if (name === TRANSPARENT) return name;
-    // 1. Check for optimization (CSS vars) if no overrides
-    // This allows instant theme switching via CSS variables without re-render
-    if (!override || Object.keys(override).length === 0) {
-      if (name.startsWith(THEME_PREFIX)) {
-        return `var(--${name.replace(/\./g, '-')})`;
-      }
-      if (name.startsWith(COLOR_PREFIX)) {
-        const parts = name.split('.');
-        // Simple lookup (e.g. color.blue or color.blue.500)
-        if (parts.length < 4) {
-          return `var(--${name.replace(/\./g, '-')})`;
-        }
-      }
+    // Strict Mode Check - only dash notation is supported
+    if (strict && !name.startsWith(COLOR_PREFIX) && !name.startsWith(THEME_PREFIX) && !name.startsWith(LIGHT_PREFIX) && !name.startsWith(DARK_PREFIX)) {
+      console.warn(`[Theme] Invalid color token: '${name}'. Use dash notation: theme-primary, color-blue-500`);
     }
-    // 2. Manual Resolution (Fallback for overrides or complex keys)
-    const effectiveMode = override?.themeMode ?? themeMode;
-    const needCache = override && Object.keys(override).length === 0;
-    const cacheKey = `${name}-${effectiveMode}`;
-    if (needCache && colorCache.has(cacheKey)) {
-      return colorCache.get(cacheKey);
-    }
-    // Strict Mode Check
-    if (strict && !name.startsWith(COLOR_PREFIX) && !name.startsWith(THEME_PREFIX) && !name.startsWith('light.') && !name.startsWith('dark.')) {
-      console.warn(`[Theme] Strict mode enabled: '${name}' is not a valid color token.`);
-    }
-    // 3. Select the correct color set (light/dark) based on the effective mode
-    const colorsToUse = themeColors[effectiveMode];
-    if (!colorsToUse) {
-      console.warn(`Color set for mode "${effectiveMode}" not found.`);
-      return name;
-    }
-    let resolvedColor = name;
-    try {
-      // Resolve "light.*" or "dark.*" paths directly
-      if (name.startsWith('light.') || name.startsWith('dark.')) {
-        const prefixLength = name.startsWith('light.') ? 6 : 5;
-        const modifiedName = `${COLOR_PREFIX}${name.substring(prefixLength)}`;
-        return `var(--${modifiedName.replace(/\./g, '-')})`;
+    const parts = name.split('-');
+    const lastPart = parts[parts.length - 1];
+    const maybeAlpha = parseInt(lastPart, 10);
+    // Handle theme-* tokens (e.g., theme-primary, theme-primary-100)
+    if (name.startsWith(THEME_PREFIX)) {
+      // Check for alpha suffix: theme-primary-100 (3+ parts, last is 0-1000)
+      if (parts.length >= 3 && !isNaN(maybeAlpha) && maybeAlpha >= 0 && maybeAlpha <= 1000) {
+        const baseVar = parts.slice(0, -1).join('-');
+        const percentage = Math.round(maybeAlpha / 1000 * 100);
+        return `color-mix(in srgb, var(--${baseVar}) ${percentage}%, transparent)`;
       }
-      // Resolve "color.*" paths
-      if (name.startsWith(COLOR_PREFIX)) {
-        const keys = name.substring(COLOR_PREFIX.length).split('.');
-        if (keys.length === 3) {
-          // e.g. "color.black.900.200" (alpha)
-          const [colorName, variant, alphaStr] = keys;
-          const palette = deepMerge(colorsToUse.palette, override?.colors?.palette || {});
-          const shadeValue = palette?.[colorName]?.[variant];
-          const alpha = parseInt(alphaStr, 10);
-          if (typeof shadeValue === 'string' && !isNaN(alpha)) {
-            resolvedColor = convertToRgba(shadeValue, alpha);
-          }
-        } else if (keys.length === 2) {
-          // e.g. "color.blue.500"
-          const [colorName, variant] = keys;
-          const palette = deepMerge(colorsToUse.palette, override?.colors?.palette || {});
-          const shadeValue = palette?.[colorName]?.[variant];
-          if (typeof shadeValue === 'string') {
-            resolvedColor = shadeValue;
-          }
-        } else if (keys.length === 1) {
-          // e.g. "color.blue"
-          const [colorName] = keys;
-          const main = deepMerge(colorsToUse.main, override?.colors?.main || {});
-          const colorValue = main?.[colorName];
-          if (typeof colorValue === 'string') {
-            resolvedColor = colorValue;
-          }
-        }
+      return `var(--${name})`;
+    }
+    // Handle color-* tokens (e.g., color-blue-500, color-blue-500-200)
+    if (name.startsWith(COLOR_PREFIX)) {
+      // Check for alpha suffix: color-blue-500-200 (4+ parts, last is 0-1000)
+      if (parts.length >= 4 && !isNaN(maybeAlpha) && maybeAlpha >= 0 && maybeAlpha <= 1000) {
+        const baseVar = parts.slice(0, -1).join('-');
+        const percentage = Math.round(maybeAlpha / 1000 * 100);
+        return `color-mix(in srgb, var(--${baseVar}) ${percentage}%, transparent)`;
       }
-    } catch (e) {
-      console.error(`Error resolving color "${name}"`, e);
-      resolvedColor = name;
+      return `var(--${name})`;
     }
-    if (needCache) colorCache.set(cacheKey, resolvedColor);
-    return resolvedColor;
-  }, [mergedTheme, themeColors, themeMode, colorCache, strict]);
+    // Handle light-* and dark-* tokens (e.g., light-blue-500, dark-red-200)
+    if (name.startsWith(LIGHT_PREFIX) || name.startsWith(DARK_PREFIX)) {
+      const prefix = name.startsWith(LIGHT_PREFIX) ? LIGHT_PREFIX : DARK_PREFIX;
+      const colorPart = name.substring(prefix.length);
+      return `var(--${prefix}color-${colorPart})`;
+    }
+    // Return as-is for direct values (#hex, rgb(), etc.)
+    return name;
+  }, [strict]);
   const getColorHex = React.useCallback((name, override) => {
     if (!name || typeof name !== 'string') return String(name);
     if (name === TRANSPARENT) return '#00000000';
@@ -1298,7 +1287,7 @@ const ThemeProvider = _ref => {
     if (!name || typeof name !== 'string') return undefined;
     const effectiveMode = override?.themeMode ?? themeMode;
     const effectiveTheme = override?.theme ? deepMerge(mergedTheme, override.theme) : mergedTheme;
-    // Resolve theme.* tokens to get the underlying color token
+    // Resolve theme-* tokens to get the underlying color token
     let colorToken = name;
     if (name.startsWith(THEME_PREFIX)) {
       const themeKey = name.substring(THEME_PREFIX.length);
@@ -1307,16 +1296,16 @@ const ThemeProvider = _ref => {
         colorToken = themeValue;
       }
     }
-    // Handle light.* or dark.* prefixes
-    if (colorToken.startsWith('light.') || colorToken.startsWith('dark.')) {
-      const prefixLength = colorToken.startsWith('light.') ? 6 : 5;
-      colorToken = `${COLOR_PREFIX}${colorToken.substring(prefixLength)}`;
+    // Handle light-* or dark-* prefixes
+    if (colorToken.startsWith(LIGHT_PREFIX) || colorToken.startsWith(DARK_PREFIX)) {
+      const prefix = colorToken.startsWith(LIGHT_PREFIX) ? LIGHT_PREFIX : DARK_PREFIX;
+      colorToken = `${COLOR_PREFIX}${colorToken.substring(prefix.length)}`;
     }
-    // Extract color scheme from color.* tokens (e.g., color.blue.500 -> 'blue')
+    // Extract color scheme from color-* tokens (e.g., color-blue-500 -> 'blue')
     if (colorToken.startsWith(COLOR_PREFIX)) {
-      const keys = colorToken.substring(COLOR_PREFIX.length).split('.');
-      if (keys.length >= 1) {
-        return keys[0]; // Return the color scheme name (e.g., 'blue', 'pink')
+      const parts = colorToken.substring(COLOR_PREFIX.length).split('-');
+      if (parts.length >= 1) {
+        return parts[0]; // Return the color scheme name (e.g., 'blue', 'pink')
       }
     }
     // Handle hex or rgba colors by finding the closest match in the palette
@@ -2702,7 +2691,7 @@ function processPseudoStyles(styles, parentPseudo, getColor, manager) {
  */
 function processEventStyles(eventName, eventStyles, getColor, manager) {
   const classes = [];
-  // Handle string shorthand (e.g., _hover: "color.red.500")
+  // Handle string shorthand (e.g., _hover: "color-red-500")
   if (typeof eventStyles === 'string') {
     eventStyles = {
       color: eventStyles
@@ -3022,20 +3011,10 @@ const Element = /*#__PURE__*/React__default.memo(/*#__PURE__*/React.forwardRef((
   }
   const {
     onPress,
-    blend: initialBlend,
+    blend,
     animateOn = 'Both',
     ...rest
   } = props;
-  let blend = initialBlend;
-  if (blend !== false && props.color === undefined && typeof props.children === 'string' && (as === 'span' || as === 'div' || as === 'sub' || as === 'sup')) {
-    const otherMediaProps = {
-      ...(props.on || {}),
-      ...(props.media || {})
-    };
-    if (otherMediaProps.color === undefined) {
-      blend = true;
-    }
-  }
   const elementRef = React.useRef(null);
   const setRef = React.useCallback(node => {
     elementRef.current = node;
@@ -4952,7 +4931,7 @@ const Skeleton = /*#__PURE__*/React__default.memo(_ref => {
     ...props
   } = _ref;
   return /*#__PURE__*/React__default.createElement(View, Object.assign({
-    backgroundColor: "color.black.300"
+    backgroundColor: "color-black-300"
   }, props, {
     overflow: "hidden"
   }), /*#__PURE__*/React__default.createElement(View, {

package/dist/app-studio.cjs.development.js.map

@@ -1 +1 @@
-{"version":3,"file":"app-studio.cjs.development.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"app-studio.cjs.development.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}