app-studio 0.7.2 → 0.7.5

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

@@ -756,15 +756,15 @@
     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.
@@ -782,8 +782,11 @@
   };
 
   // --- 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) => {
@@ -827,21 +830,17 @@
     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};`);
           }
@@ -877,14 +876,16 @@
     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,
@@ -942,9 +943,9 @@
     // 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];
@@ -1099,83 +1100,111 @@
       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);
@@ -1184,86 +1213,46 @@
       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';
@@ -1297,7 +1286,7 @@
       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);
@@ -1306,16 +1295,16 @@
           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
@@ -2701,7 +2690,7 @@
    */
   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
@@ -3021,20 +3010,10 @@
     }
     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;
@@ -4951,7 +4930,7 @@
       ...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.umd.development.js.map

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