purgetss 3.0.4 → 3.1.2

package/lib/helpers.js

@@ -5,9 +5,9 @@ const HEX_3_REGEX = /^#?([a-f\d])([a-f\d])([a-f\d])$/i; // i.e. #0F3
 const HEX_4_REGEX = /^#?([a-f\d])([a-f\d])([a-f\d])([a-f\d])$/i; // i.e. #80F3
 const HEX_6_REGEX = /^#?([a-f\d]){6}$/i; // i.e. #00FF33
 const HEX_8_REGEX = /^#?([a-f\d]){8}$/i; // i.e. #8800FF33
-let _applyClasses = {};
 
 let startTime;
+let _applyClasses = {};
 
 function start() {
 	startTime = new Date();
@@ -30,200 +30,384 @@ function resetStyles() {
 }
 exports.resetStyles = resetStyles;
 
-// Main Functions
-function processModifiersAndProperties(header, objectPosition, modifiersAndValues, minusSigns = '') {
-	let convertedStyles = `\n// ${header} Property\n`;
-
-	_.each(objectPosition, (properties, rule) => {
-		_.each(modifiersAndValues, (value, modifier) => {
-			let ruleSign = (modifier.startsWith('-')) ? '-' : '';
-			if (typeof value === 'object') {
-				_.each(value, (_value, _modifier) => {
-					convertedStyles += `'.${ruleSign}${rule}-${modifier}${setModifier(_modifier)}': ` + _.replace(properties, new RegExp("{value}", "g"), parseValue(_value, minusSigns)) + '\n';
-				});
-			} else {
-				convertedStyles += `'.${ruleSign}${rule}${setModifier(modifier)}': ` + _.replace(properties, new RegExp("{value}", "g"), parseValue(value, minusSigns)) + '\n';
-			}
-		});
-	});
-
-	return convertedStyles;
-}
-
 function textColor(modifiersAndValues) {
-	return processModifiersAndProperties('color', { 'text': '{ color: {value} }' }, modifiersAndValues);
+	return processProperties({ 'prop': 'color', 'component': 'Ti.UI.Button, Ti.UI.Label, Ti.UI.PickerRow, Ti.UI.SearchBar, Ti.UI.TextArea, Ti.UI.ActivityIndicator, Ti.UI.Animation, Ti.UI.ListItem, Ti.UI.ProgressBar, Ti.UI.Switch, Ti.UI.TableViewRow, Ti.UI.TextField, Ti.UI.Android.SearchView' }, {
+		'text': '{ color: {value} }'
+	}, modifiersAndValues);
 }
 exports.textColor = textColor;
 
 function backgroundColor(modifiersAndValues) {
-	return processModifiersAndProperties('backgroundColor', { 'bg': '{ backgroundColor: {value} }' }, modifiersAndValues);
+	return processProperties({ 'prop': 'backgroundColor', 'component': 'Ti.UI, Ti.UI.Android.CardView, Ti.UI.Animation, Ti.UI.iPad.Popover, Ti.UI.ListItem, Ti.UI.Picker, Ti.UI.Tab, Ti.UI.TableView, Ti.UI.View, Ti.UI.Window' }, {
+		'bg': '{ backgroundColor: {value} }'
+	}, modifiersAndValues);
 }
 exports.backgroundColor = backgroundColor;
 
 function navTintColor(modifiersAndValues) {
-	return processModifiersAndProperties('navTintColor', { 'nav-tint': '{ navTintColor: {value} }' }, modifiersAndValues);
+	return processProperties({ 'prop': 'navTintColor', 'component': 'Ti.UI.TabGroup, Ti.UI.Window' }, {
+		'nav-tint': '{ navTintColor: {value} }'
+	}, modifiersAndValues);
 }
 exports.navTintColor = navTintColor;
 
 function backgroundSelectedColor(modifiersAndValues) {
-	return processModifiersAndProperties('backgroundSelectedColor', { 'bg-selected': '{ backgroundSelectedColor: {value} }' }, modifiersAndValues);
+	return processProperties({ 'prop': 'backgroundSelectedColor', 'component': 'Ti.UI.Button, Ti.UI.ListItem, Ti.UI.TableViewRow, Ti.UI.View' }, {
+		'bg-selected': '{ backgroundSelectedColor: {value} }'
+	}, modifiersAndValues);
 }
 exports.backgroundSelectedColor = backgroundSelectedColor;
 
 function barColor(modifiersAndValues) {
-	return processModifiersAndProperties('barColor', { 'bar': '{ barColor: {value} }' }, modifiersAndValues);
+	return processProperties({ 'prop': 'barColor', 'component': 'Ti.UI.EmailDialog, Ti.UI.SearchBar, Ti.UI.TabGroup, Ti.UI.Toolbar, Ti.UI.Window' }, {
+		'bar': '{ barColor: {value} }'
+	}, modifiersAndValues);
 }
 exports.barColor = barColor;
 
-function cacheSize() {
-	let modifiersAndValues = {
-		1: 1,
-		2: 2,
-		3: 3,
-		4: 4,
-		5: 5,
-		6: 6,
-		7: 7,
-		8: 8,
-		9: 9,
-		10: 10,
-	};
+function shadow(shadowValue = '#59000000') {
+	let convertedStyles = processComments({ 'prop': 'viewShadowOffset, viewShadowRadius, viewShadowColor - Box Shadow in Tailwind', 'component': 'Ti.UI.View' });
+	convertedStyles += `'.shadow-xs': { viewShadowOffset: { x: 0, y: 0 }, viewShadowRadius: 1, viewShadowColor: '${shadowValue}' }\n`;
+	convertedStyles += `'.shadow-sm': { viewShadowOffset: { x: 0, y: 1 }, viewShadowRadius: 1, viewShadowColor: '${shadowValue}' }\n`;
+	convertedStyles += `'.shadow': { viewShadowOffset: { x: 0, y: 2 }, viewShadowRadius: 2, viewShadowColor: '${shadowValue}' }\n`;
+	convertedStyles += `'.shadow-md': { viewShadowOffset: { x: 0, y: 3 }, viewShadowRadius: 3, viewShadowColor: '${shadowValue}' }\n`;
+	convertedStyles += `'.shadow-lg': { viewShadowOffset: { x: 0, y: 4 }, viewShadowRadius: 4, viewShadowColor: '${shadowValue}' }\n`;
+	convertedStyles += `'.shadow-xl': { viewShadowOffset: { x: 0, y: 6 }, viewShadowRadius: 6, viewShadowColor: '${shadowValue}' }\n`;
+	convertedStyles += `'.shadow-2xl': { viewShadowOffset: { x: 0, y: 8 }, viewShadowRadius: 8, viewShadowColor: '${shadowValue}' }\n`;
 
-	return processModifiersAndProperties('cacheSize', { 'cache-size': '{ cacheSize: {value} }' }, modifiersAndValues);
+	convertedStyles += `'.shadow-inner': { viewShadowOffset: { x: 0, y: 0 }, viewShadowRadius: null, viewShadowColor: null }\n`;
+	convertedStyles += `'.shadow-outline': { viewShadowOffset: { x: 0, y: 0 }, viewShadowRadius: 2, viewShadowColor: '${shadowValue}' }\n`;
+	convertedStyles += `'.shadow-none': { viewShadowOffset: { x: 0, y: 0 }, viewShadowRadius: null, viewShadowColor: null }\n`;
+
+	return convertedStyles;
 }
-exports.cacheSize = cacheSize;
+exports.shadow = shadow;
+
+function shadowColor(modifiersAndValues) {
+	return processProperties({ 'prop': 'viewShadowColor - Box Shadow in Tailwind', 'component': 'Ti.UI.View' }, {
+		'shadow': '{ viewShadowColor: {value} }',
+	}, modifiersAndValues);
+}
+exports.shadowColor = shadowColor;
+
+function dropShadow(shadowValue = '#59000000') {
+	let convertedStyles = processComments({ 'prop': 'shadowOffset, shadowRadius, shadowColor - Drop Shadow in Tailwind', 'component': 'Ti.UI.Button, Ti.UI.Label' });
+	convertedStyles += `'.drop-shadow-xs': { shadowOffset: { x: 0, y: 0 }, shadowRadius: 1, shadowColor: '${shadowValue}' }\n`;
+	convertedStyles += `'.drop-shadow-sm': { shadowOffset: { x: 0, y: 1 }, shadowRadius: 1, shadowColor: '${shadowValue}' }\n`;
+	convertedStyles += `'.drop-shadow': { shadowOffset: { x: 0, y: 2 }, shadowRadius: 2, shadowColor: '${shadowValue}' }\n`;
+	convertedStyles += `'.drop-shadow-md': { shadowOffset: { x: 0, y: 3 }, shadowRadius: 3, shadowColor: '${shadowValue}' }\n`;
+	convertedStyles += `'.drop-shadow-lg': { shadowOffset: { x: 0, y: 4 }, shadowRadius: 4, shadowColor: '${shadowValue}' }\n`;
+	convertedStyles += `'.drop-shadow-xl': { shadowOffset: { x: 0, y: 6 }, shadowRadius: 6, shadowColor: '${shadowValue}' }\n`;
+	convertedStyles += `'.drop-shadow-2xl': { shadowOffset: { x: 0, y: 8 }, shadowRadius: 8, shadowColor: '${shadowValue}' }\n`;
+	convertedStyles += `'.drop-shadow-none': { shadowOffset: { x: 0, y: 0 }, shadowRadius: null, shadowColor: null }\n`;
+
+	return convertedStyles;
+}
+exports.dropShadow = dropShadow;
+
+function dropShadowColor(modifiersAndValues) {
+	return processProperties({ 'prop': 'shadowColor - Drop Shadow in Tailwind', 'component': 'Ti.UI.Button, Ti.UI.Label' }, {
+		'drop-shadow': '{ shadowColor: {value} }',
+	}, modifiersAndValues);
+}
+exports.dropShadowColor = dropShadowColor;
+
+function barTitleShadow(shadowValue = '#59000000') {
+
+	let convertedStyles = processComments({ 'prop': 'titleAttributes: shadow, offset, blurRadius - Bar Title Shadow', 'component': 'Ti.UI.TabGroup, Ti.UI.Window' });
+	convertedStyles += `'.bar-shadow-xs': { titleAttributes: { shadow: { color: '${shadowValue}', offset: { width: 0, height: 0 }, blurRadius: 1 } } }\n`;
+	convertedStyles += `'.bar-shadow-sm': { titleAttributes: { shadow: { color: '${shadowValue}', offset: { width: 0, height: 1 }, blurRadius: 1 } } }\n`;
+	convertedStyles += `'.bar-shadow': { titleAttributes: { shadow: { color: '${shadowValue}', offset: { width: 0, height: 2 }, blurRadius: 2 } } }\n`;
+	convertedStyles += `'.bar-shadow-md': { titleAttributes: { shadow: { color: '${shadowValue}', offset: { width: 0, height: 3 }, blurRadius: 3 } } }\n`;
+	convertedStyles += `'.bar-shadow-lg': { titleAttributes: { shadow: { color: '${shadowValue}', offset: { width: 0, height: 4 }, blurRadius: 4 } } }\n`;
+	convertedStyles += `'.bar-shadow-xl': { titleAttributes: { shadow: { color: '${shadowValue}', offset: { width: 0, height: 6 }, blurRadius: 6 } } }\n`;
+	convertedStyles += `'.bar-shadow-2xl': { titleAttributes: { shadow: { color: '${shadowValue}', offset: { width: 0, height: 8 }, blurRadius: 8 } } }\n`;
+	convertedStyles += `'.bar-shadow-none': { titleAttributes: { shadow: { color: null, offset: { width: 0, height: 0 }, blurRadius: null } } }\n`;
+
+	return convertedStyles;
+}
+exports.barTitleShadow = barTitleShadow;
+
+function barTitleShadowColor(modifiersAndValues) {
+	return processProperties({ 'prop': 'titleAttributes: shadow - Bar Title Shadow', 'component': 'Ti.UI.TabGroup, Ti.UI.Window' }, {
+		'bar': '{ titleAttributes: { shadow: { color: {value} } } }'
+	}, {
+		'shadow': {
+			'ios': modifiersAndValues
+		}
+	});
+}
+exports.barTitleShadowColor = barTitleShadowColor;
+
+function barTitleColor(modifiersAndValues) {
+	return processProperties({ 'prop': 'titleAttributes', 'component': 'Ti.UI.TabGroup, Ti.UI.Window' }, {
+		'bar': '{ titleAttributes: { color: {value} } }'
+	}, {
+		title: {
+			ios: { ...modifiersAndValues }
+		}
+	});
+}
+exports.barTitleColor = barTitleColor;
 
 function tabsBackgroundColor(modifiersAndValues) {
-	return processModifiersAndProperties('tabsBackgroundColor', { 'tabs-bg': '{ tabsBackgroundColor: {value} }' }, modifiersAndValues);
+	return processProperties({ 'prop': 'tabsBackgroundColor', 'component': 'Ti.UI.TabGroup' }, {
+		'tabs-bg': '{ tabsBackgroundColor: {value} }'
+	}, modifiersAndValues);
 }
 exports.tabsBackgroundColor = tabsBackgroundColor;
 
+function tabsBackgroundSelectedColor(modifiersAndValues) {
+	return processProperties({ 'prop': 'tabsBackgroundSelectedColor', 'component': 'Ti.UI.TabGroup' }, {
+		'tabs-bg-selected': '{ tabsBackgroundSelectedColor: {value} }'
+	}, modifiersAndValues);
+}
+exports.tabsBackgroundSelectedColor = tabsBackgroundSelectedColor;
+
 function titleColor(modifiersAndValues) {
-	return processModifiersAndProperties('titleColor', { 'title': '{ titleColor: {value} }' }, modifiersAndValues);
+	return processProperties({ 'prop': 'titleColor', 'component': 'Ti.UI.Tab, Ti.UI.TabGroup' }, {
+		'title': '{ titleColor: {value} }'
+	}, modifiersAndValues);
 }
 exports.titleColor = titleColor;
 
 function activeTintColor(modifiersAndValues) {
-	return processModifiersAndProperties('activeTintColor', { 'active-tint': '{ activeTintColor: {value} }' }, modifiersAndValues);
+	return processProperties({ 'prop': 'activeTintColor', 'component': 'Ti.UI.Tab, Ti.UI.TabGroup' }, {
+		'active-tint': '{ activeTintColor: {value} }'
+	}, modifiersAndValues);
 }
 exports.activeTintColor = activeTintColor;
 
 function activeTitleColor(modifiersAndValues) {
-	return processModifiersAndProperties('activeTitleColor', { 'active-title': '{ activeTitleColor: {value} }' }, modifiersAndValues);
+	return processProperties({ 'prop': 'activeTitleColor', 'component': 'Ti.UI.Tab, Ti.UI.TabGroup' }, {
+		'active-title': '{ activeTitleColor: {value} }'
+	}, modifiersAndValues);
 }
 exports.activeTitleColor = activeTitleColor;
 
 function borderColor(modifiersAndValues) {
-	return processModifiersAndProperties('borderColor', { 'border': '{ borderColor: {value} }' }, modifiersAndValues);
+	return processProperties({ 'prop': 'borderColor', 'component': 'Ti.UI.View' }, {
+		'border': '{ borderColor: {value} }'
+	}, modifiersAndValues);
 }
 exports.borderColor = borderColor;
 
+function indicatorColor(modifiersAndValues) {
+	return processProperties({ 'prop': 'indicatorColor', 'component': 'Ti.UI.ActivityIndicator' }, {
+		'indicator': '{ indicatorColor: {value} }'
+	}, modifiersAndValues);
+}
+exports.indicatorColor = indicatorColor;
+
 function pagingControlAlpha(modifiersAndValues) {
-	return processModifiersAndProperties('pagingControlAlpha', { 'paging-alpha': '{ pagingControlAlpha: {value} }' }, modifiersAndValues);
+	return processProperties({ 'prop': 'pagingControlAlpha', 'component': 'Ti.UI.ScrollableView' }, {
+		'paging-alpha': '{ pagingControlAlpha: {value} }'
+	}, modifiersAndValues);
 }
 exports.pagingControlAlpha = pagingControlAlpha;
 
 function pagingControlColor(modifiersAndValues) {
-	return processModifiersAndProperties('pagingControlColor', { 'paging': '{ pagingControlColor: {value} }' }, modifiersAndValues);
+	return processProperties({ 'prop': 'pagingControlColor', 'component': 'Ti.UI.ScrollableView' }, {
+		'paging': '{ pagingControlColor: {value} }'
+	}, modifiersAndValues);
 }
 exports.pagingControlColor = pagingControlColor;
 
 function pageIndicatorColor(modifiersAndValues) {
-	return processModifiersAndProperties('pageIndicatorColor', { 'page': '{ pageIndicatorColor: {value} }' }, modifiersAndValues);
+	return processProperties({ 'prop': 'pageIndicatorColor', 'component': 'Ti.UI.ScrollableView' }, {
+		'page': '{ pageIndicatorColor: {value} }'
+	}, modifiersAndValues);
 }
 exports.pageIndicatorColor = pageIndicatorColor;
 
 function currentPageIndicatorColor(modifiersAndValues) {
-	return processModifiersAndProperties('currentPageIndicatorColor', { 'current-page': '{ currentPageIndicatorColor: {value} }' }, modifiersAndValues);
+	return processProperties({ 'prop': 'currentPageIndicatorColor', 'component': 'Ti.UI.ScrollableView' }, {
+		'current-page': '{ currentPageIndicatorColor: {value} }'
+	}, modifiersAndValues);
 }
 exports.currentPageIndicatorColor = currentPageIndicatorColor;
 
-function pagingControlHeight({ ...modifiersAndValues }) {
-	modifiersAndValues = removeFractions(modifiersAndValues);
-
-	delete modifiersAndValues.full;
-	delete modifiersAndValues.auto;
-	delete modifiersAndValues.screen;
-
-	return processModifiersAndProperties('pagingControlHeight', { 'paging-h': '{ pagingControlHeight: {value} }' }, modifiersAndValues);
-}
-exports.pagingControlHeight = pagingControlHeight;
-
 function touchFeedbackColor(modifiersAndValues) {
-	return processModifiersAndProperties('touchFeedbackColor', { 'feedback': '{ touchFeedback: true, touchFeedbackColor: {value} }' }, modifiersAndValues);
+	return processProperties({ 'prop': 'touchFeedbackColor', 'component': 'Ti.UI.View' }, {
+		'feedback': '{ touchFeedback: true, touchFeedbackColor: {value} }'
+	}, modifiersAndValues);
 }
 exports.touchFeedbackColor = touchFeedbackColor;
 
 function placeholderColor(modifiersAndValues) {
-	return processModifiersAndProperties('hintTextColor', { 'placeholder': '{ hintTextColor: {value} }' }, modifiersAndValues);
+	return processProperties({ 'prop': 'hintTextColor', 'component': 'Ti.UI.Android.SearchView, Ti.UI.SearchBar, Ti.UI.TextArea, Ti.UI.TextField' }, {
+		'placeholder': '{ hintTextColor: {value} }'
+	}, modifiersAndValues);
 }
 exports.placeholderColor = placeholderColor;
 
 function tintColor(modifiersAndValues) {
-	return processModifiersAndProperties('tintColor', { 'tint': '{ tintColor: {value} }' }, modifiersAndValues);
+	return processProperties({ 'prop': 'tint and tintColor', 'component': 'Ti.UI, Ti.UI.AlertDialog, Ti.UI.Button, Ti.UI.ImageView, Ti.UI.iOS.Stepper, Ti.UI.ProgressBar, Ti.UI.RefreshControll, Ti.UI.Slider, Ti.UI.Switch, and `tint` for Ti.UI.MaskedImage' }, {
+		'tint': '{ tint: {value}, tintColor: {value} }'
+	}, modifiersAndValues);
 }
 exports.tintColor = tintColor;
 
-function rotate(modifiersAndValues) {
-	return processModifiersAndProperties('rotate', { 'rotate': '{ rotate: {value} }' }, modifiersAndValues);
+function borderRadiusExtraStyles({ ...modifiersAndValues }) {
+	// SOME CLEANUP... SOME VALUES NOT NEEDED HERE!.
+	delete modifiersAndValues[0];
+	delete modifiersAndValues.fit;
+	delete modifiersAndValues.min;
+	delete modifiersAndValues.max;
+	delete modifiersAndValues.full;
+	delete modifiersAndValues.auto;
+	delete modifiersAndValues.screen;
+	delete modifiersAndValues['min-content'];
+	delete modifiersAndValues['max-content'];
+
+	_.each(modifiersAndValues, (value, key) => {
+		if (key.includes('/')) {
+			delete modifiersAndValues[key];
+		} else if (['sm', 'md', 'lg', 'xl', '2xl', '3xl', 'px', 'DEFAULT'].includes(key)) {
+			modifiersAndValues[key] = value;
+		} else {
+			modifiersAndValues[key] = 8 * parseFloat(value);
+		}
+	});
+
+	return processProperties({ 'prop': 'borderRadius ( with Extra Styles )', 'component': 'Ti.UI.Android.CardView, Ti.UI.View' }, {
+		'rounded': '{ borderRadius: {value} }',
+
+		'rounded-t': '{ borderRadius: [{value}, {value}, 0, 0] }',
+		'rounded-r': '{ borderRadius: [0, {value}, {value}, 0] }',
+		'rounded-b': '{ borderRadius: [0, 0, {value}, {value}] }',
+		'rounded-l': '{ borderRadius: [{value}, 0, 0, {value}] }',
+
+		'rounded-tl': '{ borderRadius: [{value}, 0, 0, 0] }',
+		'rounded-tr': '{ borderRadius: [0, {value}, 0, 0] }',
+		'rounded-br': '{ borderRadius: [0, 0, {value}, 0] }',
+		'rounded-bl': '{ borderRadius: [0, 0, 0, {value}] }',
+
+	}, modifiersAndValues);
 }
-exports.rotate = rotate;
+exports.borderRadiusExtraStyles = borderRadiusExtraStyles;
 
-function zIndex(modifiersAndValues) {
-	delete modifiersAndValues.auto;
-	return processModifiersAndProperties('zIndex', { 'z': '{ zIndex: {value} }' }, modifiersAndValues);
+function borderWidth({ ...modifiersAndValues }) {
+	_.each(modifiersAndValues, (value, key) => {
+		modifiersAndValues[key] = parseInt(value);
+	});
+
+	return processProperties({ 'prop': 'borderWidth', 'component': 'Ti.UI.View' }, {
+		'border': '{ borderWidth: {value} }'
+	}, modifiersAndValues);
 }
-exports.zIndex = zIndex;
+exports.borderWidth = borderWidth;
 
 function scale(modifiersAndValues) {
-	modifiersAndValues[5] = .05;
-	modifiersAndValues[10] = .10;
-	modifiersAndValues[25] = .25;
-	return processModifiersAndProperties('scale', { 'scale': '{ scale: \'{value}\' }' }, modifiersAndValues);
+	return processProperties({ 'prop': 'scale', 'component': 'Ti.UI.ScrollView' }, {
+		'scale': '{ scale: \'{value}\' }'
+	}, modifiersAndValues);
 }
 exports.scale = scale;
 
+function fontWeight({ ...modifiersAndValues }) {
+	const invalidValues = {
+		black: 'bold',
+		medium: 'normal',
+		extrabold: 'bold',
+		hairline: 'ultralight'
+	}
+
+	_.each(modifiersAndValues, (value, key) => {
+		modifiersAndValues[key] = fixInvalidValues(invalidValues, key);
+	});
+
+	return processProperties({ 'prop': 'fontWeight', 'component': 'Ti.UI.ActivityIndicator, Ti.UI.Button, Ti.UI.Label, Ti.UI.ListItem, Ti.UI.Picker, Ti.UI.PickerColumn, Ti.UI.PickerRow, Ti.UI.ProgressBar, Ti.UI.Switch, Ti.UI.TableViewRow, Ti.UI.TextArea, Ti.UI.TextField' }, {
+		'font': '{ font: { fontWeight: {value} } }'
+	}, modifiersAndValues);
+}
+exports.fontWeight = fontWeight;
+
+function gap({ ...modifiersAndValues }) {
+	// SOME CLEANUP... VALUES NOT NEEDED HERE!.
+	modifiersAndValues = removeFractions(modifiersAndValues);
+
+	modifiersAndValues.auto = 'auto';
+	delete modifiersAndValues.min;
+	delete modifiersAndValues.max;
+	delete modifiersAndValues.screen;
+	delete modifiersAndValues['min-content'];
+	delete modifiersAndValues['max-content'];
+
+	return processProperties({ 'prop': 'top, right, bottom, left - Gap for Grid System', 'component': 'Ti.UI.ActivityIndicator, Ti.UI.Animation, Ti.UI.View, Ti.UI.Window' }, {
+		'gap': '{ top: {value}, right: {value}, bottom: {value}, left: {value} }',
+		'gap-b': '{ bottom: {value} }',
+		'gap-l': '{ left: {value} }',
+		'gap-r': '{ right: {value} }',
+		'gap-t': '{ top: {value} }',
+		'gap-x': '{ right: {value}, left: {value} }',
+		'gap-y': '{ top: {value}, bottom: {value} }',
+	}, modifiersAndValues);
+}
+exports.gap = gap;
+
 function transitionDuration(modifiersAndValues) {
 	modifiersAndValues[0] = '0ms';
 	modifiersAndValues[25] = '25ms';
 	modifiersAndValues[50] = '50ms';
-	return processModifiersAndProperties('duration', { 'duration': '{ duration: {value} }' }, modifiersAndValues);
+
+	return processProperties({ 'prop': 'duration', 'component': 'Ti.UI.Animation' }, {
+		'duration': '{ duration: {value} }'
+	}, modifiersAndValues);
 }
 exports.transitionDuration = transitionDuration;
 
 function transitionDelay(modifiersAndValues) {
-	modifiersAndValues[0] = '0ms';
-	modifiersAndValues[25] = '25ms';
-	modifiersAndValues[50] = '50ms';
-	modifiersAndValues[2000] = '2000ms';
-	modifiersAndValues[3000] = '3000ms';
-	modifiersAndValues[4000] = '4000ms';
-	modifiersAndValues[5000] = '5000ms';
-	return processModifiersAndProperties('delay', { 'delay': '{ delay: {value} }' }, modifiersAndValues);
+	return processProperties({ 'prop': 'delay', 'component': 'Ti.UI.Animation' }, {
+		'delay': '{ delay: {value} }'
+	}, modifiersAndValues);
 }
 exports.transitionDelay = transitionDelay;
 
 function pagingControlTimeout(modifiersAndValues) {
-	modifiersAndValues[0] = '0ms';
-	modifiersAndValues[25] = '25ms';
-	modifiersAndValues[50] = '50ms';
-	modifiersAndValues[2000] = '2000ms';
-	modifiersAndValues[3000] = '3000ms';
-	modifiersAndValues[4000] = '4000ms';
-	modifiersAndValues[5000] = '5000ms';
-
-	return processModifiersAndProperties('pagingControlTimeout', { 'paging-timeout': '{ pagingControlTimeout: {value} }' }, modifiersAndValues);
+	return processProperties({ 'prop': 'pagingControlTimeout', 'component': 'Ti.UI.ScrollableView' }, {
+		'paging-timeout': '{ pagingControlTimeout: {value} }'
+	}, modifiersAndValues);
 }
 exports.pagingControlTimeout = pagingControlTimeout;
 
-
 function fontFamily(modifiersAndValues) {
-	return processModifiersAndProperties('fontFamily', { 'font': '{ font: { fontFamily: {value} } }' }, modifiersAndValues);
+	return processProperties({ 'prop': 'fontFamily', 'component': 'Ti.UI.ActivityIndicator, Ti.UI.Button, Ti.UI.Label, Ti.UI.ListItem, Ti.UI.Picker, Ti.UI.PickerColumn, Ti.UI.PickerRow, Ti.UI.ProgressBar, Ti.UI.Switch, Ti.UI.TableViewRow, Ti.UI.TextArea, Ti.UI.TextField' }, {
+		'font': '{ font: { fontFamily: {value} } }'
+	}, modifiersAndValues);
 }
 exports.fontFamily = fontFamily;
 
+function pagingControlHeight({ ...modifiersAndValues }) {
+	modifiersAndValues = removeFractions(modifiersAndValues);
+
+	delete modifiersAndValues.full;
+	delete modifiersAndValues.auto;
+	delete modifiersAndValues.screen;
+
+	return processProperties({ 'prop': 'pagingControlHeight', 'component': 'Ti.UI.ScrollableView' }, {
+		'paging-h': '{ pagingControlHeight: {value} }'
+	}, modifiersAndValues);
+}
+exports.pagingControlHeight = pagingControlHeight;
+
+function rotate(modifiersAndValues) {
+	return processProperties({ 'prop': 'rotate', 'component': 'For the Animation Component' }, {
+		'rotate': '{ rotate: {value} }'
+	}, modifiersAndValues);
+}
+exports.rotate = rotate;
+
+function zIndex(modifiersAndValues) {
+	delete modifiersAndValues.auto;
+	return processProperties({ 'prop': 'zIndex', 'component': 'Ti.UI.Animation, Ti.UI.View' }, {
+		'z': '{ zIndex: {value} }'
+	}, modifiersAndValues);
+}
+exports.zIndex = zIndex;
+
 function linearGradient() {
-	let convertedStyles = `\n// Linear backgroundGradient Property\n`;
+	let convertedStyles = processComments({ 'prop': 'backgroundGradient - Linear', 'component': 'Ti.UI.MaskedImage' });
 
 	convertedStyles += `'.bg-linear': { backgroundGradient: { type: 'linear', startPoint: { x: '50%', y: '100%' }, endPoint: { x: '50%', y: '0%' }, backfillStart: true } }\n`;
 	convertedStyles += `'.bg-linear-to-t': { backgroundGradient: { type: 'linear', startPoint: { x: '0%', y: '0%' }, endPoint: { x: '0%', y: '100%' }, backfillStart: true } }\n`;
@@ -235,7 +419,7 @@ function linearGradient() {
 	convertedStyles += `'.bg-linear-to-l': { backgroundGradient: { type: 'linear', startPoint: { x: '0%', y: '0%' }, endPoint: { x: '100%', y: '0%' }, backfillStart: true } }\n`;
 	convertedStyles += `'.bg-linear-to-tl': { backgroundGradient: { type: 'linear', startPoint: { x: '0%', y: '0%' }, endPoint: { x: '100%', y: '100%' }, backfillStart: true } }\n`;
 
-	convertedStyles += '\n';
+	convertedStyles += processComments({ 'prop': 'backgroundGradient - Gradient', 'component': 'Ti.UI.MaskedImage' });
 
 	convertedStyles += `'.bg-gradient': { backgroundGradient: { type: 'linear', startPoint: { x: '50%', y: '100%' }, endPoint: { x: '50%', y: '0%' }, backfillStart: true } }\n`;
 	convertedStyles += `'.bg-gradient-to-t': { backgroundGradient: { type: 'linear', startPoint: { x: '0%', y: '0%' }, endPoint: { x: '0%', y: '100%' }, backfillStart: true } }\n`;
@@ -251,8 +435,50 @@ function linearGradient() {
 }
 exports.linearGradient = linearGradient;
 
+function backgroundBlendMode() {
+	return processProperties({ 'prop': 'mode ( Background Blend Mode )', 'component': 'Ti.UI.MaskedImage' }, {
+		'default': '{ mode: {value} }'
+	}, {
+		'bg-blend': {
+			'default': {
+				'clear': 'Ti.UI.BLEND_MODE_CLEAR',
+				'copy': 'Ti.UI.BLEND_MODE_COPY',
+				'darken': 'Ti.UI.BLEND_MODE_DARKEN',
+				'destination-atop': 'Ti.UI.BLEND_MODE_DESTINATION_ATOP',
+				'destination-in': 'Ti.UI.BLEND_MODE_DESTINATION_IN',
+				'destination-out': 'Ti.UI.BLEND_MODE_DESTINATION_OUT',
+				'destination-over': 'Ti.UI.BLEND_MODE_DESTINATION_OVER',
+				'lighten': 'Ti.UI.BLEND_MODE_LIGHTEN',
+				'multiply': 'Ti.UI.BLEND_MODE_MULTIPLY',
+				'normal': 'Ti.UI.BLEND_MODE_NORMAL',
+				'overlay': 'Ti.UI.BLEND_MODE_OVERLAY',
+				'plus-lighter': 'Ti.UI.BLEND_MODE_PLUS_LIGHTER',
+				'screen': 'Ti.UI.BLEND_MODE_SCREEN',
+				'source-atop': 'Ti.UI.BLEND_MODE_SOURCE_ATOP',
+				'source-in': 'Ti.UI.BLEND_MODE_SOURCE_IN',
+				'source-out': 'Ti.UI.BLEND_MODE_SOURCE_OUT',
+				'xor': 'Ti.UI.BLEND_MODE_XOR',
+			},
+			'ios': {
+				'color': 'Ti.UI.BLEND_MODE_COLOR',
+				'color-burn': 'Ti.UI.BLEND_MODE_COLOR_BURN',
+				'color-dodge': 'Ti.UI.BLEND_MODE_COLOR_DODGE',
+				'diference': 'Ti.UI.BLEND_MODE_DIFFERENCE',
+				'exclusion': 'Ti.UI.BLEND_MODE_EXCLUSION',
+				'hard-light': 'Ti.UI.BLEND_MODE_HARD_LIGHT',
+				'hue': 'Ti.UI.BLEND_MODE_HUE',
+				'luminosity': 'Ti.UI.BLEND_MODE_LUMINOSITY',
+				'plus-darker': 'Ti.UI.BLEND_MODE_PLUS_DARKER',
+				'saturation': 'Ti.UI.BLEND_MODE_SATURATION',
+				'soft-light': 'Ti.UI.BLEND_MODE_SOFT_LIGHT',
+			},
+		}
+	});
+}
+exports.backgroundBlendMode = backgroundBlendMode;
+
 function radialGradient() {
-	let convertedStyles = `\n// Radial backgroundGradient Property [iOS]\n`;
+	let convertedStyles = processComments({ 'prop': 'backgroundGradient: type, startRadius, endRadius, backfillStart, backfillEnd', 'component': 'Ti.UI.ListItem, Ti.UI.View' });
 
 	convertedStyles += `'.bg-radial[platform=ios]': { backgroundGradient: { type: 'radial', startRadius: '125%', endRadius: '0%', backfillStart: true, backfillEnd: true } }\n`;
 	convertedStyles += `'.bg-radial-to-b[platform=ios]': { backgroundGradient: { type: 'radial', startPoint: { x: '50%', y: '0%' }, endPoint: { x: '50%', y: '0%' }, startRadius: '150%', endRadius: '0%', backfillStart: true, backfillEnd: true } }\n`;
@@ -269,7 +495,7 @@ function radialGradient() {
 exports.radialGradient = radialGradient;
 
 function gradientColorStops({ ...modifiersAndValues }) {
-	let convertedStyles = '\n// Gradient Color Stops\n// From Color\n';
+	let convertedStyles = processComments({ 'prop': 'backgroundGradient: colors - From Color', 'component': 'Ti.UI.ListItem, Ti.UI.View' });
 
 	let objectPosition = { 'from': '{ backgroundGradient: { colors: [ {transparentValue}, {value} ] } }' };
 
@@ -285,7 +511,7 @@ function gradientColorStops({ ...modifiersAndValues }) {
 		});
 	});
 
-	convertedStyles += '\n// To Color\n';
+	convertedStyles += processComments({ 'prop': 'backgroundGradient: colors - To Color', 'component': 'Ti.UI.ListItem, Ti.UI.View' });
 
 	objectPosition = { 'to': '{ backgroundGradient: { colors: [ {value} ] } }' };
 
@@ -312,58 +538,254 @@ function fontSize({ ...modifiersAndValues }) {
 		cleanValues[key] = Array.isArray(value) ? value[0] : value;
 	});
 
-	return processModifiersAndProperties('fontSize', { 'text': '{ font: { fontSize: {value} } }' }, cleanValues);
+	return processProperties({ 'prop': 'fontSize', 'component': 'Ti.UI.ActivityIndicator, Ti.UI.Button, Ti.UI.Label, Ti.UI.ListItem, Ti.UI.Picker, Ti.UI.PickerColumn, Ti.UI.PickerRow, Ti.UI.ProgressBar, Ti.UI.Switch, Ti.UI.TableViewRow, Ti.UI.TextArea, Ti.UI.TextField' }, {
+		'text': '{ font: { fontSize: {value} } }'
+	}, cleanValues);
 }
 exports.fontSize = fontSize;
 
-function fontStyle() {
-	let convertedStyles = '\n// fontStyle Property\n';
-	convertedStyles += `'.italic': { font: { fontStyle: 'italic' } }\n`;
-	convertedStyles += `'.not-italic': { font: { fontStyle: 'normal' } }\n`;
+function opacity(modifiersAndValues) {
+	return processProperties({ 'prop': 'opacity', 'component': 'Ti.UI.Animation, Ti.UI.TableViewRow, Ti.UI.View, Ti.UI.Window' }, {
+		'opacity': '{ opacity: {value} }'
+	}, modifiersAndValues);
+}
+exports.opacity = opacity;
 
-	return convertedStyles;
+function fontStyle() {
+	return processProperties({ 'prop': 'fontStyle', 'component': 'Ti.UI.ActivityIndicator, Ti.UI.Button, Ti.UI.Label, Ti.UI.ListItem, Ti.UI.Picker, Ti.UI.PickerColumn, Ti.UI.PickerRow, Ti.UI.ProgressBar, Ti.UI.Switch, Ti.UI.TableViewRow, Ti.UI.TextArea, Ti.UI.TextField' }, {
+		'default': '{ font: { fontStyle: {value} } }'
+	}, {
+		'italic': 'italic',
+		'not-italic': 'normal',
+	});
 }
 exports.fontStyle = fontStyle;
 
-function bounce() {
-	let convertedStyles = '\n// disableBounce Property\n';
-	convertedStyles += `'.enable-bounce': { disableBounce: false }\n`;
-	convertedStyles += `'.disable-bounce': { disableBounce: true }\n`;
+function cacheSize() {
+	return processProperties({ 'prop': 'cacheSize', 'component': 'Ti.UI.ScrollableView' }, {
+		'cache-size': '{ cacheSize: {value} }'
+	}, {
+		1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10
+	});
+}
+exports.cacheSize = cacheSize;
+
+function activityIndicatorStyle() {
+	return processProperties({ 'prop': 'style', 'component': 'Ti.UI.ActivityIndicator' }, {
+		'activity-indicator-style': '{ style: {value} }',
+	}, {
+		'big': 'Ti.UI.ActivityIndicatorStyle.BIG',
+		'dark': 'Ti.UI.ActivityIndicatorStyle.DARK',
+		'big-dark': 'Ti.UI.ActivityIndicatorStyle.BIG_DARK',
+		'plain': 'Ti.UI.ActivityIndicatorStyle.PLAIN'
+	});
+}
+exports.activityIndicatorStyle = activityIndicatorStyle;
+
+function statusBar() {
+	return processProperties({ 'prop': 'statusBarStyle - iOS Only', 'component': 'Ti.UI.Window' }, {
+		'default': '{ statusBarStyle: {value} }'
+	}, {
+		'status-bar': {
+			'ios': {
+				'default': 'Ti.UI.iOS.StatusBar.DEFAULT',
+				'dark': 'Ti.UI.iOS.StatusBar.DARK_CONTENT',
+				'light': 'Ti.UI.iOS.StatusBar.LIGHT_CONTENT',
+			}
+		}
+	});
+}
+exports.statusBar = statusBar;
 
-	return convertedStyles;
+function disableBounce() {
+	return processProperties({ 'prop': 'disableBounce', 'component': 'Ti.UI.ListView, Ti.UI.ScrollableView, Ti.UI.ScrollView, Ti.UI.WebView' }, {
+		'default': '{ disableBounce: {value} }'
+	}, {
+		'disable-bounce': true,
+		'enable-bounce': false,
+	});
 }
-exports.bounce = bounce;
+exports.disableBounce = disableBounce;
 
-function draggingType() {
-	let convertedStyles = '\n// draggingType Property\n';
-	convertedStyles += `'.drag-apply': { draggingType: 'apply' }\n`;
-	convertedStyles += `'.drag-animate': { draggingType: 'animate' }\n`;
+function bubbleParent() {
+	return processProperties({ 'prop': 'bubbleParent', 'component': 'Ti.Proxy' }, {
+		'default': '{ bubbleParent: {value} }'
+	}, {
+		'bubble-parent': true,
+		'dont-bubble-parent': false,
+	});
+}
+exports.bubbleParent = bubbleParent;
 
-	return convertedStyles;
+function draggingType() {
+	return processProperties({ 'prop': 'draggingType', 'component': 'For the Animation Component' }, {
+		'default': '{ draggingType: {value} }'
+	}, {
+		'drag-apply': 'apply',
+		'drag-animate': 'animate',
+	});
 }
 exports.draggingType = draggingType;
 
 function keepScreenOn() {
-	let convertedStyles = '\n// keepScreenOn Property\n';
+	return processProperties({ 'prop': 'keepScreenOn - Android Only', 'component': 'Ti.UI.View' }, {
+		'default': '{ keepScreenOn: {value} }'
+	}, {
+		'keep-screen': {
+			'android': {
+				'on': true,
+			}
+		}
+	});
+}
+exports.keepScreenOn = keepScreenOn;
 
-	convertedStyles += `'.keep-screen-on[platform=android]': { keepScreenOn: true }\n`;
-	convertedStyles += `'.keep-screen-off[platform=android]': { keepScreenOn: false }\n`;
+function largeTitleDisplayMode() {
+	return processProperties({ 'prop': 'largeTitleDisplayMode - iOS Only', 'component': 'Ti.UI.Window' }, {
+		'default': '{ largeTitleDisplayMode: {value} }'
+	}, {
+		'large-title-display': {
+			'ios': {
+				'always': 'Ti.UI.iOS.LARGE_TITLE_DISPLAY_MODE_ALWAYS',
+				'automatic': 'Ti.UI.iOS.LARGE_TITLE_DISPLAY_MODE_AUTOMATIC',
+				'never': 'Ti.UI.iOS.LARGE_TITLE_DISPLAY_MODE_NEVER',
+			}
+		}
+	});
+}
+exports.largeTitleDisplayMode = largeTitleDisplayMode;
 
-	return convertedStyles;
+function autoAdjustScrollViewInsets() {
+	return processProperties({ 'prop': 'autoAdjustScrollViewInsets - iOS Only', 'component': 'Ti.UI.Window' }, {
+		'default': '{ autoAdjustScrollViewInsets: {value} }'
+	}, {
+		'auto-adjust-scroll-view-inset': {
+			'ios': {
+				'default': true,
+			}
+		}
+	});
 }
-exports.keepScreenOn = keepScreenOn;
+exports.autoAdjustScrollViewInsets = autoAdjustScrollViewInsets;
 
-function overlay() {
-	let convertedStyles = '\n// overlayEnabled Property\n';
-	convertedStyles += `'.overlay-enabled[platform=ios]': { overlayEnabled: true }\n`;
-	convertedStyles += `'.overlay-disabled[platform=ios]': { overlayEnabled: false }\n`;
+function largeTitleEnabled() {
+	return processProperties({ 'prop': 'largeTitleEnabled - iOS Only', 'component': 'Ti.UI.Window' }, {
+		'default': '{ largeTitleEnabled: {value} }'
+	}, {
+		'large-title': {
+			'ios': {
+				'enabled': true,
+			}
+		}
+	});
+}
+exports.largeTitleEnabled = largeTitleEnabled;
 
-	return convertedStyles;
+function includeOpaqueBars() {
+	return processProperties({ 'prop': 'includeOpaqueBars - iOS Only', 'component': 'Ti.UI.Window' }, {
+		'default': '{ includeOpaqueBars: {value} }'
+	}, {
+		'include': {
+			'ios': {
+				'opaque-bars': true,
+			}
+		},
+		'exclude': {
+			'ios': {
+				'opaque-bars': false,
+			}
+		}
+	});
+}
+exports.includeOpaqueBars = includeOpaqueBars;
+
+function extendEdges() {
+	return processProperties({ 'prop': 'extendEdges - iOS Only', 'component': 'Ti.UI.Window' }, {
+		'default': '{ extendEdges: {value} }'
+	}, {
+		'extend-edges': {
+			'ios': {
+				'all': '[ Ti.UI.EXTEND_EDGE_ALL ]',
+				'bottom': '[ Ti.UI.EXTEND_EDGE_BOTTOM ]',
+				'left': '[ Ti.UI.EXTEND_EDGE_LEFT ]',
+				'none': '[ Ti.UI.EXTEND_EDGE_NONE ]',
+				'right': '[ Ti.UI.EXTEND_EDGE_RIGHT ]',
+				'top': '[ Ti.UI.EXTEND_EDGE_TOP ]',
+			}
+		}
+	});
+}
+exports.extendEdges = extendEdges;
+
+function extendSafeArea() {
+	return processProperties({ 'prop': 'extendSafeArea', 'component': 'Ti.UI.Window' }, {
+		'default': '{ extendSafeArea: {value} }'
+	}, {
+		'extend-safe-area': true,
+		'dont-extend-safe-area': false,
+	});
+}
+exports.extendSafeArea = extendSafeArea;
+
+function flagSecure() {
+	return processProperties({ 'prop': 'flagSecure', 'component': 'Ti.UI.Window' }, {
+		'default': '{ flagSecure: {value} }'
+	}, {
+		'flag': {
+			'android': {
+				'secure': true,
+				'not-secure': false,
+			}
+		}
+	});
+}
+exports.flagSecure = flagSecure;
+
+function overlay() {
+	return processProperties({ 'prop': 'overlayEnabled', 'component': 'Ti.UI.ScrollableView' }, {
+		'default': '{ overlayEnabled: {value} }'
+	}, {
+		'overlay': {
+			'ios': {
+				'enabled': true,
+			}
+		}
+	});
 }
 exports.overlay = overlay;
 
+function translucent() {
+	return processProperties({ 'prop': 'translucent - iOS Only', 'component': 'Ti.UI.iOS.Toolbar, Ti.UI.TabGroup, Ti.UI.Toolbar, Ti.UI.Window' }, {
+		'default': '{ translucent: {value} }'
+	}, {
+		'translucent': {
+			'ios': {
+				'default': true,
+				'disabled': false,
+			}
+		}
+	});
+}
+exports.translucent = translucent;
+
+function tabsTranslucent() {
+	return processProperties({ 'prop': 'tabsTranslucent - iOS Only', 'component': 'Ti.UI.TabGroup' }, {
+		'default': '{ tabsTranslucent: {value} }'
+	}, {
+		'tabs': {
+			'ios': {
+				'translucent': true,
+				'not-translucent': false,
+			}
+		}
+	});
+}
+exports.tabsTranslucent = tabsTranslucent;
+
 function displayCaps() {
-	let convertedStyles = '\n// displayCaps Property\n';
+	let convertedStyles = '\n// Property(ies): width, height\n';
+	convertedStyles += '// Component(s): Ti.UI.ActivityIndicator, Ti.UI.Animation, Ti.UI.iPad.Popover, Ti.UI.View\n';
+	convertedStyles += '// Description: width and height properties using Ti.Platform.displayCaps platformWidth and platformHeight values\n';
 	convertedStyles += `'.platform-w': { width: Ti.Platform.displayCaps.platformWidth }\n`;
 	convertedStyles += `'.platform-h': { height: Ti.Platform.displayCaps.platformHeight }\n`;
 
@@ -377,112 +799,243 @@ function displayCaps() {
 }
 exports.displayCaps = displayCaps;
 
-function scrolling() {
-	let convertedStyles = '\n// scrollingEnabled Property\n';
-	convertedStyles += `'.scrolling-enabled': { scrollingEnabled: true }\n`;
-	convertedStyles += `'.scrolling-disabled': { scrollingEnabled: false }\n`;
+function scrollingEnabled() {
+	return processProperties({ 'prop': 'scrollingEnabled', 'component': 'Ti.UI.ScrollableView, Ti.UI.ScrollView' }, {
+		'scrolling': '{ scrollingEnabled: {value} }'
+	}, {
+		'enabled': true,
+		'disabled': false,
+	});
+}
+exports.scrollingEnabled = scrollingEnabled;
 
-	return convertedStyles;
+function modal() {
+	return processProperties({ 'prop': 'modal', 'component': 'Ti.UI.Window' }, {
+		'default': '{ modal: {value} }'
+	}, {
+		'modal': true,
+		'regular': false,
+	});
 }
-exports.scrolling = scrolling;
+exports.modal = modal;
 
-function pagingControl() {
-	let convertedStyles = '\n// showPagingControl Property\n';
-	convertedStyles += `'.show-paging': { showPagingControl: true }\n`;
-	convertedStyles += `'.hide-paging': { showPagingControl: false }\n`;
+function fullscreen() {
+	return processProperties({ 'prop': 'fullscreen', 'component': 'Ti.Media.VideoPlayer[android], Ti.UI.TextArea, Ti.UI.TextField, Ti.UI.Window' }, {
+		'default': '{ fullscreen: {value} }'
+	}, {
+		'fullscreen': true,
+		'fullscreen-disabled': false,
+	});
+}
+exports.fullscreen = fullscreen;
 
-	return convertedStyles;
+function hidesBackButton() {
+	return processProperties({ 'prop': 'hidesBackButton', 'component': 'Ti.UI.Window' }, {
+		'default': '{ hidesBackButton: {value} }'
+	}, {
+		'hides-back-button': true,
+		'shows-back-button': false,
+	});
 }
-exports.pagingControl = pagingControl;
+exports.hidesBackButton = hidesBackButton;
 
-function pagingControlOnTop() {
-	let convertedStyles = '\n// pagingControlOnTop Property\n';
-	convertedStyles += `'.paging-on-top': { pagingControlOnTop: true }\n`;
-	convertedStyles += `'.paging-on-bottom': { pagingControlOnTop: false }\n`;
-
-	return convertedStyles;
+function hidesBarsOnSwipe() {
+	return processProperties({ 'prop': 'hidesBarsOnSwipe - iOS Only', 'component': 'Ti.UI.Window' }, {
+		'default': '{ hidesBarsOnSwipe: {value} }'
+	}, {
+		'hides': {
+			'ios': {
+				'bars-on-swipe': true,
+			}
+		},
+		'shows': {
+			'ios': {
+				'bars-on-swipe': false,
+			}
+		}
+	});
 }
-exports.pagingControlOnTop = pagingControlOnTop;
-
-function autoreverse() {
-	let convertedStyles = '\n// autoreverse Property\n';
-	convertedStyles += `'.autoreverse': { autoreverse: true }\n`;
-	convertedStyles += `'.no-autoreverse': { autoreverse: false }\n`;
+exports.hidesBarsOnSwipe = hidesBarsOnSwipe;
 
-	return convertedStyles;
+function hidesBarsOnTap() {
+	return processProperties({ 'prop': 'hidesBarsOnTap - iOS Only', 'component': 'Ti.UI.Window' }, {
+		'default': '{ hidesBarsOnTap: {value} }'
+	}, {
+		'hides': {
+			'ios': {
+				'bars-on-tap': true,
+			}
+		},
+		'shows': {
+			'ios': {
+				'bars-on-tap': false,
+			}
+		}
+	});
 }
-exports.autoreverse = autoreverse;
+exports.hidesBarsOnTap = hidesBarsOnTap;
 
-function transition() {
-	let convertedStyles = '\n// curve Property\n';
-	convertedStyles += `'.ease-in': { curve: Ti.UI.ANIMATION_CURVE_EASE_IN }\n`;
-	convertedStyles += `'.ease-out': { curve: Ti.UI.ANIMATION_CURVE_EASE_OUT }\n`;
-	convertedStyles += `'.ease-linear': { curve: Ti.UI.ANIMATION_CURVE_LINEAR }\n`;
-	convertedStyles += `'.ease-in-out': { curve: Ti.UI.ANIMATION_CURVE_EASE_IN_OUT }\n`;
+function hidesBarsWhenKeyboardAppears() {
+	return processProperties({ 'prop': 'hidesBarsWhenKeyboardAppears - iOS Only', 'component': 'Ti.UI.Window' }, {
+		'default': '{ hidesBarsWhenKeyboardAppears: {value} }'
+	}, {
+		'hides': {
+			'ios': {
+				'bars-when-keyboard-appears': true,
+			}
+		},
+		'shows': {
+			'ios': {
+				'bars-when-keyboard-appears': false,
+			}
+		}
+	});
+}
+exports.hidesBarsWhenKeyboardAppears = hidesBarsWhenKeyboardAppears;
 
-	// '.debug': { debug: true }
-	convertedStyles += '\n// Debug Mode Property\n';
-	convertedStyles += `'.debug-on': { debug: true }\n`;
-	convertedStyles += `'.debug-off': { debug: false }\n`;
+function hideShadow() {
+	return processProperties({ 'prop': 'hideShadow - iOS Only', 'component': 'Ti.UI.Window' }, {
+		'default': '{ hideShadow: {value} }'
+	}, {
+		'hide': {
+			'ios': {
+				'shadow': true,
+			}
+		},
+		'show': {
+			'ios': {
+				'shadow': false,
+			}
+		}
+	});
+}
+exports.hideShadow = hideShadow;
 
-	return convertedStyles;
+function hidesSearchBarWhenScrolling() {
+	return processProperties({ 'prop': 'hidesSearchBarWhenScrolling - iOS Only', 'component': 'Ti.UI.Window' }, {
+		'default': '{ hidesSearchBarWhenScrolling: {value} }'
+	}, {
+		'hides': {
+			'ios': {
+				'search-bar-when-scrolling': true,
+			}
+		},
+		'shows': {
+			'ios': {
+				'search-bar-when-scrolling': false,
+			}
+		}
+	});
 }
-exports.transition = transition;
+exports.hidesSearchBarWhenScrolling = hidesSearchBarWhenScrolling;
 
-function fontWeight({ ...modifiersAndValues }) {
-	const invalidValues = {
-		black: 'bold',
-		medium: 'normal',
-		extrabold: 'bold',
-		hairline: 'ultralight'
-	}
+function homeIndicatorAutoHidden() {
+	return processProperties({ 'prop': 'homeIndicatorAutoHidden - iOS Only', 'component': 'Ti.UI.Window' }, {
+		'default': '{ homeIndicatorAutoHidden: {value} }'
+	}, {
+		'home-indicator-auto-hidden': {
+			'ios': {
+				'default': true,
+			}
+		}
+	});
+}
+exports.homeIndicatorAutoHidden = homeIndicatorAutoHidden;
 
-	_.each(modifiersAndValues, (value, key) => {
-		modifiersAndValues[key] = fixInvalidValues(invalidValues, key);
+function pagingControl() {
+	return processProperties({ 'prop': 'showPagingControl', 'component': 'Ti.UI.ScrollableView' }, {
+		'default': '{ showPagingControl: {value} }'
+	}, {
+		'show-paging-control': true,
 	});
+}
+exports.pagingControl = pagingControl;
 
-	return processModifiersAndProperties('fontWeight', { 'font': '{ font: { fontWeight: {value} } }' }, modifiersAndValues);
+function pagingControlOnTop() {
+	return processProperties({ 'prop': 'pagingControlOnTop', 'component': 'Ti.UI.ScrollableView' }, {
+		'paging-control-on': '{ pagingControlOnTop: {value} }'
+	}, {
+		'top': true,
+		'bottom': false
+	});
 }
-exports.fontWeight = fontWeight;
+exports.pagingControlOnTop = pagingControlOnTop;
 
-function gaps({ ...modifiersAndValues }) {
-	let objectPosition = {
-		'gap': '{ top: {value}, right: {value}, bottom: {value}, left: {value} }',
-		'gap-b': '{ bottom: {value} }',
-		'gap-l': '{ left: {value} }',
-		'gap-r': '{ right: {value} }',
-		'gap-t': '{ top: {value} }',
-		'gap-x': '{ right: {value}, left: {value} }',
-		'gap-y': '{ top: {value}, bottom: {value} }',
-	}
+function autoreverse() {
+	return processProperties({ 'prop': 'autoreverse', 'component': 'Ti.UI.Animation' }, {
+		'default': '{ autoreverse: {value} }'
+	}, {
+		'autoreverse': true,
+	});
+}
+exports.autoreverse = autoreverse;
 
-	// SOME CLEANUP... VALUES NOT NEEDED HERE!.
-	modifiersAndValues = removeFractions(modifiersAndValues);
+function transition() {
+	let convertedStyles = processProperties({ 'prop': 'curve', 'component': 'Ti.UI.Animation' }, {
+		'ease': '{ curve: {value} }'
+	}, {
+		'in': 'Ti.UI.ANIMATION_CURVE_EASE_IN',
+		'out': 'Ti.UI.ANIMATION_CURVE_EASE_OUT',
+		'linear': 'Ti.UI.ANIMATION_CURVE_LINEAR',
+		'in-out': 'Ti.UI.ANIMATION_CURVE_EASE_IN_OUT',
+	});
 
-	modifiersAndValues.auto = 'auto';
-	delete modifiersAndValues.min;
-	delete modifiersAndValues.max;
-	delete modifiersAndValues.screen;
-	delete modifiersAndValues['min-content'];
-	delete modifiersAndValues['max-content'];
+	convertedStyles += processProperties('debug', {
+		'debug': '{ debug: {value} }'
+	}, {
+		'default': true,
+	});
 
-	return processModifiersAndProperties('Gaps', objectPosition, modifiersAndValues);
+	return convertedStyles;
 }
-exports.gaps = gaps;
+exports.transition = transition;
 
 function gridFlow() {
-	const modifiersAndValues = {
+	return processProperties({ 'prop': 'layout', 'component': 'Ti.UI.View', 'description': 'Grid Flow - layout' }, {
+		'grid': '{ layout: {value} }'
+	}, {
 		'default': 'horizontal',
 		'flow-col': 'horizontal',
 		'flow-row': 'vertical',
-	};
-
-	return processModifiersAndProperties('grid and gridFlow', { 'grid': '{ layout: {value} }' }, modifiersAndValues);
+	});
 }
 exports.gridFlow = gridFlow;
 
+function orientationModes() {
+	let convertedStyles = processProperties({ 'prop': 'orientationModes', 'component': 'Ti.UI.Window' }, {
+		'default': '{ orientationModes: {value} }'
+	}, {
+		'orientation': {
+			'default': {
+				'left': '[ Ti.UI.LANDSCAPE_LEFT ]',
+				'right': '[ Ti.UI.LANDSCAPE_RIGHT ]',
+				'portrait': '[ Ti.UI.PORTRAIT ]',
+				'upside-portrait': '[ Ti.UI.UPSIDE_PORTRAIT ]',
+				'landscape': '[ Ti.UI.LANDSCAPE_LEFT, Ti.UI.LANDSCAPE_RIGHT ]',
+			}
+		}
+	});
+
+	convertedStyles += processProperties({ 'prop': 'orientationModes (Alternative)', 'component': 'Ti.UI.Window' }, {
+		'default': '{ orientationModes: {value} }'
+	}, {
+		'portrait': '[ Ti.UI.PORTRAIT ]',
+		'upside-portrait': '[ Ti.UI.UPSIDE_PORTRAIT ]',
+		'landscape-left': '[ Ti.UI.LANDSCAPE_LEFT ]',
+		'landscape-right': '[ Ti.UI.LANDSCAPE_RIGHT ]',
+		'landscape': '[ Ti.UI.LANDSCAPE_LEFT, Ti.UI.LANDSCAPE_RIGHT ]',
+	});
+
+	return convertedStyles;
+}
+exports.orientationModes = orientationModes;
+
 function items() {
-	let convertedStyles = '\n// items Property\n';
+	let convertedStyles = processComments({
+		prop: 'top, bottom, width(FILL), height(FILL)',
+		component: 'Ti.UI.ActivityIndicator, Ti.UI.Animaiton, Ti.UI.View, Ti.UI.Window',
+		description: 'top, bottom, width, height properties for aligning items in a Grid System',
+	});
 	convertedStyles += `'.items-start': { top: 0 }\n`;
 	convertedStyles += `'.items-end': { bottom: 0 }\n`;
 	convertedStyles += `'.items-center': { width: Ti.UI.FILL, height: Ti.UI.FILL }\n`;
@@ -491,18 +1044,22 @@ function items() {
 }
 exports.items = items;
 
-
 function clipMode() {
-	let convertedStyles = '\n// clipMode Property\n';
-	convertedStyles += `'.clip-enabled[platform=ios]': { clipMode: Ti.UI.iOS.CLIP_MODE_ENABLED }\n`;
-	convertedStyles += `'.clip-disabled[platform=ios]': { clipMode: Ti.UI.iOS.CLIP_MODE_DISABLED }\n`;
-
-	return convertedStyles;
+	return processProperties({ 'prop': 'clipMode - iOS Only', 'component': 'Ti.UI.View' }, {
+		'default': '{ clipMode: {value} }'
+	}, {
+		'clip': {
+			'ios': {
+				'enabled': 'Ti.UI.iOS.CLIP_MODE_ENABLED',
+				'disabled': 'Ti.UI.iOS.CLIP_MODE_DISABLED',
+			}
+		}
+	});
 }
 exports.clipMode = clipMode;
 
 function exitOnClose() {
-	let convertedStyles = '\n// exitOnClose Property\n';
+	let convertedStyles = processComments({ 'prop': 'exitOnClose', 'component': 'Ti.UI.TabGroup[android], Ti.UI.Window[android]' });
 	convertedStyles += `'.exit-on-close[platform=android]': { exitOnClose: true }\n`;
 	convertedStyles += `'.dont-exit-on-close[platform=android]': { exitOnClose: false }\n`;
 
@@ -511,25 +1068,62 @@ function exitOnClose() {
 exports.exitOnClose = exitOnClose;
 
 function layout() {
-	let convertedStyles = '\n// layout Property\n';
-	convertedStyles += `'.vertical': { layout: 'vertical' }\n`;
-	convertedStyles += `'.horizontal': { layout: 'horizontal' }\n`;
-
-	return convertedStyles;
+	return processProperties({ 'prop': 'layout', 'component': 'Ti.UI.OptionBar, Ti.UI.View' }, {
+		'default': '{ layout: {value} }'
+	}, {
+		'horizontal': 'horizontal',
+		'vertical': 'vertical',
+	});
 }
 exports.layout = layout;
 
 function scrollType() {
-	let convertedStyles = '\n// scrollType Property\n';
-	convertedStyles += `'.scroll-horizontal[platform=android]': { scrollType: 'horizontal' }\n`;
-	convertedStyles += `'.scroll-vertical[platform=android]': { scrollType: 'vertical' }\n`;
-
-	return convertedStyles;
+	return processProperties({ 'prop': 'scrollType', 'component': 'Ti.UI.ScrollView' }, {
+		'default': '{ scrollType: {value} }'
+	}, {
+		'scroll': {
+			'android': {
+				'horizontal': 'horizontal',
+				'vertical': 'vertical',
+			}
+		}
+	});
 }
 exports.scrollType = scrollType;
 
+function sustainedPerformanceMode() {
+	return processProperties({ 'prop': 'sustainedPerformanceMode', 'component': 'Ti.UI.Window' }, {
+		'default': '{ sustainedPerformanceMode: {value} }'
+	}, {
+		'sustained-performance-mode': {
+			'android': {
+				'default': true,
+			}
+		}
+	});
+}
+exports.sustainedPerformanceMode = sustainedPerformanceMode;
+
+function swipeToClose() {
+	return processProperties({ 'prop': 'swipeToClose', 'component': 'Ti.UI.Window' }, {
+		'default': '{ swipeToClose: {value} }'
+	}, {
+		'swipe-to-close': {
+			'ios': {
+				'default': true,
+			}
+		},
+		'dont-swipe-to-close': {
+			'ios': {
+				'default': false,
+			}
+		}
+	});
+}
+exports.swipeToClose = swipeToClose;
+
 function preventDefaultImage() {
-	let convertedStyles = '\n// preventDefaultImage Property\n';
+	let convertedStyles = processComments({ 'prop': 'preventDefaultImage - iOS Only', 'component': 'Ti.UI.ImageView' });
 	convertedStyles += `'.prevent-default-image[platform=ios]': { preventDefaultImage: true }\n`;
 	convertedStyles += `'.display-default-image[platform=ios]': { preventDefaultImage: false }\n`;
 
@@ -540,42 +1134,121 @@ exports.preventDefaultImage = preventDefaultImage;
 function tiMedia() {
 	let convertedStyles = '\n// Ti.Media';
 
-	convertedStyles += processModifiersAndProperties('audioSessionCategory', { 'audio-session': '{ audioSessionCategory: {value} }' }, {
-		record: 'Ti.Media.AUDIO_SESSION_CATEGORY_RECORD',
-		ambient: 'Ti.Media.AUDIO_SESSION_CATEGORY_AMBIENT',
-		playback: 'Ti.Media.AUDIO_SESSION_CATEGORY_PLAYBACK',
-		'solo-ambient': 'Ti.Media.AUDIO_SESSION_CATEGORY_SOLO_AMBIENT',
-		'play-record': 'Ti.Media.AUDIO_SESSION_CATEGORY_PLAY_AND_RECORD',
+	convertedStyles += processProperties({
+		'prop': 'audioSessionCategory - iOS Only',
+		'component': 'Ti.Media'
+	}, {
+		'audio': '{ audioSessionCategory: {value} }'
+	}, {
+		'sesion': {
+			'ios': {
+				'record': 'Ti.Media.AUDIO_SESSION_CATEGORY_RECORD',
+				'ambient': 'Ti.Media.AUDIO_SESSION_CATEGORY_AMBIENT',
+				'playback': 'Ti.Media.AUDIO_SESSION_CATEGORY_PLAYBACK',
+				'solo-ambient': 'Ti.Media.AUDIO_SESSION_CATEGORY_SOLO_AMBIENT',
+				'play-record': 'Ti.Media.AUDIO_SESSION_CATEGORY_PLAY_AND_RECORD',
+			}
+		}
+	});
+
+	convertedStyles += processProperties({
+		'prop': 'audioType',
+		'component': 'Ti.Media.AudioPlayer[android], Ti.Media.Sound[android]'
+	}, {
+		'audio': '{ audioType: {value} }'
+	}, {
+		'type': {
+			'android': {
+				'ring': 'Ti.Media.Sound.AUDIO_TYPE_RING',
+				'alarm': 'Ti.Media.Sound.AUDIO_TYPE_ALARM',
+				'media': 'Ti.Media.Sound.AUDIO_TYPE_MEDIA',
+				'voice': 'Ti.Media.Sound.AUDIO_TYPE_VOICE',
+				'signalling': 'Ti.Media.Sound.AUDIO_TYPE_SIGNALLING',
+				'notification': 'Ti.Media.Sound.AUDIO_TYPE_NOTIFICATION',
+			}
+		}
+	});
+
+	convertedStyles += processProperties({
+		'prop': 'repeatMode - iOS Only',
+		'component': 'Ti.Media.MusicPlayer'
+	}, {
+		'music': '{ repeatMode: {value} }'
+	}, {
+		'repeat': {
+			'ios': {
+				'all': 'Ti.Media.MUSIC_PLAYER_REPEAT_ALL',
+				'default': 'Ti.Media.MUSIC_PLAYER_REPEAT_DEFAULT',
+				'none': 'Ti.Media.MUSIC_PLAYER_REPEAT_NONE',
+				'one': 'Ti.Media.MUSIC_PLAYER_REPEAT_ONE',
+			}
+		}
 	});
 
-	convertedStyles += processModifiersAndProperties('audioType', { 'audio-type': '{ audioType: {value} }' }, {
-		ring: 'Ti.Media.Sound.AUDIO_TYPE_RING',
-		alarm: 'Ti.Media.Sound.AUDIO_TYPE_ALARM',
-		media: 'Ti.Media.Sound.AUDIO_TYPE_MEDIA',
-		voice: 'Ti.Media.Sound.AUDIO_TYPE_VOICE',
-		signalling: 'Ti.Media.Sound.AUDIO_TYPE_SIGNALLING',
-		notification: 'Ti.Media.Sound.AUDIO_TYPE_NOTIFICATION',
+	convertedStyles += processProperties({
+		'prop': 'shuffleMode - iOS Only',
+		'component': 'Ti.Media.MusicPlayer'
+	}, {
+		'music': '{ shuffleMode: {value} }'
+	}, {
+		'shuffle': {
+			'ios': {
+				'albums': 'Ti.Media.MUSIC_PLAYER_SHUFFLE_ALBUMS',
+				'default': 'Ti.Media.MUSIC_PLAYER_SHUFFLE_DEFAULT',
+				'none': 'Ti.Media.MUSIC_PLAYER_SHUFFLE_NONE',
+				'songs': 'Ti.Media.MUSIC_PLAYER_SHUFFLE_SONGS',
+			}
+		}
 	});
 
-	convertedStyles += processModifiersAndProperties('Background Size ( for compatibility with Tailwind’s classes )', { 'bg': '{ scalingMode: {value} }' }, {
-		auto: 'Ti.Media.IMAGE_SCALING_NONE',
-		cover: 'Ti.Media.IMAGE_SCALING_ASPECT_FILL',
-		contain: 'Ti.Media.IMAGE_SCALING_ASPECT_FIT'
+	convertedStyles += processProperties({
+		'prop': 'scalingMode',
+		'component': 'Ti.UI.ImageView',
+		'description': 'Background Size for compatibility with Tailwind classes'
+	}, {
+		'bg': '{ scalingMode: {value} }'
+	}, {
+		'auto': 'Ti.Media.IMAGE_SCALING_NONE',
+		'cover': 'Ti.Media.IMAGE_SCALING_ASPECT_FILL',
+		'contain': 'Ti.Media.IMAGE_SCALING_ASPECT_FIT'
 	});
 
-	convertedStyles += processModifiersAndProperties('Image Scaling Mode', { 'image-scaling': '{ scalingMode: {value} }' }, {
-		auto: 'Ti.Media.IMAGE_SCALING_AUTO',
-		none: 'Ti.Media.IMAGE_SCALING_NONE',
-		fill: 'Ti.Media.IMAGE_SCALING_FILL',
-		cover: 'Ti.Media.IMAGE_SCALING_ASPECT_FILL',
-		contain: 'Ti.Media.IMAGE_SCALING_ASPECT_FIT',
+	convertedStyles += processProperties({
+		'prop': 'scalingMode',
+		'component': 'Ti.UI.ImageView',
+		'description': 'Image Scaling Mode'
+	}, {
+		'image-scaling': '{ scalingMode: {value} }'
+	}, {
+		'auto': 'Ti.Media.IMAGE_SCALING_AUTO',
+		'none': 'Ti.Media.IMAGE_SCALING_NONE',
+		'fill': 'Ti.Media.IMAGE_SCALING_FILL',
+		'cover': 'Ti.Media.IMAGE_SCALING_ASPECT_FILL',
+		'contain': 'Ti.Media.IMAGE_SCALING_ASPECT_FIT',
 	});
 
 	// Video Scaling Mode
-	convertedStyles += processModifiersAndProperties('Video Scaling Mode', { 'video-scaling': '{ scalingMode: {value} }' }, {
-		resize: 'Ti.Media.VIDEO_SCALING_RESIZE',
-		contain: 'Ti.Media.VIDEO_SCALING_RESIZE_ASPECT',
-		cover: 'Ti.Media.VIDEO_SCALING_RESIZE_ASPECT_FILL'
+	convertedStyles += processProperties({
+		'prop': 'scalingMode',
+		'component': 'Ti.Media.VideoPlayer',
+		'description': 'Video Scaling Mode'
+	}, {
+		'video-scaling': '{ scalingMode: {value} }'
+	}, {
+		'resize': 'Ti.Media.VIDEO_SCALING_RESIZE',
+		'contain': 'Ti.Media.VIDEO_SCALING_RESIZE_ASPECT',
+		'cover': 'Ti.Media.VIDEO_SCALING_RESIZE_ASPECT_FILL'
+	});
+
+	convertedStyles += processProperties({
+		'prop': 'repeatMode',
+		'component': 'Ti.Media.VideoPlayer',
+		'description': 'Determines how the movie player repeats when reaching the end of playback.'
+	}, {
+		'video-repeat': '{ repeatMode: {value} }'
+	}, {
+		'one': 'Ti.Media.VIDEO_REPEAT_MODE_ONE',
+		'none': 'Ti.Media.VIDEO_REPEAT_MODE_NONE',
 	});
 
 	return convertedStyles;
@@ -583,244 +1256,430 @@ function tiMedia() {
 exports.tiMedia = tiMedia;
 
 function autocapitalization() {
-	let convertedStyles = '\n// autocapitalization Property\n';
-
-	convertedStyles += `'.uppercase': { autocapitalization: Ti.UI.TEXT_AUTOCAPITALIZATION_ALL }\n`;
-	convertedStyles += `'.normal-case': { autocapitalization: Ti.UI.TEXT_AUTOCAPITALIZATION_NONE }\n`;
-	convertedStyles += `'.capitalize': { autocapitalization: Ti.UI.TEXT_AUTOCAPITALIZATION_WORDS }\n`;
-	convertedStyles += `'.sentences': { autocapitalization: Ti.UI.TEXT_AUTOCAPITALIZATION_SENTENCES }\n`;
-
-	return convertedStyles;
+	return processProperties({ 'prop': 'autocapitalization', 'component': 'Ti.UI.SearchBar, Ti.UI.TextArea, Ti.UI.TextField' }, {
+		'default': '{ autocapitalization: {value} }'
+	}, {
+		'uppercase': 'Ti.UI.TEXT_AUTOCAPITALIZATION_ALL',
+		'normal-case': 'Ti.UI.TEXT_AUTOCAPITALIZATION_NONE',
+		'capitalize': 'Ti.UI.TEXT_AUTOCAPITALIZATION_WORDS',
+		'sentences': 'Ti.UI.TEXT_AUTOCAPITALIZATION_SENTENCES',
+	});
 }
 exports.autocapitalization = autocapitalization;
 
 function showCancel() {
-	let convertedStyles = '\n// showCancel Property\n';
-
-	convertedStyles += `'.show-cancel': { showCancel: true }\n`;
-	convertedStyles += `'.hide-cancel': { showCancel: false }\n`;
-
-	return convertedStyles;
+	return processProperties({ 'prop': 'showCancel', 'component': 'Ti.UI.SearchBar' }, {
+		'default': '{ showCancel: {value} }'
+	}, {
+		'show-cancel': true,
+	});
 }
 exports.showCancel = showCancel;
 
-function gridFlow() {
-	const modifiersAndValues = {
-		'default': 'horizontal',
-		'flow-col': 'horizontal',
-		'flow-row': 'vertical',
-	};
-
-	return processModifiersAndProperties('grid and gridFlow', { 'grid': '{ layout: {value} }' }, modifiersAndValues);
+function loginKeyboardType() {
+	return processProperties({ 'prop': 'loginKeyboardType', 'component': 'Ti.UI.AlertDialog' }, {
+		'login-keyboard': '{ loginKeyboardType: {value} }'
+	}, {
+		'default': 'Ti.UI.KEYBOARD_TYPE_DEFAULT',
+		'appearance': 'Ti.UI.KEYBOARD_APPEARANCE_DEFAULT',
+		'appearance-dark': 'Ti.UI.KEYBOARD_APPEARANCE_DARK',
+		'appearance-light': 'Ti.UI.KEYBOARD_APPEARANCE_LIGHT',
+		'ascii': 'Ti.UI.KEYBOARD_TYPE_ASCII',
+		'decimal-pad': 'Ti.UI.KEYBOARD_TYPE_DECIMAL_PAD',
+		'email': 'Ti.UI.KEYBOARD_TYPE_EMAIL',
+		'namephone-pad': 'Ti.UI.KEYBOARD_TYPE_NAMEPHONE_PAD',
+		'number-pad': 'Ti.UI.KEYBOARD_TYPE_NUMBER_PAD',
+		'numbers-punctuation': 'Ti.UI.KEYBOARD_TYPE_NUMBERS_PUNCTUATION',
+		'phone-pad': 'Ti.UI.KEYBOARD_TYPE_PHONE_PAD',
+		'twitter': 'Ti.UI.KEYBOARD_TYPE_TWITTER',
+		'url': 'Ti.UI.KEYBOARD_TYPE_URL',
+		'websearch': 'Ti.UI.KEYBOARD_TYPE_WEBSEARCH',
+	});
 }
-exports.gridFlow = gridFlow;
+exports.loginKeyboardType = loginKeyboardType;
 
 function keyboardAppearance() {
-	let convertedStyles = '\n// keyboardAppearance Property\n';
-
-	convertedStyles += `'.keyboard-appearance-dark[platform=ios]': { keyboardAppearance: Ti.UI.KEYBOARD_APPEARANCE_DARK }\n`;
-	convertedStyles += `'.keyboard-appearance-light[platform=ios]': { keyboardAppearance: Ti.UI.KEYBOARD_APPEARANCE_LIGHT }\n`;
-	convertedStyles += `'.keyboard-appearance-default[platform=ios]': { keyboardAppearance: Ti.UI.KEYBOARD_APPEARANCE_DEFAULT }\n`;
-
-	return convertedStyles;
+	return processProperties({ 'prop': 'keyboardAppearance - iOS Only', 'component': 'Ti.UI.AlertDialog, Ti.UI.SearchBar, Ti.UI.TextArea, Ti.UI.TextField' }, {
+		'keyboard': '{ keyboardAppearance: {value} }'
+	}, {
+		'appearance': {
+			'ios': {
+				'default': 'Ti.UI.KEYBOARD_APPEARANCE_DEFAULT',
+				'dark': 'Ti.UI.KEYBOARD_APPEARANCE_DARK',
+				'light': 'Ti.UI.KEYBOARD_APPEARANCE_LIGHT'
+			}
+		}
+	});
 }
 exports.keyboardAppearance = keyboardAppearance;
 
-function keyboardType() {
-	let convertedStyles = '\n// keyboardType Property\n';
-
-	convertedStyles += `'.keyboard-type-url': { keyboardType: Ti.UI.KEYBOARD_TYPE_URL }\n`;
-	convertedStyles += `'.keyboard-type-ascii': { keyboardType: Ti.UI.KEYBOARD_TYPE_ASCII }\n`;
-	convertedStyles += `'.keyboard-type-email': { keyboardType: Ti.UI.KEYBOARD_TYPE_EMAIL }\n`;
-	convertedStyles += `'.keyboard-type-default': { keyboardType: Ti.UI.KEYBOARD_TYPE_DEFAULT }\n`;
-	convertedStyles += `'.keyboard-type-twitter': { keyboardType: Ti.UI.KEYBOARD_TYPE_TWITTER }\n`;
-	convertedStyles += `'.keyboard-type-phone-pad': { keyboardType: Ti.UI.KEYBOARD_TYPE_PHONE_PAD }\n`;
-	convertedStyles += `'.keyboard-type-websearch': { keyboardType: Ti.UI.KEYBOARD_TYPE_WEBSEARCH }\n`;
-	convertedStyles += `'.keyboard-type-number-pad': { keyboardType: Ti.UI.KEYBOARD_TYPE_NUMBER_PAD }\n`;
-	convertedStyles += `'.keyboard-type-decimal-pad': { keyboardType: Ti.UI.KEYBOARD_TYPE_DECIMAL_PAD }\n`;
-	convertedStyles += `'.keyboard-type-namephone-pad': { keyboardType: Ti.UI.KEYBOARD_TYPE_NAMEPHONE_PAD }\n`;
-	convertedStyles += `'.keyboard-type-numbers-punctuation': { keyboardType: Ti.UI.KEYBOARD_TYPE_NUMBERS_PUNCTUATION }\n`;
-
-	//
-	// convertedStyles += '\n';
-	// convertedStyles += `'.keyboard-appearance-dark[platform=android]': { keyboardType: Ti.UI.KEYBOARD_APPEARANCE_DARK }\n`;
-	// convertedStyles += `'.keyboard-appearance-light[platform=android]': { keyboardType: Ti.UI.KEYBOARD_APPEARANCE_LIGHT }\n`;
-	// convertedStyles += `'.keyboard-appearance-default[platform=android]': { keyboardType: Ti.UI.KEYBOARD_APPEARANCE_DEFAULT }\n`;
+function keyboardDismissMode() {
+	return processProperties({ 'prop': 'keyboardDismissMode - iOS Only', 'component': 'Ti.UI.AlertDialog, Ti.UI.SearchBar, Ti.UI.TextArea, Ti.UI.TextField' }, {
+		'keyboard': '{ keyboardDismissMode: {value} }'
+	}, {
+		'dismiss': {
+			'ios': {
+				'interactive': 'Ti.UI.iOS.KEYBOARD_DISMISS_MODE_INTERACTIVE',
+				'none': 'Ti.UI.iOS.KEYBOARD_DISMISS_MODE_NONE',
+				'on-drag': 'Ti.UI.iOS.KEYBOARD_DISMISS_MODE_ON_DRAG',
+			}
+		}
+	});
+}
+exports.keyboardDismissMode = keyboardDismissMode;
 
-	return convertedStyles;
+function keyboardType() {
+	return processProperties({ 'prop': 'keyboardType', 'component': 'Ti.UI.AlertDialog, Ti.UI.SearchBar, Ti.UI.TextArea, Ti.UI.TextField' }, {
+		'keyboard': '{ keyboardType: {value} }'
+	}, {
+		'type': {
+			'default': {
+				'default': 'Ti.UI.KEYBOARD_TYPE_DEFAULT',
+				'ascii': 'Ti.UI.KEYBOARD_TYPE_ASCII',
+				'decimal-pad': 'Ti.UI.KEYBOARD_TYPE_DECIMAL_PAD',
+				'email': 'Ti.UI.KEYBOARD_TYPE_EMAIL',
+				'namephone-pad': 'Ti.UI.KEYBOARD_TYPE_NAMEPHONE_PAD',
+				'number-pad': 'Ti.UI.KEYBOARD_TYPE_NUMBER_PAD',
+				'numbers-punctuation': 'Ti.UI.KEYBOARD_TYPE_NUMBERS_PUNCTUATION',
+				'phone-pad': 'Ti.UI.KEYBOARD_TYPE_PHONE_PAD',
+				'url': 'Ti.UI.KEYBOARD_TYPE_URL'
+			},
+			'ios': {
+				'appearance': 'Ti.UI.KEYBOARD_APPEARANCE_DEFAULT',
+				'appearance-dark': 'Ti.UI.KEYBOARD_APPEARANCE_DARK',
+				'appearance-light': 'Ti.UI.KEYBOARD_APPEARANCE_LIGHT',
+				'twitter': 'Ti.UI.KEYBOARD_TYPE_TWITTER',
+				'websearch': 'Ti.UI.KEYBOARD_TYPE_WEBSEARCH'
+			}
+		}
+	});
 }
 exports.keyboardType = keyboardType;
 
-function draggingConstraints() {
-	let convertedStyles = '\n// Constraint Property\n';
-
-	convertedStyles += `'.vertical-constraint': { constraint: 'vertical' }\n`;
-	convertedStyles += `'.horizontal-constraint': { constraint: 'horizontal' }\n`;
+function passwordKeyboardType() {
+	return processProperties({ 'prop': 'passwordKeyboardType', 'component': 'Ti.UI.AlertDialog' }, {
+		'password': '{ passwordKeyboardType: {value} }'
+	}, {
+		'keyboard': {
+			'default': {
+				'default': 'Ti.UI.KEYBOARD_TYPE_DEFAULT',
+				'ascii': 'Ti.UI.KEYBOARD_TYPE_ASCII',
+				'decimal-pad': 'Ti.UI.KEYBOARD_TYPE_DECIMAL_PAD',
+				'email': 'Ti.UI.KEYBOARD_TYPE_EMAIL',
+				'namephone-pad': 'Ti.UI.KEYBOARD_TYPE_NAMEPHONE_PAD',
+				'number-pad': 'Ti.UI.KEYBOARD_TYPE_NUMBER_PAD',
+				'numbers-punctuation': 'Ti.UI.KEYBOARD_TYPE_NUMBERS_PUNCTUATION',
+				'phone-pad': 'Ti.UI.KEYBOARD_TYPE_PHONE_PAD',
+				'url': 'Ti.UI.KEYBOARD_TYPE_URL'
+			},
+			'ios': {
+				'appearance': 'Ti.UI.KEYBOARD_APPEARANCE_DEFAULT',
+				'appearance-dark': 'Ti.UI.KEYBOARD_APPEARANCE_DARK',
+				'appearance-light': 'Ti.UI.KEYBOARD_APPEARANCE_LIGHT',
+				'twitter': 'Ti.UI.KEYBOARD_TYPE_TWITTER',
+				'websearch': 'Ti.UI.KEYBOARD_TYPE_WEBSEARCH'
+			}
+		}
+	});
+}
+exports.passwordKeyboardType = passwordKeyboardType;
 
-	return convertedStyles;
+function draggingConstraints() {
+	return processProperties({
+		'prop': 'A custom property to use it with the Animation module',
+		'component': 'Ti.UI.Animation',
+	}, {
+		'default': '{ constraint: {value} }'
+	}, {
+		'horizontal-constraint': 'horizontal',
+		'vertical-constraint': 'vertical',
+	});
 }
 exports.draggingConstraints = draggingConstraints;
 
-function autocorrect() {
-	let convertedStyles = '\n// autocorrect Property\n';
-
-	convertedStyles += `'.autocorrect': { autocorrect: true }\n`;
-	convertedStyles += `'.no-autocorrect': { autocorrect: false }\n`;
+function navBarHidden() {
+	return processProperties({ 'prop': 'navBarHidden', 'component': 'Ti.UI.Window' }, {
+		'default': '{ navBarHidden: {value} }'
+	}, {
+		'nav-bar-hidden': true,
+		'nav-bar-visible': false,
+	});
+}
+exports.navBarHidden = navBarHidden;
 
-	return convertedStyles;
+function autocorrect() {
+	return processProperties({ 'prop': 'autocorrect', 'component': 'Ti.UI.SearchBar, Ti.UI.TextArea, Ti.UI.TextField' }, {
+		'default': '{ autocorrect: {value} }'
+	}, {
+		'autocorrect': true,
+		'no-autocorrect': false,
+	});
 }
 exports.autocorrect = autocorrect;
 
 function editable() {
-	let convertedStyles = '\n// editable Property\n';
-
-	convertedStyles += `'.editable': { editable: true }\n`;
-	convertedStyles += `'.none-editable': { editable: false }\n`;
-
-	return convertedStyles;
+	return processProperties({ 'prop': 'editable', 'component': 'Ti.UI.DashboardView, Ti.UI.SearchBar, Ti.UI.TextArea, Ti.UI.TextField' }, {
+		'default': '{ editable: {value} }'
+	}, {
+		'editable': true,
+		'none-editable': false,
+	});
 }
 exports.editable = editable;
 
 function ellipsize() {
-	let convertedStyles = '\n// ellipsize Property\n';
+	let convertedStyles = processProperties({ 'prop': 'ellipsize', 'component': 'Ti.UI.Label' }, {
+		'ellipsize': '{ ellipsize: {value} }'
+	}, {
+		'end': 'Ti.UI.TEXT_ELLIPSIZE_TRUNCATE_END',
+		'clip': 'Ti.UI.TEXT_ELLIPSIZE_TRUNCATE_CLIP',
+		'none': 'Ti.UI.TEXT_ELLIPSIZE_TRUNCATE_NONE',
+		'start': 'Ti.UI.TEXT_ELLIPSIZE_TRUNCATE_START',
+		'middle': 'Ti.UI.TEXT_ELLIPSIZE_TRUNCATE_MIDDLE',
+		'marquee': 'Ti.UI.TEXT_ELLIPSIZE_TRUNCATE_MARQUEE',
+		'char-wrap': 'Ti.UI.TEXT_ELLIPSIZE_TRUNCATE_CHAR_WRAP',
+		'word-wrap': 'Ti.UI.TEXT_ELLIPSIZE_TRUNCATE_WORD_WRAP'
+	});
+
+	// for Labels
+	convertedStyles += processProperties({ 'prop': 'ellipsize', 'component': 'Ti.UI.TextArea, Ti.UI.TextField' });
 
 	convertedStyles += `'.ellipsize': { ellipsize: true }\n`;
 	convertedStyles += `'.no-ellipsize': { ellipsize: false }\n`;
 
-	// for Labels
-	convertedStyles += '\n// ellipsize Property ( for Labels )\n';
-	convertedStyles += `'.ellipsize-end': { ellipsize: Ti.UI.TEXT_ELLIPSIZE_TRUNCATE_END }\n`;
-	convertedStyles += `'.ellipsize-clip': { ellipsize: Ti.UI.TEXT_ELLIPSIZE_TRUNCATE_CLIP }\n`;
-	convertedStyles += `'.ellipsize-none': { ellipsize: Ti.UI.TEXT_ELLIPSIZE_TRUNCATE_NONE }\n`;
-	convertedStyles += `'.ellipsize-start': { ellipsize: Ti.UI.TEXT_ELLIPSIZE_TRUNCATE_START }\n`;
-	convertedStyles += `'.ellipsize-middle': { ellipsize: Ti.UI.TEXT_ELLIPSIZE_TRUNCATE_MIDDLE }\n`;
-	convertedStyles += `'.ellipsize-marquee': { ellipsize: Ti.UI.TEXT_ELLIPSIZE_TRUNCATE_MARQUEE }\n`;
-	convertedStyles += `'.ellipsize-char-wrap': { ellipsize: Ti.UI.TEXT_ELLIPSIZE_TRUNCATE_CHAR_WRAP }\n`;
-	convertedStyles += `'.ellipsize-word-wrap': { ellipsize: Ti.UI.TEXT_ELLIPSIZE_TRUNCATE_WORD_WRAP }\n`;
-
 	return convertedStyles;
 }
 exports.ellipsize = ellipsize;
 
 function enableCopy() {
-	let convertedStyles = '\n// enableCopy Property\n';
-
-	convertedStyles += `'.enable-copy': { enableCopy: true }\n`;
-	convertedStyles += `'.disable-copy': { enableCopy: false }\n`;
-
-	return convertedStyles;
+	return processProperties({ 'prop': 'enableCopy', 'component': 'Ti.UI.TextArea, Ti.UI.TextField' }, {
+		'default': '{ enableCopy: {value} }'
+	}, {
+		'enable-copy': true,
+		'disable-copy': false,
+	});
 }
 exports.enableCopy = enableCopy;
 
 function enableReturnKey() {
-	let convertedStyles = '\n// enableReturnKey Property\n';
-
-	convertedStyles += `'.enable-return-key': { enableReturnKey: true }\n`;
-	convertedStyles += `'.disable-return-key': { enableReturnKey: false }\n`;
-
-	return convertedStyles;
+	return processProperties({ 'prop': 'enableReturnKey - iOS Only', 'component': 'Ti.UI.TextArea, Ti.UI.TextField' }, {
+		'default': '{ enableReturnKey: {value} }'
+	}, {
+		'enable': {
+			'ios': {
+				'return-key': true,
+			}
+		},
+		'disable': {
+			'ios': {
+				'return-key': false,
+			}
+		}
+	});
 }
 exports.enableReturnKey = enableReturnKey;
 
 function extendBackground() {
-	let convertedStyles = '\n// extendBackground Property\n';
-
-	convertedStyles += `'.extend-background': { extendBackground: true }\n`;
-	convertedStyles += `'.no-extend-background': { extendBackground: false }\n`;
-
-	return convertedStyles;
+	return processProperties({ 'prop': 'extendBackground', 'component': 'Ti.UI.Toolbar' }, {
+		'default': '{ extendBackground: {value} }'
+	}, {
+		'extend-background': true,
+		'dont-extend-background': false,
+	});
 }
 exports.extendBackground = extendBackground;
 
 function autoLink() {
-	let convertedStyles = '\n// autoLink Property\n';
-
-	convertedStyles += `'.autolink-all': { autoLink: Ti.UI.AUTOLINK_ALL }\n`;
-	convertedStyles += `'.autolink-none': { autoLink: Ti.UI.AUTOLINK_NONE }\n`;
-	convertedStyles += `'.autolink-urls': { autoLink: Ti.UI.AUTOLINK_URLS }\n`;
-	convertedStyles += `'.autolink-calendar': { autoLink: Ti.UI.AUTOLINK_CALENDAR }\n`;
-	convertedStyles += `'.autolink-map-addresses': { autoLink: Ti.UI.AUTOLINK_MAP_ADDRESSES }\n`;
-	convertedStyles += `'.autolink-phone-numbers': { autoLink: Ti.UI.AUTOLINK_PHONE_NUMBERS }\n`;
-	convertedStyles += `'.autolink-email-addresses': { autoLink: Ti.UI.AUTOLINK_EMAIL_ADDRESSES }\n`;
-
-	return convertedStyles;
+	return processProperties({ 'prop': 'autoLink', 'component': 'Ti.UI.Label, Ti.UI.TextArea, Ti.UI.TextField' }, {
+		'auto': '{ autoLink: {value} }'
+	}, {
+		'link': {
+			default: {
+				'all': 'Ti.UI.AUTOLINK_ALL',
+				'email-addresses': 'Ti.UI.AUTOLINK_EMAIL_ADDRESSES',
+				'map-addresses': 'Ti.UI.AUTOLINK_MAP_ADDRESSES',
+				'none': 'Ti.UI.AUTOLINK_NONE',
+				'phone-numbers': 'Ti.UI.AUTOLINK_PHONE_NUMBERS',
+				'urls': 'Ti.UI.AUTOLINK_URLS',
+			},
+			ios: {
+				'calendar': 'Ti.UI.AUTOLINK_CALENDAR',
+			},
+		}
+	});
 }
 exports.autoLink = autoLink;
 
 function borderStyle() {
-	let convertedStyles = '\n// borderStyle Property\n';
+	return processProperties({ 'prop': 'borderStyle', 'component': 'Ti.UI.Picker[android], Ti.UI.TextArea, Ti.UI.TextField' }, {
+		'border-style': '{ borderStyle: {value} }'
+	}, {
+		'bezel': 'Ti.UI.INPUT_BORDERSTYLE_BEZEL',
+		'filled': 'Ti.UI.INPUT_BORDERSTYLE_FILLED',
+		'line': 'Ti.UI.INPUT_BORDERSTYLE_LINE',
+		'none': 'Ti.UI.INPUT_BORDERSTYLE_NONE',
+		'rounded': 'Ti.UI.INPUT_BORDERSTYLE_ROUNDED',
+		'underlined': 'Ti.UI.INPUT_BORDERSTYLE_UNDERLINED',
+	});
+}
+exports.borderStyle = borderStyle;
 
-	convertedStyles += `'.input-borderstyle-line[plarform=android]': { borderStyle: Ti.UI.INPUT_BORDERSTYLE_LINE }\n`;
-	convertedStyles += `'.input-borderstyle-none[plarform=android]': { borderStyle: Ti.UI.INPUT_BORDERSTYLE_NONE }\n`;
-	convertedStyles += `'.input-borderstyle-bezel[plarform=android]': { borderStyle: Ti.UI.INPUT_BORDERSTYLE_BEZEL }\n`;
-	convertedStyles += `'.input-borderstyle-filled[plarform=android]': { borderStyle: Ti.UI.INPUT_BORDERSTYLE_FILLED }\n`;
-	convertedStyles += `'.input-borderstyle-rounded[plarform=android]': { borderStyle: Ti.UI.INPUT_BORDERSTYLE_ROUNDED }\n`;
-	convertedStyles += `'.input-borderstyle-underlined[plarform=android]': { borderStyle: Ti.UI.INPUT_BORDERSTYLE_UNDERLINED }\n`;
+function pickerType() {
+	return processProperties({ 'prop': 'type (Picker Type)', 'component': 'Ti.UI.Picker' }, {
+		'picker-type': '{ type: {value} }'
+	}, {
+		'count-down-timer': 'Ti.UI.PICKER_TYPE_COUNT_DOWN_TIMER',
+		'date': 'Ti.UI.PICKER_TYPE_DATE',
+		'date-and-time': 'Ti.UI.PICKER_TYPE_DATE_AND_TIME',
+		'plain': 'Ti.UI.PICKER_TYPE_PLAIN',
+		'time': 'Ti.UI.PICKER_TYPE_TIME',
+	});
+}
+exports.pickerType = pickerType;
 
-	return convertedStyles;
+function lazyLoadingEnabled() {
+	return processProperties({ 'prop': 'lazyLoadingEnabled - iOS Only', 'component': 'Ti.UI.ListView' }, {
+		'lazy': '{ lazyLoadingEnabled: {value} }'
+	}, {
+		'loading': {
+			'ios': {
+				'enabled': true,
+				'disabled': false,
+			}
+		}
+	});
 }
-exports.borderStyle = borderStyle;
+exports.lazyLoadingEnabled = lazyLoadingEnabled;
 
-function autofillType() {
-	let convertedStyles = '\n// autofillType Property\n';
-
-	convertedStyles += `'.autofill-type-url': { autofillType: Ti.UI.AUTOFILL_TYPE_URL }\n`;
-	convertedStyles += `'.autofill-type-name': { autofillType: Ti.UI.AUTOFILL_TYPE_NAME }\n`;
-	convertedStyles += `'.autofill-type-phone': { autofillType: Ti.UI.AUTOFILL_TYPE_PHONE }\n`;
-	convertedStyles += `'.autofill-type-email': { autofillType: Ti.UI.AUTOFILL_TYPE_EMAIL }\n`;
-	convertedStyles += `'.autofill-type-address': { autofillType: Ti.UI.AUTOFILL_TYPE_ADDRESS }\n`;
-	convertedStyles += `'.autofill-type-username': { autofillType: Ti.UI.AUTOFILL_TYPE_USERNAME }\n`;
-	convertedStyles += `'.autofill-type-password': { autofillType: Ti.UI.AUTOFILL_TYPE_PASSWORD }\n`;
-	convertedStyles += `'.autofill-type-nickname': { autofillType: Ti.UI.AUTOFILL_TYPE_NICKNAME }\n`;
-	convertedStyles += `'.autofill-type-location': { autofillType: Ti.UI.AUTOFILL_TYPE_LOCATION }\n`;
-	convertedStyles += `'.autofill-type-job-title': { autofillType: Ti.UI.AUTOFILL_TYPE_JOB_TITLE }\n`;
-	convertedStyles += `'.autofill-type-given-name': { autofillType: Ti.UI.AUTOFILL_TYPE_GIVEN_NAME }\n`;
-	convertedStyles += `'.autofill-type-name-prefix': { autofillType: Ti.UI.AUTOFILL_TYPE_NAME_PREFIX }\n`;
-	convertedStyles += `'.autofill-type-middle-name': { autofillType: Ti.UI.AUTOFILL_TYPE_MIDDLE_NAME }\n`;
-	convertedStyles += `'.autofill-type-family-name': { autofillType: Ti.UI.AUTOFILL_TYPE_FAMILY_NAME }\n`;
-	convertedStyles += `'.autofill-type-name-suffix': { autofillType: Ti.UI.AUTOFILL_TYPE_NAME_SUFFIX }\n`;
-	convertedStyles += `'.autofill-type-sublocality': { autofillType: Ti.UI.AUTOFILL_TYPE_SUBLOCALITY }\n`;
-	convertedStyles += `'.autofill-type-postal-code': { autofillType: Ti.UI.AUTOFILL_TYPE_POSTAL_CODE }\n`;
-	convertedStyles += `'.autofill-type-card-number': { autofillType: Ti.UI.AUTOFILL_TYPE_CARD_NUMBER }\n`;
-	convertedStyles += `'.autofill-type-address-city': { autofillType: Ti.UI.AUTOFILL_TYPE_ADDRESS_CITY }\n`;
-	convertedStyles += `'.autofill-type-country-name': { autofillType: Ti.UI.AUTOFILL_TYPE_COUNTRY_NAME }\n`;
-	convertedStyles += `'.autofill-type-new-password': { autofillType: Ti.UI.AUTOFILL_TYPE_NEW_PASSWORD }\n`;
-	convertedStyles += `'.autofill-type-address-line1': { autofillType: Ti.UI.AUTOFILL_TYPE_ADDRESS_LINE1 }\n`;
-	convertedStyles += `'.autofill-type-address-line2': { autofillType: Ti.UI.AUTOFILL_TYPE_ADDRESS_LINE2 }\n`;
-	convertedStyles += `'.autofill-type-address-state': { autofillType: Ti.UI.AUTOFILL_TYPE_ADDRESS_STATE }\n`;
-	convertedStyles += `'.autofill-type-one-time-code': { autofillType: Ti.UI.AUTOFILL_TYPE_ONE_TIME_CODE }\n`;
-	convertedStyles += `'.autofill-type-organization-name': { autofillType: Ti.UI.AUTOFILL_TYPE_ORGANIZATION_NAME }\n`;
-	convertedStyles += `'.autofill-type-address-city-state': { autofillType: Ti.UI.AUTOFILL_TYPE_ADDRESS_CITY_STATE }\n`;
-	convertedStyles += `'.autofill-type-card-security-code': { autofillType: Ti.UI.AUTOFILL_TYPE_CARD_SECURITY_CODE }\n`;
-	convertedStyles += `'.autofill-type-card-expiration-day': { autofillType: Ti.UI.AUTOFILL_TYPE_CARD_EXPIRATION_DAY }\n`;
-	convertedStyles += `'.autofill-type-card-expiration-date': { autofillType: Ti.UI.AUTOFILL_TYPE_CARD_EXPIRATION_DATE }\n`;
-	convertedStyles += `'.autofill-type-card-expiration-year': { autofillType: Ti.UI.AUTOFILL_TYPE_CARD_EXPIRATION_YEAR }\n`;
-	convertedStyles += `'.autofill-type-card-expiration-month': { autofillType: Ti.UI.AUTOFILL_TYPE_CARD_EXPIRATION_MONTH }\n`;
+function allowUserCustomization() {
+	return processProperties({ 'prop': 'allowUserCustomization - iOS Only', 'component': 'Ti.UI.TabGroup' }, {
+		'default': '{ allowUserCustomization: {value} }'
+	}, {
+		'allow-user-customization': {
+			'ios': {
+				'default': true,
+			}
+		},
+		'dont-allow-user-customization': {
+			'ios': {
+				'default': false,
+			}
+		}
+	});
+}
+exports.allowUserCustomization = allowUserCustomization;
+
+function showAsAction() {
+	return processProperties({ 'prop': 'showAsAction - Android Only', 'component': 'Ti.Android.MenuItem' }, {
+		'show-as': '{ showAsAction: {value} }'
+	}, {
+		'action': {
+			'android': {
+				'always': 'Ti.Android.SHOW_AS_ACTION_ALWAYS',
+				'collapse': 'Ti.Android.SHOW_AS_ACTION_COLLAPSE_ACTION_VIEW',
+				'if-room': 'Ti.Android.SHOW_AS_ACTION_IF_ROOM',
+				'never': 'Ti.Android.SHOW_AS_ACTION_NEVER',
+				'with-text': 'Ti.Android.SHOW_AS_ACTION_WITH_TEXT',
+			}
+		}
+	});
+}
+exports.showAsAction = showAsAction;
 
-	return convertedStyles;
+function autofillType() {
+	return processProperties({ 'prop': 'autofillType', 'component': 'Ti.UI.TextArea, Ti.UI.TextField' }, {
+		'autofill-type': '{ autofillType: {value} }'
+	}, {
+		'url': 'Ti.UI.AUTOFILL_TYPE_URL',
+		'name': 'Ti.UI.AUTOFILL_TYPE_NAME',
+		'phone': 'Ti.UI.AUTOFILL_TYPE_PHONE',
+		'email': 'Ti.UI.AUTOFILL_TYPE_EMAIL',
+		'address': 'Ti.UI.AUTOFILL_TYPE_ADDRESS',
+		'username': 'Ti.UI.AUTOFILL_TYPE_USERNAME',
+		'password': 'Ti.UI.AUTOFILL_TYPE_PASSWORD',
+		'nickname': 'Ti.UI.AUTOFILL_TYPE_NICKNAME',
+		'location': 'Ti.UI.AUTOFILL_TYPE_LOCATION',
+		'job-title': 'Ti.UI.AUTOFILL_TYPE_JOB_TITLE',
+		'given-name': 'Ti.UI.AUTOFILL_TYPE_GIVEN_NAME',
+		'name-prefix': 'Ti.UI.AUTOFILL_TYPE_NAME_PREFIX',
+		'middle-name': 'Ti.UI.AUTOFILL_TYPE_MIDDLE_NAME',
+		'family-name': 'Ti.UI.AUTOFILL_TYPE_FAMILY_NAME',
+		'name-suffix': 'Ti.UI.AUTOFILL_TYPE_NAME_SUFFIX',
+		'sublocality': 'Ti.UI.AUTOFILL_TYPE_SUBLOCALITY',
+		'postal-code': 'Ti.UI.AUTOFILL_TYPE_POSTAL_CODE',
+		'card-number': 'Ti.UI.AUTOFILL_TYPE_CARD_NUMBER',
+		'address-city': 'Ti.UI.AUTOFILL_TYPE_ADDRESS_CITY',
+		'country-name': 'Ti.UI.AUTOFILL_TYPE_COUNTRY_NAME',
+		'new-password': 'Ti.UI.AUTOFILL_TYPE_NEW_PASSWORD',
+		'address-line1': 'Ti.UI.AUTOFILL_TYPE_ADDRESS_LINE1',
+		'address-line2': 'Ti.UI.AUTOFILL_TYPE_ADDRESS_LINE2',
+		'address-state': 'Ti.UI.AUTOFILL_TYPE_ADDRESS_STATE',
+		'one-time-code': 'Ti.UI.AUTOFILL_TYPE_ONE_TIME_CODE',
+		'organization-name': 'Ti.UI.AUTOFILL_TYPE_ORGANIZATION_NAME',
+		'address-city-state': 'Ti.UI.AUTOFILL_TYPE_ADDRESS_CITY_STATE',
+		'card-security-code': 'Ti.UI.AUTOFILL_TYPE_CARD_SECURITY_CODE',
+		'card-expiration-day': 'Ti.UI.AUTOFILL_TYPE_CARD_EXPIRATION_DAY',
+		'card-expiration-date': 'Ti.UI.AUTOFILL_TYPE_CARD_EXPIRATION_DATE',
+		'card-expiration-year': 'Ti.UI.AUTOFILL_TYPE_CARD_EXPIRATION_YEAR',
+		'card-expiration-month': 'Ti.UI.AUTOFILL_TYPE_CARD_EXPIRATION_MONTH',
+	});
 }
 exports.autofillType = autofillType;
 
 function returnKeyType() {
-	let convertedStyles = '\n// returnKeyType Property\n';
-
-	convertedStyles += `'.returnkey-go': { returnKeyType: Ti.UI.RETURNKEY_GO }\n`;
-	convertedStyles += `'.returnkey-done': { returnKeyType: Ti.UI.RETURNKEY_DONE }\n`;
-	convertedStyles += `'.returnkey-join': { returnKeyType: Ti.UI.RETURNKEY_JOIN }\n`;
-	convertedStyles += `'.returnkey-next': { returnKeyType: Ti.UI.RETURNKEY_NEXT }\n`;
-	convertedStyles += `'.returnkey-send': { returnKeyType: Ti.UI.RETURNKEY_SEND }\n`;
-	convertedStyles += `'.returnkey-route': { returnKeyType: Ti.UI.RETURNKEY_ROUTE }\n`;
-	convertedStyles += `'.returnkey-yahoo': { returnKeyType: Ti.UI.RETURNKEY_YAHOO }\n`;
-	convertedStyles += `'.returnkey-google': { returnKeyType: Ti.UI.RETURNKEY_GOOGLE }\n`;
-	convertedStyles += `'.returnkey-search': { returnKeyType: Ti.UI.RETURNKEY_SEARCH }\n`;
-	convertedStyles += `'.returnkey-default': { returnKeyType: Ti.UI.RETURNKEY_DEFAULT }\n`;
-	convertedStyles += `'.returnkey-continue': { returnKeyType: Ti.UI.RETURNKEY_CONTINUE }\n`;
-	convertedStyles += `'.returnkey-emergency-call': { returnKeyType: Ti.UI.RETURNKEY_EMERGENCY_CALL }\n`;
-
-	return convertedStyles;
+	return processProperties({ 'prop': 'returnKeyType', 'component': 'Ti.UI.AlertDialog, Ti.UI.TextArea, Ti.UI.TextField' }, {
+		'default': '{ returnKeyType: {value} }'
+	}, {
+		'returnkey': {
+			default: {
+				'default': 'Ti.UI.RETURNKEY_DEFAULT',
+				'go': 'Ti.UI.RETURNKEY_GO',
+				'done': 'Ti.UI.RETURNKEY_DONE',
+				'join': 'Ti.UI.RETURNKEY_JOIN',
+				'next': 'Ti.UI.RETURNKEY_NEXT',
+				'send': 'Ti.UI.RETURNKEY_SEND',
+				'route': 'Ti.UI.RETURNKEY_ROUTE',
+				'yahoo': 'Ti.UI.RETURNKEY_YAHOO',
+				'google': 'Ti.UI.RETURNKEY_GOOGLE',
+				'search': 'Ti.UI.RETURNKEY_SEARCH',
+				'emergency-call': 'Ti.UI.RETURNKEY_EMERGENCY_CALL'
+			},
+			ios: {
+				'continue': 'Ti.UI.RETURNKEY_CONTINUE',
+			}
+		}
+	});
 }
 exports.returnKeyType = returnKeyType;
 
+function loginReturnKeyType() {
+	return processProperties({ 'prop': 'loginReturnKeyType', 'component': 'Ti.UI.AlertDialog' }, {
+		'login': '{ loginReturnKeyType: {value} }'
+	}, {
+		'returnkey': {
+			default: {
+				'default': 'Ti.UI.RETURNKEY_DEFAULT',
+				'go': 'Ti.UI.RETURNKEY_GO',
+				'done': 'Ti.UI.RETURNKEY_DONE',
+				'join': 'Ti.UI.RETURNKEY_JOIN',
+				'next': 'Ti.UI.RETURNKEY_NEXT',
+				'send': 'Ti.UI.RETURNKEY_SEND',
+				'route': 'Ti.UI.RETURNKEY_ROUTE',
+				'yahoo': 'Ti.UI.RETURNKEY_YAHOO',
+				'google': 'Ti.UI.RETURNKEY_GOOGLE',
+				'search': 'Ti.UI.RETURNKEY_SEARCH',
+				'emergency-call': 'Ti.UI.RETURNKEY_EMERGENCY_CALL'
+			},
+			ios: {
+				'continue': 'Ti.UI.RETURNKEY_CONTINUE',
+			}
+		}
+	});
+}
+exports.loginReturnKeyType = loginReturnKeyType;
+
+// loginReturnKeyType ( Android and iOS )
+
 function gridSystem() {
 	let modifiersAndValues = {
 		1: '100%',
@@ -837,7 +1696,9 @@ function gridSystem() {
 		12: '8.333334%',
 	};
 
-	let convertedStyles = processModifiersAndProperties('Grid Template Columns', { 'grid-cols': '{ width: {value} }' }, modifiersAndValues);
+	let convertedStyles = processProperties({ 'prop': 'width - For Grid Template Columns', 'component': 'Ti.UI.ActivityIndicator, Ti.UI.Animation, Ti.UI.iPad.Popover, Ti.UI.View, Ti.UI.Window' }, {
+		'grid-cols': '{ width: {value} }'
+	}, modifiersAndValues);
 
 	modifiersAndValues = {
 		1: '100%',
@@ -854,7 +1715,9 @@ function gridSystem() {
 		12: '8.333334%',
 	};
 
-	convertedStyles += processModifiersAndProperties('Grid Template Rows', { 'grid-rows': '{ height: {value} }' }, modifiersAndValues);
+	convertedStyles += processProperties({ 'prop': 'height - For Grid Template Rows', 'component': 'Ti.UI.ActivityIndicator, Ti.UI.Animation, Ti.UI.iPad.Popover, Ti.UI.View, Ti.UI.Window' }, {
+		'grid-rows': '{ height: {value} }'
+	}, modifiersAndValues);
 
 	return convertedStyles;
 }
@@ -862,161 +1725,456 @@ exports.gridSystem = gridSystem;
 
 function gridColumnsStartEnd() {
 	let modifiersAndValues = {
-		'span-1': '8.333334%',
-		'span-2': '16.666667%',
-		'span-3': '25%',
-		'span-4': '33.333334%',
-		'span-5': '41.666667%',
-		'span-6': '50%',
-		'span-7': '58.333334%',
-		'span-8': '66.666667%',
-		'span-9': '75%',
-		'span-10': '83.333334%',
-		'span-11': '91.666667%',
-		'span-12': '100%'
+		1: '8.333334%',
+		2: '16.666667%',
+		3: '25%',
+		4: '33.333334%',
+		5: '41.666667%',
+		6: '50%',
+		7: '58.333334%',
+		8: '66.666667%',
+		9: '75%',
+		10: '83.333334%',
+		11: '91.666667%',
+		12: '100%'
 	};
 
-	let convertedStyles = processModifiersAndProperties('Grid Column Start / End', { 'col': '{ width: {value} }' }, modifiersAndValues);
+	let convertedStyles = processProperties({ 'prop': 'width - For Grid Column Start/End', 'component': 'Ti.UI.ActivityIndicator, Ti.UI.Animation, Ti.UI.iPad.Popover, Ti.UI.View, Ti.UI.Window' }, {
+		'col-span': '{ width: {value} }'
+	}, modifiersAndValues);
 
 	modifiersAndValues = {
-		'span-1': '8.333334%',
-		'span-2': '16.666667%',
-		'span-3': '25%',
-		'span-4': '33.333334%',
-		'span-5': '41.666667%',
-		'span-6': '50%',
-		'span-7': '58.333334%',
-		'span-8': '66.666667%',
-		'span-9': '75%',
-		'span-10': '83.333334%',
-		'span-11': '91.666667%',
-		'span-12': '100%'
+		1: '8.333334%',
+		2: '16.666667%',
+		3: '25%',
+		4: '33.333334%',
+		5: '41.666667%',
+		6: '50%',
+		7: '58.333334%',
+		8: '66.666667%',
+		9: '75%',
+		10: '83.333334%',
+		11: '91.666667%',
+		12: '100%'
 	};
 
-	convertedStyles += processModifiersAndProperties('Grid Row Start / End', { 'row': '{ height: {value} }' }, modifiersAndValues);
+	convertedStyles += processProperties({ 'prop': 'height - For Grid Row Start/End', 'component': 'Ti.UI.ActivityIndicator, Ti.UI.Animation, Ti.UI.iPad.Popover, Ti.UI.View, Ti.UI.Window' }, {
+		'row-span': '{ height: {value} }'
+	}, modifiersAndValues);
 
 	return convertedStyles;
 }
 exports.gridColumnsStartEnd = gridColumnsStartEnd;
 
-function borderRadiusExtraStyles({ ...modifiersAndValues }) {
-	// SOME CLEANUP... VALUES NOT NEEDED HERE!.
-	delete modifiersAndValues.fit;
-	delete modifiersAndValues.min;
-	delete modifiersAndValues.max;
-	delete modifiersAndValues.full;
-	delete modifiersAndValues.auto;
-	delete modifiersAndValues.screen;
-	delete modifiersAndValues['min-content'];
-	delete modifiersAndValues['max-content'];
-
-	_.each(modifiersAndValues, (value, key) => {
-		if (key.includes('/')) {
-			delete modifiersAndValues[key];
-		} else if (['sm', 'md', 'lg', 'xl', '2xl', '3xl', 'px', 'DEFAULT'].includes(key)) {
-			modifiersAndValues[key] = value;
-		} else {
-			modifiersAndValues[key] = 8 * parseFloat(value);
-		}
+function displayUtilities() {
+	return processProperties({ 'prop': 'visible', 'component': 'Ti.Android.MenuItem, Ti.UI.Animation, Ti.UI.Picker, Ti.UI.ScrollableView, Ti.UI.ShortcutItem, Ti.UI.View' }, {
+		'default': '{ visible: {value} }'
+	}, {
+		'block': true,
+		'hidden': false,
 	});
-
-	return processModifiersAndProperties('borderRadius - ( With Extra Styles )', { 'rounded': '{ borderRadius: {value} }' }, modifiersAndValues);
 }
-exports.borderRadiusExtraStyles = borderRadiusExtraStyles;
+exports.displayUtilities = displayUtilities;
 
-function borderWidth({ ...modifiersAndValues }) {
-	_.each(modifiersAndValues, (value, key) => {
-		modifiersAndValues[key] = parseInt(value);
+function useSpinner() {
+	return processProperties({ 'prop': 'useSpinner', 'component': 'Ti.UI.Picker' }, {
+		'default': '{ useSpinner: {value} }'
+	}, {
+		'use-spinner': true,
+		'dont-use-spinner': false,
 	});
+}
+exports.useSpinner = useSpinner;
 
-	return processModifiersAndProperties('borderWidth', { 'border': '{ borderWidth: {value} }' }, modifiersAndValues);
+function calendarViewShown() {
+	return processProperties({ 'prop': 'calendarViewShown', 'component': 'Ti.UI.Picker' }, {
+		'default': '{ calendarViewShown: {value} }'
+	}, {
+		'show-calendar-view': true,
+		'hide-calendar-view': false,
+	});
 }
-exports.borderWidth = borderWidth;
+exports.calendarViewShown = calendarViewShown;
 
-function displayUtilities() {
-	let convertedStyles = '\n// Display\n';
+function flip() {
+	return processProperties({ 'prop': 'flip', 'component': 'For the Animation Component' }, {
+		'flip': '{ flip: {value} }'
+	}, {
+		'horizontal': 'horizontal',
+		'vertical': 'vertical',
+	});
+}
+exports.flip = flip;
 
-	convertedStyles += `'.block': { visible: true }\n`;
-	convertedStyles += `'.hidden': { visible: false }\n`;
+function shiftMode() {
+	return processProperties({ 'prop': 'shiftMode - Android Only', 'component': 'Ti.UI.TabGroup' }, {
+		'default': '{ shiftMode: {value} }'
+	}, {
+		'shift-mode': {
+			'android': {
+				'default': true,
+				'disabled': false
+			}
+		}
+	});
+}
+exports.shiftMode = shiftMode;
 
-	return convertedStyles;
+function smoothScrollOnTabClick() {
+	return processProperties({ 'prop': 'smoothScrollOnTabClick', 'component': 'Ti.UI.TabGroup' }, {
+		'default': '{ smoothScrollOnTabClick: {value} }'
+	}, {
+		'smooth-scroll': {
+			'android': {
+				'default': true,
+				'disabled': false
+			}
+		}
+	});
 }
-exports.displayUtilities = displayUtilities;
+exports.smoothScrollOnTabClick = smoothScrollOnTabClick;
 
-function flip() {
-	let convertedStyles = '\n// Flip Property\n';
+function tabGroupStyle() {
+	return processProperties({ 'prop': 'style - Android Only', 'component': 'Ti.UI.TabGroup' }, {
+		'default': '{ style: {value} }'
+	}, {
+		'tabs-style': {
+			'android': {
+				'default': 'Ti.UI.Android.TABS_STYLE_DEFAULT',
+				'bottom-navigation': 'Ti.UI.Android.TABS_STYLE_BOTTOM_NAVIGATION'
+			}
+		}
+	});
+}
+exports.tabGroupStyle = tabGroupStyle;
+
+function tabbedBarStyle() {
+	return processProperties({ 'prop': 'style - iOS Only', 'component': 'Ti.UI.iOS.TabbedBar' }, {
+		'default': '{ style: {value} }'
+	}, {
+		'tabbed-bar-style': {
+			'ios': {
+				'bordered': 'Ti.UI.iOS.SystemButtonStyle.BORDERED',
+				'done': 'Ti.UI.iOS.SystemButtonStyle.DONE',
+				'plain': 'Ti.UI.iOS.SystemButtonStyle.PLAIN',
+			}
+		}
+	});
+}
+exports.tabbedBarStyle = tabbedBarStyle;
+
+function windowPixelFormat() {
+	return processProperties({ 'prop': 'windowPixelFormat - Android Only', 'component': 'Ti.UI.Window' }, {
+		'default': '{ windowPixelFormat: {value} }'
+	}, {
+		'pixel-format': {
+			'android': {
+				'a-8': 'Ti.UI.Android.PIXEL_FORMAT_A_8',
+				'la-88': 'Ti.UI.Android.PIXEL_FORMAT_LA_88',
+				'l-8': 'Ti.UI.Android.PIXEL_FORMAT_L_8',
+				'opaque': 'Ti.UI.Android.PIXEL_FORMAT_OPAQUE',
+				'rgba-4444': 'Ti.UI.Android.PIXEL_FORMAT_RGBA_4444',
+				'rgba-5551': 'Ti.UI.Android.PIXEL_FORMAT_RGBA_5551',
+				'rgba-8888': 'Ti.UI.Android.PIXEL_FORMAT_RGBA_8888',
+				'rgbx-8888': 'Ti.UI.Android.PIXEL_FORMAT_RGBX_8888',
+				'rgb-332': 'Ti.UI.Android.PIXEL_FORMAT_RGB_332',
+				'rgb-565': 'Ti.UI.Android.PIXEL_FORMAT_RGB_565',
+				'rgb-888': 'Ti.UI.Android.PIXEL_FORMAT_RGB_888',
+				'translucent': 'Ti.UI.Android.PIXEL_FORMAT_TRANSLUCENT',
+				'transparent': 'Ti.UI.Android.PIXEL_FORMAT_TRANSPARENT',
+				'unknown': 'Ti.UI.Android.PIXEL_FORMAT_UNKNOWN',
+			}
+		}
+	});
+}
+exports.windowPixelFormat = windowPixelFormat;
 
-	convertedStyles += `'.flip-vertical': { flip: 'vertical'}\n`;
-	convertedStyles += `'.flip-horizontal': { flip: 'horizontal'}\n`;
+function tabBarHidden() {
+	return processProperties({ 'prop': 'tabBarHidden - iOS Only', 'component': 'Ti.UI.Window' }, {
+		'default': '{ tabBarHidden: {value} }'
+	}, {
+		'tab-bar-hidden': {
+			'ios': {
+				'default': true,
+			}
+		},
+		'tab-bar-visible': {
+			'ios': {
+				'default': false,
+			}
+		}
+	});
+}
+exports.tabBarHidden = tabBarHidden;
+
+function windowSoftInputMode() {
+	return processProperties({ 'prop': 'windowSoftInputMode - Android Only', 'component': 'Ti.UI.TabGroup, Ti.UI.Window' }, {
+		'window': '{ windowSoftInputMode: {value} }'
+	}, {
+		'soft-input': {
+			'android': {
+				'always-hidden': 'Ti.UI.Android.SOFT_INPUT_STATE_ALWAYS_HIDDEN',
+				'always-visible': 'Ti.UI.Android.SOFT_INPUT_STATE_ALWAYS_VISIBLE',
+				'hidden': 'Ti.UI.Android.SOFT_INPUT_STATE_HIDDEN',
+				'pan': 'Ti.UI.Android.SOFT_INPUT_ADJUST_PAN',
+				'resize': 'Ti.UI.Android.SOFT_INPUT_ADJUST_RESIZE',
+				'unspecified': 'Ti.UI.Android.SOFT_INPUT_ADJUST_UNSPECIFIED',
+				'unspecified': 'Ti.UI.Android.SOFT_INPUT_STATE_UNSPECIFIED',
+				'visible': 'Ti.UI.Android.SOFT_INPUT_STATE_VISIBLE',
+			}
+		}
+	});
+}
+exports.windowSoftInputMode = windowSoftInputMode;
+
+// Activities Android
+function activityEnterTransition() {
+	return processProperties({ 'prop': 'activityEnterTransition - Android Only', 'component': 'Ti.UI.Window' }, {
+		'activity': '{ activityEnterTransition: {value} }'
+	}, {
+		'enter-transition': {
+			'android': {
+				'explode': 'Ti.UI.Android.TRANSITION_EXPLODE',
+				'fade-in': 'Ti.UI.Android.TRANSITION_FADE_IN',
+				'fade-out': 'Ti.UI.Android.TRANSITION_FADE_OUT',
+				'none': 'Ti.UI.Android.TRANSITION_NONE',
+				'slide-bottom': 'Ti.UI.Android.TRANSITION_SLIDE_BOTTOM',
+				'slide-left': 'Ti.UI.Android.TRANSITION_SLIDE_LEFT',
+				'slide-right': 'Ti.UI.Android.TRANSITION_SLIDE_RIGHT',
+				'slide-top': 'Ti.UI.Android.TRANSITION_SLIDE_TOP',
+			}
+		}
+	});
+}
+exports.activityEnterTransition = activityEnterTransition;
+
+function activityExitTransition() {
+	return processProperties({ 'prop': 'activityExitTransition - Android Only', 'component': 'Ti.UI.Window' }, {
+		'activity': '{ activityExitTransition: {value} }'
+	}, {
+		'exit-transition': {
+			'android': {
+				'explode': 'Ti.UI.Android.TRANSITION_EXPLODE',
+				'fade-in': 'Ti.UI.Android.TRANSITION_FADE_IN',
+				'fade-out': 'Ti.UI.Android.TRANSITION_FADE_OUT',
+				'none': 'Ti.UI.Android.TRANSITION_NONE',
+				'slide-bottom': 'Ti.UI.Android.TRANSITION_SLIDE_BOTTOM',
+				'slide-left': 'Ti.UI.Android.TRANSITION_SLIDE_LEFT',
+				'slide-right': 'Ti.UI.Android.TRANSITION_SLIDE_RIGHT',
+				'slide-top': 'Ti.UI.Android.TRANSITION_SLIDE_TOP',
+			}
+		}
+	});
+}
+exports.activityExitTransition = activityExitTransition;
+
+function activityReenterTransition() {
+	return processProperties({ 'prop': 'activityReenterTransition - Android Only', 'component': 'Ti.UI.Window' }, {
+		'activity': '{ activityReenterTransition: {value} }'
+	}, {
+		'reenter-transition': {
+			'android': {
+				'explode': 'Ti.UI.Android.TRANSITION_EXPLODE',
+				'fade-in': 'Ti.UI.Android.TRANSITION_FADE_IN',
+				'fade-out': 'Ti.UI.Android.TRANSITION_FADE_OUT',
+				'none': 'Ti.UI.Android.TRANSITION_NONE',
+				'slide-bottom': 'Ti.UI.Android.TRANSITION_SLIDE_BOTTOM',
+				'slide-left': 'Ti.UI.Android.TRANSITION_SLIDE_LEFT',
+				'slide-right': 'Ti.UI.Android.TRANSITION_SLIDE_RIGHT',
+				'slide-top': 'Ti.UI.Android.TRANSITION_SLIDE_TOP',
+			}
+		}
+	});
+}
+exports.activityReenterTransition = activityReenterTransition;
+
+function activityReturnTransition() {
+	return processProperties({ 'prop': 'activityReturnTransition - Android Only', 'component': 'Ti.UI.Window' }, {
+		'activity': '{ activityReturnTransition: {value} }'
+	}, {
+		'return-transition': {
+			'android': {
+				'explode': 'Ti.UI.Android.TRANSITION_EXPLODE',
+				'fade-in': 'Ti.UI.Android.TRANSITION_FADE_IN',
+				'fade-out': 'Ti.UI.Android.TRANSITION_FADE_OUT',
+				'none': 'Ti.UI.Android.TRANSITION_NONE',
+				'slide-bottom': 'Ti.UI.Android.TRANSITION_SLIDE_BOTTOM',
+				'slide-left': 'Ti.UI.Android.TRANSITION_SLIDE_LEFT',
+				'slide-right': 'Ti.UI.Android.TRANSITION_SLIDE_RIGHT',
+				'slide-top': 'Ti.UI.Android.TRANSITION_SLIDE_TOP',
+			}
+		}
+	});
+}
+exports.activityReturnTransition = activityReturnTransition;
+
+function activitySharedElementEnterTransition() {
+	return processProperties({ 'prop': 'activitySharedElementEnterTransition - Android Only', 'component': 'Ti.UI.Window' }, {
+		'activity': '{ activitySharedElementEnterTransition: {value} }'
+	}, {
+		'shared-element-enter-transition': {
+			'android': {
+				'change-bounds': 'Ti.UI.Android.TRANSITION_CHANGE_BOUNDS',
+				'change-clip-bounds': 'Ti.UI.Android.TRANSITION_CHANGE_CLIP_BOUNDS',
+				'change-transform': 'Ti.UI.Android.TRANSITION_CHANGE_TRANSFORM',
+				'change-image-transform': 'Ti.UI.Android.TRANSITION_CHANGE_IMAGE_TRANSFORM',
+				'none': 'Ti.UI.Android.TRANSITION_NONE',
+			}
+		}
+	});
+}
+exports.activitySharedElementEnterTransition = activitySharedElementEnterTransition;
+
+function activitySharedElementExitTransition() {
+	return processProperties({ 'prop': 'activitySharedElementExitTransition - Android Only', 'component': 'Ti.UI.Window' }, {
+		'activity': '{ activitySharedElementExitTransition: {value} }'
+	}, {
+		'shared-element-exit-transition': {
+			'android': {
+				'change-bounds': 'Ti.UI.Android.TRANSITION_CHANGE_BOUNDS',
+				'change-clip-bounds': 'Ti.UI.Android.TRANSITION_CHANGE_CLIP_BOUNDS',
+				'change-transform': 'Ti.UI.Android.TRANSITION_CHANGE_TRANSFORM',
+				'change-image-transform': 'Ti.UI.Android.TRANSITION_CHANGE_IMAGE_TRANSFORM',
+				'none': 'Ti.UI.Android.TRANSITION_NONE',
+			}
+		}
+	});
+}
+exports.activitySharedElementExitTransition = activitySharedElementExitTransition;
+
+function activitySharedElementReenterTransition() {
+	return processProperties({ 'prop': 'activitySharedElementReenterTransition - Android Only', 'component': 'Ti.UI.Window' }, {
+		'activity': '{ activitySharedElementReenterTransition: {value} }'
+	}, {
+		'shared-element-reenter-transition': {
+			'android': {
+				'change-bounds': 'Ti.UI.Android.TRANSITION_CHANGE_BOUNDS',
+				'change-clip-bounds': 'Ti.UI.Android.TRANSITION_CHANGE_CLIP_BOUNDS',
+				'change-transform': 'Ti.UI.Android.TRANSITION_CHANGE_TRANSFORM',
+				'change-image-transform': 'Ti.UI.Android.TRANSITION_CHANGE_IMAGE_TRANSFORM',
+				'none': 'Ti.UI.Android.TRANSITION_NONE',
+			}
+		}
+	});
+}
+exports.activitySharedElementReenterTransition = activitySharedElementReenterTransition;
+
+function activitySharedElementReturnTransition() {
+	return processProperties({ 'prop': 'activitySharedElementReturnTransition - Android Only', 'component': 'Ti.UI.Window' }, {
+		'activity': '{ activitySharedElementReturnTransition: {value} }'
+	}, {
+		'shared-element-return-transition': {
+			'android': {
+				'change-bounds': 'Ti.UI.Android.TRANSITION_CHANGE_BOUNDS',
+				'change-clip-bounds': 'Ti.UI.Android.TRANSITION_CHANGE_CLIP_BOUNDS',
+				'change-transform': 'Ti.UI.Android.TRANSITION_CHANGE_TRANSFORM',
+				'change-image-transform': 'Ti.UI.Android.TRANSITION_CHANGE_IMAGE_TRANSFORM',
+				'none': 'Ti.UI.Android.TRANSITION_NONE',
+			}
+		}
+	});
+}
+exports.activitySharedElementReturnTransition = activitySharedElementReturnTransition;
 
-	return convertedStyles;
+function iconIsMask() {
+	return processProperties({ 'prop': 'iconIsMask - iOS Only', 'component': 'Ti.UI.Tab' }, {
+		'default': '{ iconIsMask: {value} }'
+	}, {
+		'icon-is': {
+			'ios': {
+				'mask': true,
+				'not-mask': false
+			}
+		}
+	});
 }
-exports.flip = flip;
+exports.iconIsMask = iconIsMask;
 
-function shadow(shadowValue = '#80000000') {
-	let convertedStyles = '\n// Box Shadow\n';
+function activeIconIsMask() {
+	return processProperties({ 'prop': 'activeIconIsMask - iOS Only', 'component': 'Ti.UI.Tab' }, {
+		'default': '{ activeIconIsMask: {value} }'
+	}, {
+		'active-icon-is': {
+			'ios': {
+				'mask': true,
+				'not-mask': false
+			}
+		}
+	});
+}
+exports.activeIconIsMask = activeIconIsMask;
 
-	convertedStyles += `'.shadow-xs': { viewShadowOffset: { x: 0, y: 0 }, viewShadowRadius: 1, viewShadowColor: ${parseValue(shadowValue)} }\n`;
-	convertedStyles += `'.shadow-sm': { viewShadowOffset: { x: 0, y: 1 }, viewShadowRadius: 1, viewShadowColor: ${parseValue(shadowValue)} }\n`;
-	convertedStyles += `'.shadow': { viewShadowOffset: { x: 0, y: 2 }, viewShadowRadius: 2, viewShadowColor: ${parseValue(shadowValue)} }\n`;
-	convertedStyles += `'.shadow-md': { viewShadowOffset: { x: 0, y: 4 }, viewShadowRadius: 4, viewShadowColor: ${parseValue(shadowValue)} }\n`;
-	convertedStyles += `'.shadow-lg': { viewShadowOffset: { x: 0, y: 8 }, viewShadowRadius: 8, viewShadowColor: ${parseValue(shadowValue)} }\n`;
-	convertedStyles += `'.shadow-xl': { viewShadowOffset: { x: 0, y: 12 }, viewShadowRadius: 12, viewShadowColor: ${parseValue(shadowValue)} }\n`;
-	convertedStyles += `'.shadow-2xl': { viewShadowOffset: { x: 0, y: 16 }, viewShadowRadius: 16, viewShadowColor: ${parseValue(shadowValue)} }\n`;
-	convertedStyles += `'.shadow-inner': { viewShadowOffset: { x: 0, y: 0 }, viewShadowRadius: null, viewShadowColor: null }\n`;
-	convertedStyles += `'.shadow-outline': { viewShadowOffset: { x: 0, y: 0 }, viewShadowRadius: 2, viewShadowColor: ${parseValue(shadowValue)} }\n`;
-	convertedStyles += `'.shadow-none': { viewShadowOffset: { x: 0, y: 0 }, viewShadowRadius: null, viewShadowColor: null }\n`;
+function keepSectionsInSearch() {
+	let convertedStyles = processComments({ 'prop': 'keepSectionsInSearch - iOS Only', 'component': 'Ti.UI.ListView' });
+	convertedStyles += `'.keep-sections-in-search[platform=ios]': { keepSectionsInSearch: true }\n`;
+	convertedStyles += `'.dont-keep-sections-in-search[platform=ios]': { keepSectionsInSearch: false }\n`;
 
 	return convertedStyles;
 }
-exports.shadow = shadow;
+exports.keepSectionsInSearch = keepSectionsInSearch;
+
+function bottomNavigation({ ...modifiersAndValues }) {
+	const objectPosition = {
+		'padding': '{ padding: {value} }',
+		'padding-x': '{ paddingLeft: {value}, paddingRight: {value} }',
+		'padding-y': '{ paddingTop: {value}, paddingBottom: {value} }',
+		'padding-t': '{ paddingTop: {value} }',
+		'padding-l': '{ paddingLeft: {value} }',
+		'padding-r': '{ paddingRight: {value} }',
+		'padding-b': '{ paddingBottom: {value} }',
+	}
 
-function shadowColor(modifiersAndValues) {
-	return processModifiersAndProperties('Box Shadow Color', { 'shadow': '{ viewShadowColor: {value} }' }, modifiersAndValues);
-}
-exports.shadowColor = shadowColor;
+	modifiersAndValues = removeFractions(modifiersAndValues);
+	delete modifiersAndValues.fit;
+	delete modifiersAndValues.min;
+	delete modifiersAndValues.max;
+	delete modifiersAndValues.full;
+	delete modifiersAndValues.auto;
+	delete modifiersAndValues.screen;
+	delete modifiersAndValues['min-content'];
+	delete modifiersAndValues['max-content'];
 
-function opacity(modifiersAndValues) {
-	return processModifiersAndProperties('opacity', { 'opacity': '{ opacity: {value} }' }, modifiersAndValues);
+	return processProperties({ 'prop': 'padding, paddingTop, paddingLeft, paddingRight, paddingBottom', 'component': 'Ti.UI.Android.CardView, Ti.UI.TabGroup' }, objectPosition, modifiersAndValues);
 }
-exports.opacity = opacity;
+exports.bottomNavigation = bottomNavigation;
 
 function interactivity() {
-	let convertedStyles = '\n// touchEnabled Property\n';
-	convertedStyles += `'.touch-enabled': { touchEnabled: true }\n`;
-	convertedStyles += `'.touch-disabled': { touchEnabled: false }\n`;
-	convertedStyles += `'.pointer-events-auto': { touchEnabled: true }\n`;
-	convertedStyles += `'.pointer-events-none': { touchEnabled: false }\n`;
-
-	return convertedStyles;
+	return processProperties({ 'prop': 'touchEnabled', 'component': 'Ti.UI.View' }, {
+		'default': '{ touchEnabled: {value} }'
+	}, {
+		'touch-enabled': true,
+		'touch-disabled': false,
+		'pointer-events-auto': true,
+		'pointer-events-none': false,
+	});
 }
 exports.interactivity = interactivity;
 
 function textAlign() {
-	const modifiersAndValues = {
-		left: 'Ti.UI.TEXT_ALIGNMENT_LEFT',
-		right: 'Ti.UI.TEXT_ALIGNMENT_RIGHT',
-		center: 'Ti.UI.TEXT_ALIGNMENT_CENTER',
-		justify: 'Ti.UI.TEXT_ALIGNMENT_JUSTIFY'
-	};
-
-	return processModifiersAndProperties('textAlign', { 'text': '{ textAlign: {value} }' }, modifiersAndValues);
+	return processProperties({ 'prop': 'textAlign', 'component': 'Ti.UI.Button, Ti.UI.Label, Ti.UI.Switch, Ti.UI.TextArea, Ti.UI.TextField' }, {
+		'text': '{ textAlign: {value} }'
+	}, {
+		'left': 'Ti.UI.TEXT_ALIGNMENT_LEFT',
+		'right': 'Ti.UI.TEXT_ALIGNMENT_RIGHT',
+		'center': 'Ti.UI.TEXT_ALIGNMENT_CENTER',
+		'justify': 'Ti.UI.TEXT_ALIGNMENT_JUSTIFY',
+	});
 }
 exports.textAlign = textAlign;
 
 function verticalAlignment() {
-	const modifiersAndValues = {
-		top: 'Ti.UI.TEXT_VERTICAL_ALIGNMENT_TOP',
-		middle: 'Ti.UI.TEXT_VERTICAL_ALIGNMENT_CENTER',
-		bottom: 'Ti.UI.TEXT_VERTICAL_ALIGNMENT_BOTTOM',
-	};
-
-	return processModifiersAndProperties('verticalAlign', { 'align': '{ verticalAlign: {value} }' }, modifiersAndValues);
+	return processProperties({ 'prop': 'verticalAlign', 'component': 'Ti.UI.Button, Ti.UI.Label, Ti.UI.Switch, Ti.UI.TextArea, Ti.UI.TextField' }, {
+		'align': '{ verticalAlign: {value} }'
+	}, {
+		'top': 'Ti.UI.TEXT_VERTICAL_ALIGNMENT_TOP',
+		'middle': 'Ti.UI.TEXT_VERTICAL_ALIGNMENT_CENTER',
+		'bottom': 'Ti.UI.TEXT_VERTICAL_ALIGNMENT_BOTTOM',
+	});
 }
 exports.verticalAlignment = verticalAlignment;
 
 function scrollableRegion() {
-	let convertedStyles = '\n// contentWidth & contentHeight ( for ScrollViews )\n';
+	let convertedStyles = processComments({ 'prop': 'contentWidth, contentHeight', 'component': 'Ti.UI.ScrollView' });
 
 	convertedStyles += `'.content-w-auto': { contentWidth: Ti.UI.SIZE }\n`;
 	convertedStyles += `'.content-w-screen': { contentWidth: Ti.UI.FILL }\n`;
@@ -1030,7 +2188,7 @@ function scrollableRegion() {
 exports.scrollableRegion = scrollableRegion;
 
 function scrollIndicators() {
-	let convertedStyles = '\n// Scroll Indicators ( for ScrollViews )\n';
+	let convertedStyles = processComments({ 'prop': 'showHorizontalScrollIndicator, showVerticalScrollIndicator', 'component': 'Ti.UI.ScrollView' });
 
 	convertedStyles += `'.overflow-x-scroll': { showHorizontalScrollIndicator: true }\n`;
 	convertedStyles += `'.overflow-y-scroll': { showVerticalScrollIndicator: true }\n`;
@@ -1064,7 +2222,7 @@ function placement() {
 		'inset-auto': 'top: Ti.UI.SIZE, right: Ti.UI.SIZE, bottom: Ti.UI.SIZE, left: Ti.UI.SIZE'
 	}
 
-	let convertedStyles = '\n// Top / Right / Bottom / Left\n';
+	let convertedStyles = processComments({ 'prop': 'top, right, bottom, left', 'component': 'Ti.UI.ActivityIndicator, Ti.UI.Animation, Ti.UI.View, Ti.UI.Window' });
 
 	_.each(objectPosition, (value, modifier) => {
 		convertedStyles += `'.${modifier}': { ${value} }\n`;
@@ -1086,8 +2244,8 @@ function origin() {
 		'left': 'x: 0, y: 0.5',
 		'top-left': 'x: 0, y: 0'
 	}
-
-	let convertedStyles = '\n// anchorPoint Properties\n';
+	// '\n// anchorPoint Properties\n'
+	let convertedStyles = processComments({ 'prop': 'anchorPoint', 'component': 'Ti.UI.Animation, Ti.UI.View' });
 
 	_.each(objectPosition, (value, modifier) => {
 		convertedStyles += `'.origin-${modifier}': { anchorPoint: { ${value} } }\n`;
@@ -1108,7 +2266,6 @@ function margin({ ...modifiersAndValues }) {
 		'ml': '{ left: {value} }',
 	}
 
-
 	// SOME CLEANUP... VALUES NOT NEEDED HERE.
 	delete modifiersAndValues.fit;
 	delete modifiersAndValues.min;
@@ -1121,7 +2278,7 @@ function margin({ ...modifiersAndValues }) {
 
 	modifiersAndValues.auto = 'null';
 
-	let convertedStyles = processModifiersAndProperties('Margin', objectPosition, modifiersAndValues);
+	let convertedStyles = processProperties({ 'prop': 'top, right, bottom, left ( Margin )', 'component': 'Ti.UI.ActivityIndicator, Ti.UI.Animation, Ti.UI.View, Ti.UI.Window' }, objectPosition, modifiersAndValues);
 
 	objectPosition = {
 		'-m': '{ top: {value}, right: {value}, bottom: {value}, left: {value} }',
@@ -1136,14 +2293,18 @@ function margin({ ...modifiersAndValues }) {
 	delete modifiersAndValues['0'];
 	delete modifiersAndValues.auto;
 
-	convertedStyles += processModifiersAndProperties('Negative Margins', objectPosition, modifiersAndValues, '-');
+	convertedStyles += processProperties({ 'prop': 'top, right, bottom, left ( Negative Margin )', 'component': 'Ti.UI.ActivityIndicator, Ti.UI.Animation, Ti.UI.View, Ti.UI.Window' }, objectPosition, modifiersAndValues, '-');
 
 	return convertedStyles;
 }
 exports.margin = margin;
 
 function repeat() {
-	return processModifiersAndProperties('repeat', { 'repeat': '{ repeat: {value} }' }, { 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10 });
+	return processProperties({ 'prop': 'repeat', 'component': 'Ti.UI.Animation' }, {
+		'repeat': '{ repeat: {value} }'
+	}, {
+		1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10
+	});
 }
 exports.repeat = repeat;
 
@@ -1158,7 +2319,7 @@ function padding({ ...modifiersAndValues }) {
 		'pl': '{ padding: { left: {value} } }',
 	}
 
-	modifiersAndValues['0'] = 0;
+	// modifiersAndValues['0'] = 0;
 	delete modifiersAndValues.fit;
 	delete modifiersAndValues.min;
 	delete modifiersAndValues.max;
@@ -1167,7 +2328,7 @@ function padding({ ...modifiersAndValues }) {
 	delete modifiersAndValues['min-content'];
 	delete modifiersAndValues['max-content'];
 
-	return processModifiersAndProperties('padding', objectPosition, modifiersAndValues);
+	return processProperties({ 'prop': 'padding', 'component': 'Ti.UI.Android.CardView, Ti.UI.TextArea, Ti.UI.TextField' }, objectPosition, modifiersAndValues);
 }
 exports.padding = padding;
 
@@ -1179,7 +2340,10 @@ function width({ ...modifiersAndValues }) {
 	delete modifiersAndValues.max;
 	delete modifiersAndValues['max-content'];
 
-	return processModifiersAndProperties('width', { 'w': '{ width: {value} }' }, modifiersAndValues);
+	return processProperties({ 'prop': 'width', 'component': 'Ti.UI.ActivityIndicator, Ti.UI.Animation, Ti.UI.iPad.Popover, Ti.UI.ListItem, Ti.UI.View' }, {
+		'w':
+			'{ width: {value} }'
+	}, modifiersAndValues);
 }
 exports.width = width;
 
@@ -1191,30 +2355,73 @@ function height({ ...modifiersAndValues }) {
 	delete modifiersAndValues.max;
 	delete modifiersAndValues['max-content'];
 
-	return processModifiersAndProperties('height', { 'h': '{ height: {value} }' }, modifiersAndValues);
+	return processProperties({ 'prop': 'height', 'component': 'Ti.UI.ActivityIndicator, Ti.UI.Animation, Ti.UI.iPad.Popover, Ti.UI.ListItem, Ti.UI.View' }, {
+		'h': '{ height: {value} }'
+	}, modifiersAndValues);
 }
 exports.height = height;
 
-function testingAppPTSSFile() {
-	readCSS(srcAppPTSSFile, (err, data) => {
-		if (err) throw err
+//! The Mother Goose
+function customRules(_value, _key) {
+	//! Want to refactor
+	let convertedStyles = '';
 
-		let someData = _.map(data.stylesheet.rules, (processing) => {
-			let selector = processing.selectors[0];
-			let property = processing.declarations[0].property;
-			let __value = JSON.parse(processing.declarations[0].value);
-			let value = Array.isArray(__value) ? __value : __value.split(' ');
+	_.each(_value, (value, modifier) => {
+		if (modifier === 'apply') {
+			_applyClasses[_key] = new Set(Array.isArray(_value[modifier]) ? _value[modifier] : _value[modifier].split(' '));
 
-			return {
-				selector: selector,
-				property: property,
-				value: value
-			}
-		});
+			convertedStyles += `'${_key}': { {_applyProperties_} }\n`;
+		} else {
+			let customProperties = '';
 
-		console.log('Some Data:', someData);
+			_.each(value, (theValue, theModifier) => {
+				if (typeof (theValue) === 'object' && theValue !== null) {
+					if (theModifier === 'apply') {
+						_applyClasses[`${_key}${setModifier(modifier)}`] = new Set(Array.isArray(theValue) ? theValue : theValue.split(' '));
+
+						customProperties += ` {_applyProperties_},`;
+					} else {
+						customProperties += ` ${theModifier}: {`;
+
+						let extraCustomProperties = '';
+
+						_.each(theValue, (extraValue, extraModifier) => {
+							if (typeof (extraValue) === 'object' && extraValue !== null) {
+								customProperties += ` ${extraModifier}: {`;
+
+								let moreExtraCustomProperties = '';
+
+								_.each(extraValue, (moreExtraValue, moreModifier) => {
+									moreExtraCustomProperties += ` ${moreModifier}: ${parseValue(moreExtraValue)},`;
+								});
+
+								customProperties += `${remove_last_character(moreExtraCustomProperties)} },`;
+							} else {
+								extraCustomProperties += ` ${extraModifier}: ${parseValue(extraValue)},`;
+							}
+						});
+
+						customProperties += `${remove_last_character(extraCustomProperties)} },`;
+					}
+				} else {
+					if (theModifier === 'apply') {
+						_applyClasses[`${_key}${setModifier(modifier)}`] = new Set(Array.isArray(theValue) ? theValue : theValue.split(' '));
+
+						customProperties += ` {_applyProperties_},`;
+					} else {
+						customProperties += ` ${theModifier}: ${parseValue(theValue)},`;
+					}
+				}
+			});
+
+			convertedStyles += `'${_key}${setModifier(modifier)}': {${remove_last_character(customProperties)} }\n`;
+		}
 	});
+
+	return convertedStyles;
 }
+exports.customRules = customRules;
+
 //! The son of Mother Goose
 function applyProperties(twStyles) {
 	let twStylesArray = twStyles.split(/\r?\n/);
@@ -1284,6 +2491,66 @@ function applyProperties(twStyles) {
 }
 exports.applyProperties = applyProperties;
 
+function processProperties(info, selectorAndDeclarationBlock, selectorsAndValues, minusSigns = '') {
+	let convertedStyles = '';
+
+	if (typeof info === 'object') {
+		convertedStyles = processComments(info);
+	} else {
+		convertedStyles = `\n// ${info}\n`;
+	}
+
+	_.each(selectorAndDeclarationBlock, (declarationBlock, mainSelector) => {
+		_.each(selectorsAndValues, (value, secondSelector) => {
+			let selectorSign = (secondSelector.startsWith('-')) ? '-' : '';
+			if (typeof value === 'object') {
+				_.each(value, (_values, modifier) => {
+					if (typeof _values === 'object') {
+						_.each(_values, (__value, thirdSelector) => {
+							if (typeof __value === 'object') {
+								_.each(__value, (___value, fourthSelector) => {
+									let valores = _.replace(declarationBlock, new RegExp("{value}", "g"), parseValue(___value, minusSigns));
+									convertedStyles += (mainSelector === 'default') ?
+										`'.${selectorSign}${setModifier(secondSelector)}${setModifier(thirdSelector)}${setModifier(fourthSelector)}${setModifier(modifier)}': ${valores} \n` :
+										`'.${selectorSign}${mainSelector}-${secondSelector}${setModifier(thirdSelector)}${setModifier(fourthSelector)}${setModifier(modifier)}': ${valores} \n`;
+								});
+							} else {
+								let valores = _.replace(declarationBlock, new RegExp("{value}", "g"), parseValue(__value, minusSigns));
+								convertedStyles += (mainSelector === 'default') ?
+									`'.${selectorSign}${secondSelector}${setModifier(thirdSelector)}${setModifier(modifier)}': ${valores}\n` :
+									`'.${selectorSign}${mainSelector}-${secondSelector}${setModifier(thirdSelector)}${setModifier(modifier)}': ${valores}\n`;
+							}
+						});
+					} else {
+						let valores = _.replace(declarationBlock, new RegExp("{value}", "g"), parseValue(_values, minusSigns));
+						convertedStyles += (mainSelector === 'default') ?
+							`'.${selectorSign}${setModifier(secondSelector)}${setModifier(modifier)}': ${valores}\n` :
+							`'.${selectorSign}${mainSelector}${setModifier(secondSelector)}${setModifier(modifier)}': ${valores}\n`;
+					}
+				});
+			} else {
+				let valores = _.replace(declarationBlock, new RegExp("{value}", "g"), parseValue(value, minusSigns));
+				convertedStyles += (mainSelector === 'default') ?
+					`'.${selectorSign}${secondSelector}': ${valores}\n` :
+					`'.${selectorSign}${mainSelector}${setModifier(secondSelector)}': ${valores}\n`;
+			}
+		});
+	});
+
+	return convertedStyles;
+}
+exports.processProperties = processProperties;
+
+function processComments(info) {
+	let comments = '';
+
+	comments += (info.component) ? `\n// Component(s): ${info.component}` : '';
+	comments += (info.prop) ? `\n// Property(ies): ${info.prop}\n` : '';
+	comments += (info.description) ? `// Description: ${info.description}\n` : '';
+
+	return comments;
+}
+
 function checkColorClasses(cleanClassName) {
 	return (
 		cleanClassName.startsWith('active-tint-') ||
@@ -1295,6 +2562,7 @@ function checkColorClasses(cleanClassName) {
 		cleanClassName.startsWith('current-page-') ||
 		cleanClassName.startsWith('feedback-') ||
 		cleanClassName.startsWith('from-') ||
+		cleanClassName.startsWith('indicator-') ||
 		cleanClassName.startsWith('nav-tint-') ||
 		cleanClassName.startsWith('page-') ||
 		cleanClassName.startsWith('paging-') ||
@@ -1314,6 +2582,138 @@ function findIndexOf(_substring, _array) {
 }
 exports.findIndexOf = findIndexOf;
 
+function checkPlatformAndDevice(line, className) {
+	// https://regex101.com/r/6VTh23/1
+	if (className.includes('ios:')) {
+		return (line.includes('platform=ios'))
+			? `${line.replace(/[^'.][^']+|1/, `ios:$&`)}\n`
+			: `${line.replace(/[^'.][^']+|1/, `ios:$&[platform=ios]`)}\n`;
+	} else if (className.includes('android:')) {
+		return (line.includes('platform=android'))
+			? `${line.replace(/[^'.][^']+|1/, `android:$&`)}\n`
+			: `${line.replace(/[^'.][^']+|1/, `android:$&[platform=android]`)}\n`;
+	} else if (className.includes('handheld:')) {
+		return (line.includes('formFactor=handheld'))
+			? `${line.replace(/[^'.][^']+|1/, `handheld:$&`)}\n`
+			: `${line.replace(/[^'.][^']+|1/, `handheld:$&[formFactor=handheld]`)}\n`;
+	} else if (className.includes('tablet:')) {
+		return (line.includes('formFactor=tablet'))
+			? `${line.replace(/[^'.][^']+|1/, `tablet:$&`)}\n`
+			: `${line.replace(/[^'.][^']+|1/, `tablet:$&[formFactor=tablet]`)}\n`;
+	} else if (className.includes('open:')) {
+		return `${line.replace(/[^'.][^']+|1/, `open:$&`).replace(/{(.*)}/, '{ animation: { open: $& } }')}\n`;
+	} else if (className.includes('close:')) {
+		return `${line.replace(/[^'.][^']+|1/, `close:$&`).replace(/{(.*)}/, '{ animation: { close: $& } }')}\n`;
+	} else if (className.includes('complete:')) {
+		return `${line.replace(/[^'.][^']+|1/, `complete:$&`).replace(/{(.*)}/, '{ animation: { complete: $& } }')}\n`;
+	} else if (className.includes('bounds:') && (line.includes('top') || line.includes('right') || line.includes('bottom') || line.includes('left'))) {
+		return `${line.replace(/[^'.][^']+|1/, `bounds:$&`).replace(/{(.*)}/, '{ bounds: $& }')}\n`;
+	} else if (className.includes('drag:')) {
+		return `${line.replace(/[^'.][^']+|1/, `drag:$&`).replace(/{(.*)}/, '{ draggable: { drag: $& } }')}\n`;
+	} else if (className.includes('drop:')) {
+		return `${line.replace(/[^'.][^']+|1/, `drop:$&`).replace(/{(.*)}/, '{ draggable: { drop: $& } }')}\n`;
+	} else {
+		return `${line}\n`;
+	}
+}
+exports.checkPlatformAndDevice = checkPlatformAndDevice;
+
+function parseValue(value, sign = '') {
+	if (value === '') return `''`;
+
+	// Hack for unicode values
+	if (/[^\u0000-\u00ff]/.test(value)) {
+		return `'\\u${value.charCodeAt(0).toString(16)}'`;
+	}
+
+	if (value === '0px') {
+		value = 0;
+	}
+
+	let unit = isNaN(value) ? checkTitanium(value) : value;
+
+	switch (unit) {
+		case '0':
+		case true:
+		case false:
+		case 'titanium':
+			return `${sign}${value}`;
+		case 'vw':
+		case 'vh':
+		case 'screen':
+			return 'Ti.UI.FILL';
+		case 'auto':
+			return 'Ti.UI.SIZE';
+		case 'none':
+		case 'null':
+			return null;
+		case 'rem':
+			return `${sign}${16 * parseFloat(value)}`;
+		case 'dp':
+			return `${sign}${parseFloat(value)}`;
+		case 'hex':
+			return toHex(value);
+		case 'deg':
+			return parseFloat(value);
+		case 'ms':
+			return parseFloat(value);
+		case 'transparent':
+			return `'${value}'`;
+		default:
+			return isNaN(value) ? `'${sign}${value}'` : `${sign}${value}`;
+	}
+}
+exports.parseValue = parseValue;
+
+function addTransparencyToValue(color) {
+	if (color.includes('#')) {
+		switch (color.length) {
+			case 4:
+				color = `#0${color[0]}${color[1]}${color[2]}`
+				break;
+			case 7:
+				color = `#00${color[0]}${color[1]}${color[2]}${color[3]}${color[4]}${color[5]}`
+				break;
+			case 9:
+				color = `#00${color[2]}${color[3]}${color[4]}${color[5]}${color[6]}${color[7]}`
+				break;
+			case 11:
+				color = `#00${color[4]}${color[5]}${color[6]}${color[7]}${color[8]}${color[9]}`
+				break;
+		}
+		return `'${color}'`;
+	} else if (color.match(/rgba?/i)) {
+		const rgba = color.replace(/[\[\]')]+/g, '').split(',');
+		color = `'${rgba[0].trim()}, ${rgba[1].trim()}, ${rgba[2].trim()}, 0)'`;
+	}
+
+	return color;
+}
+exports.addTransparencyToValue = addTransparencyToValue;
+
+function addTransparencyToHex(color, transparency = '00') {
+	if (color.includes('#')) {
+		if (color.includes('\'')) {
+			color = color.replace(/'/g, '');
+		}
+		switch (color.length) {
+			case 4:
+				color = `#${transparency}${color[1]}${color[2]}${color[3]}`
+				break;
+			case 7:
+				color = `#${transparency}${color[1]}${color[2]}${color[3]}${color[4]}${color[5]}${color[6]}`
+				break;
+			case 9:
+				color = `#${transparency}${color[3]}${color[4]}${color[5]}${color[6]}${color[7]}${color[8]}`
+				break;
+		}
+	}
+
+	return `'${color}'`;
+}
+exports.addTransparencyToHex = addTransparencyToHex;
+
+//! Private Functions
 function fixDuplicateKeys(compoundClasses) {
 	compoundClasses.sort();
 
@@ -1366,10 +2766,10 @@ function fixDuplicateKeys(compoundClasses) {
 }
 
 const arbitraryValuesTable = {
-	// Check if they are really needed
-
 	'active-tint': 'activeTintColor: {value}',
 	'active-title': 'activeTitleColor: {value}',
+	'bar-title': 'titleAttributes : { color : {value} }',
+	'bar-title-shadow': 'titleAttributes: { shadow: { color: {value} } }',
 	'bar': 'barColor: {value}',
 	'bg-selected': 'backgroundSelectedColor: {value}',
 	'bg': 'backgroundColor: {value}',
@@ -1382,6 +2782,7 @@ const arbitraryValuesTable = {
 	'content': 'contentWidth: {value}, contentHeight: {value}',
 	'current-page': 'currentPageIndicatorColor: {value}',
 	'delay': 'delay: {value}',
+	'drop-shadow': 'shadowColor: {value} }',
 	'duration': 'duration: {value}',
 	'feedback': 'touchFeedback: true, touchFeedbackColor: {value}',
 	'font': 'font: { fontWeight: {value} }',
@@ -1389,6 +2790,7 @@ const arbitraryValuesTable = {
 	'grid-cols': 'width: Alloy.Globals.cols_{value}',
 	'grid-rows': 'height: Alloy.Globals.rows_{value}',
 	'h': 'height: {value}',
+	'indicator': 'indicatorColor: {value}',
 	'left': 'left: {value}',
 	'm': 'top: {value}, right: {value}, bottom: {value}, left: {value}',
 	'max-scale': 'maxZoomScale: {value}',
@@ -1403,6 +2805,9 @@ const arbitraryValuesTable = {
 	'opacity': 'opacity: {value}',
 	'origin': 'anchorPoint: { x: {value}, y: {value1} }',
 	'p': 'padding: { top: {value}, right: {value}, bottom: {value}, left: {value} }',
+	'padding-bottom': 'paddingBottom: {value}',
+	'padding-left': 'paddingLeft: {value}',
+	'padding-right': 'paddingRight: {value}',
 	'page': 'pageIndicatorColor: {value}',
 	'paging-alpha': 'pagingControlAlpha: {value}',
 	'paging-color': 'pagingControlColor: {value}',
@@ -1417,15 +2822,15 @@ const arbitraryValuesTable = {
 	'right': 'right: {value}',
 	'rotate': 'rotate: {value}',
 	'rounded': 'borderRadius: {value}',
-	'shadow': 'viewShadowColor: {value}',
+	'shadow': 'viewShadowColor: {value} }',
 	'tabs-bg': 'tabsBackgroundColor: {value}',
 	'text-color': 'color: {value}',
 	'text-size': 'font: { fontSize: {value} }',
-	'tint': 'tintColor: {value}',
+	'tint': 'tint: {value}, tintColor: {value}',
 	'title': 'titleColor: {value}',
 	'to': 'backgroundGradient: { colors: [ {value} ] }',
 	'top': 'top: {value}',
-	'w': 'width: {value}'
+	'w': 'width: {value}',
 };
 
 function formatArbitraryValues(arbitraryValue) {
@@ -1495,177 +2900,6 @@ function formatArbitraryValues(arbitraryValue) {
 	return null;
 }
 
-//! The Mother Goose
-function customRules(_value, _key) {
-	//! Want to refactor
-	let convertedStyles = '';
-
-	_.each(_value, (value, modifier) => {
-		if (modifier === 'apply') {
-			_applyClasses[_key] = new Set(Array.isArray(_value[modifier]) ? _value[modifier] : _value[modifier].split(' '));
-
-			convertedStyles += `'${_key}': { {_applyProperties_} }\n`;
-		} else {
-			let customProperties = '';
-
-			_.each(value, (theValue, theModifier) => {
-				if (typeof (theValue) === 'object' && theValue !== null) {
-					if (theModifier === 'apply') {
-						_applyClasses[`${_key}${setModifier(modifier)}`] = new Set(Array.isArray(theValue) ? theValue : theValue.split(' '));
-
-						customProperties += ` {_applyProperties_},`;
-					} else {
-						customProperties += ` ${theModifier}: {`;
-
-						let extraCustomProperties = '';
-
-						_.each(theValue, (extraValue, extraModifier) => {
-							if (typeof (extraValue) === 'object' && extraValue !== null) {
-								customProperties += ` ${extraModifier}: {`;
-
-								let moreExtraCustomProperties = '';
-
-								_.each(extraValue, (moreExtraValue, moreModifier) => {
-									moreExtraCustomProperties += ` ${moreModifier}: ${parseValue(moreExtraValue)},`;
-								});
-
-								customProperties += `${remove_last_character(moreExtraCustomProperties)} },`;
-							} else {
-								extraCustomProperties += ` ${extraModifier}: ${parseValue(extraValue)},`;
-							}
-						});
-
-						customProperties += `${remove_last_character(extraCustomProperties)} },`;
-					}
-				} else {
-					if (theModifier === 'apply') {
-						_applyClasses[`${_key}${setModifier(modifier)}`] = new Set(Array.isArray(theValue) ? theValue : theValue.split(' '));
-
-						customProperties += ` {_applyProperties_},`;
-					} else {
-						customProperties += ` ${theModifier}: ${parseValue(theValue)},`;
-					}
-				}
-			});
-
-			convertedStyles += `'${_key}${setModifier(modifier)}': {${remove_last_character(customProperties)} }\n`;
-		}
-	});
-
-	return convertedStyles;
-}
-exports.customRules = customRules;
-
-function checkPlatformAndDevice(line, className) {
-	// https://regex101.com/r/6VTh23/1
-	if (className.includes('ios:')) {
-		return (line.includes('platform=ios'))
-			? `${line.replace(/[^'.][^']+|1/, `ios:$&`)}\n`
-			: `${line.replace(/[^'.][^']+|1/, `ios:$&[platform=ios]`)}\n`;
-	} else if (className.includes('android:')) {
-		return (line.includes('platform=android'))
-			? `${line.replace(/[^'.][^']+|1/, `android:$&`)}\n`
-			: `${line.replace(/[^'.][^']+|1/, `android:$&[platform=android]`)}\n`;
-	} else if (className.includes('handheld:')) {
-		return (line.includes('formFactor=handheld'))
-			? `${line.replace(/[^'.][^']+|1/, `handheld:$&`)}\n`
-			: `${line.replace(/[^'.][^']+|1/, `handheld:$&[formFactor=handheld]`)}\n`;
-	} else if (className.includes('tablet:')) {
-		return (line.includes('formFactor=tablet'))
-			? `${line.replace(/[^'.][^']+|1/, `tablet:$&`)}\n`
-			: `${line.replace(/[^'.][^']+|1/, `tablet:$&[formFactor=tablet]`)}\n`;
-	} else if (className.includes('open:')) {
-		return `${line.replace(/[^'.][^']+|1/, `open:$&`).replace(/{(.*)}/, '{ animation: { open: $& } }')}\n`;
-	} else if (className.includes('close:')) {
-		return `${line.replace(/[^'.][^']+|1/, `close:$&`).replace(/{(.*)}/, '{ animation: { close: $& } }')}\n`;
-	} else if (className.includes('complete:')) {
-		return `${line.replace(/[^'.][^']+|1/, `complete:$&`).replace(/{(.*)}/, '{ animation: { complete: $& } }')}\n`;
-	} else if (className.includes('bounds:') && (line.includes('top') || line.includes('right') || line.includes('bottom') || line.includes('left'))) {
-		return `${line.replace(/[^'.][^']+|1/, `bounds:$&`).replace(/{(.*)}/, '{ bounds: $& }')}\n`;
-	} else if (className.includes('drag:')) {
-		return `${line.replace(/[^'.][^']+|1/, `drag:$&`).replace(/{(.*)}/, '{ draggable: { drag: $& } }')}\n`;
-	} else if (className.includes('drop:')) {
-		return `${line.replace(/[^'.][^']+|1/, `drop:$&`).replace(/{(.*)}/, '{ draggable: { drop: $& } }')}\n`;
-	} else {
-		return `${line}\n`;
-	}
-}
-exports.checkPlatformAndDevice = checkPlatformAndDevice;
-
-function parseValue(value, sign = '') {
-	if (value === '') return `''`;
-
-	// Hack for unicode values
-	if (/[^\u0000-\u00ff]/.test(value)) {
-		return `'\\u${value.charCodeAt(0).toString(16)}'`;
-	}
-
-	if (value === '0px') {
-		value = 0;
-	}
-
-	let unit = isNaN(value) ? checkTitanium(value) : value;
-
-	switch (unit) {
-		case '0':
-		case true:
-		case false:
-		case 'titanium':
-			return `${sign}${value}`;
-		case 'vw':
-		case 'vh':
-		case 'screen':
-			return 'Ti.UI.FILL';
-		case 'auto':
-			return 'Ti.UI.SIZE';
-		case 'none':
-		case 'null':
-			return null;
-		case 'rem':
-			return `${sign}${16 * parseFloat(value)}`;
-		case 'dp':
-			return `${sign}${parseFloat(value)}`;
-		case 'hex':
-			return toHex(value);
-		case 'deg':
-			return parseFloat(value);
-		case 'ms':
-			return parseFloat(value);
-		case 'transparent':
-			return `'${value}'`;
-		default:
-			return isNaN(value) ? `'${sign}${value}'` : `${sign}${value}`;
-	}
-}
-exports.parseValue = parseValue;
-
-function addTransparencyToValue(color) {
-	if (color.includes('#')) {
-		switch (color.length) {
-			case 4:
-				color = `#0${color[0]}${color[1]}${color[2]}`
-				break;
-			case 7:
-				color = `#00${color[0]}${color[1]}${color[2]}${color[3]}${color[4]}${color[5]}`
-				break;
-			case 9:
-				color = `#00${color[2]}${color[3]}${color[4]}${color[5]}${color[6]}${color[7]}`
-				break;
-			case 11:
-				color = `#00${color[4]}${color[5]}${color[6]}${color[7]}${color[8]}${color[9]}`
-				break;
-		}
-		return `'${color}'`;
-	} else if (color.match(/rgba?/i)) {
-		const rgba = color.replace(/[\[\]')]+/g, '').split(',');
-		color = `'${rgba[0].trim()}, ${rgba[1].trim()}, ${rgba[2].trim()}, 0)'`;
-	}
-
-	return color;
-}
-exports.addTransparencyToValue = addTransparencyToValue;
-
-//! Private Functions
 function setModifier(modifier) {
 	if (defaultModifier(modifier)) {
 		modifier = '';
@@ -1689,7 +2923,7 @@ function setModifier(modifier) {
 }
 
 function defaultModifier(modifier) {
-	return modifier === 'global' || modifier === 'default' || modifier === 'DEFAULT';
+	return modifier === '' || modifier === 'global' || modifier === 'default' || modifier === 'DEFAULT';
 }
 
 function checkTitanium(value) {
@@ -1753,20 +2987,6 @@ function rgbToHex(color) {
 	return `#${alpha}${((1 << 24) + (parseInt(rgba[0]) << 16) + (parseInt(rgba[1]) << 8) + parseInt(rgba[2])).toString(16).slice(1)}`;
 }
 
-function convertHexToRGBA(hexCode, opacity) {
-	let hex = hexCode.replace('#', '');
-
-	if (hex.length === 3) {
-		hex = `${hex[0]}${hex[0]}${hex[1]}${hex[1]}${hex[2]}${hex[2]}`;
-	}
-
-	const r = parseInt(hex.substring(0, 2), 16);
-	const g = parseInt(hex.substring(2, 4), 16);
-	const b = parseInt(hex.substring(4, 6), 16);
-
-	return `rgba(${r},${g},${b},${opacity / 100})`;
-}
-
 function defaultColors(color) {
 	const colors = {
 		aqua: '#00FFFF',
@@ -1924,24 +3144,67 @@ function defaultColors(color) {
 	return colors[color] || null;
 }
 
-function addTransparencyToHex(color, transparency = '00') {
-	if (color.includes('#')) {
-		if (color.includes('\'')) {
-			color = color.replace(/'/g, '');
-		}
-		switch (color.length) {
-			case 4:
-				color = `#${transparency}${color[1]}${color[2]}${color[3]}`
-				break;
-			case 7:
-				color = `#${transparency}${color[1]}${color[2]}${color[3]}${color[4]}${color[5]}${color[6]}`
-				break;
-			case 9:
-				color = `#${transparency}${color[3]}${color[4]}${color[5]}${color[6]}${color[7]}${color[8]}`
-				break;
-		}
+//! RecycleBin
+function convertHexToRGBA(hexCode, opacity) {
+	let hex = hexCode.replace('#', '');
+
+	if (hex.length === 3) {
+		hex = `${hex[0]}${hex[0]}${hex[1]}${hex[1]}${hex[2]}${hex[2]}`;
 	}
 
-	return `'${color}'`;
+	const r = parseInt(hex.substring(0, 2), 16);
+	const g = parseInt(hex.substring(2, 4), 16);
+	const b = parseInt(hex.substring(4, 6), 16);
+
+	return `rgba(${r},${g},${b},${opacity / 100})`;
 }
-exports.addTransparencyToHex = addTransparencyToHex;
+
+function processModifiersAndProperties(header, objectPosition, modifiersAndValues, minusSigns = '') {
+	let convertedStyles = `\n// ${header} Property\n`;
+
+	_.each(objectPosition, (properties, rule) => {
+		_.each(modifiersAndValues, (value, modifier) => {
+			let ruleSign = (modifier.startsWith('-')) ? '-' : '';
+			if (typeof value === 'object') {
+				_.each(value, (_value, _modifier) => {
+					convertedStyles += `'.${ruleSign}${rule}-${modifier}${setModifier(_modifier)}': ` + _.replace(properties, new RegExp("{value}", "g"), parseValue(_value, minusSigns)) + '\n';
+				});
+			} else {
+				convertedStyles += `'.${ruleSign}${rule}${setModifier(modifier)}': ` + _.replace(properties, new RegExp("{value}", "g"), parseValue(value, minusSigns)) + '\n';
+			}
+		});
+	});
+
+	return convertedStyles;
+}
+
+function testingAppPTSSFile() {
+	readCSS(srcAppPTSSFile, (err, data) => {
+		if (err) throw err
+
+		let someData = _.map(data.stylesheet.rules, (processing) => {
+			let selector = processing.selectors[0];
+			let property = processing.declarations[0].property;
+			let __value = JSON.parse(processing.declarations[0].value);
+			let value = Array.isArray(__value) ? __value : __value.split(' ');
+
+			return {
+				selector: selector,
+				property: property,
+				value: value
+			}
+		});
+
+		console.log('Some Data:', someData);
+	});
+}
+
+function selectionIndicator() {
+	return processProperties({ 'prop': 'selectionIndicator', 'component': 'Ti.UI.Picker' }, {
+		'default': '{ selectionIndicator: {value} }'
+	}, {
+		'show-selection-indicator': true,
+		'hide-selection-indicator': false,
+	});
+}
+exports.selectionIndicator = selectionIndicator;