sheel-deer 1.0.0

package/src/methods/parsers.ts

@@ -0,0 +1,1012 @@
+import fs from "fs";
+import path from "path";
+import { ComponentData, DataProperty, getCurrentSquaring, ImportData, Methods, NotationData, setCurrentSquaring, Squaring, SquaringParameters } from '../components/squaring';
+import { commentSeparation, componentTypeSeparator, eventTypeSeparator, classDeclartionSeparator, importTypeSeparator, methodReturnTypeBitMap, methodTypeSeparator, NotationTypeSeparator, rowSeparation, typeBitMap, newRow, newTab, propertyCloseSeparator, nullable, empty, using } from '../data/binary-resources';
+import { DataList, DataListType } from '../models/data-type-model';
+import { asciiTable } from './../data/ascii';
+import { TsSquareMethods } from './square';
+import { byteMapStartWith, trimWhiteSpaceFromLeft, isArrayEqual, splitArray, findLast, isListEqual, startsWithMultipleByteMap, removeArrayExclamationMark, setProperty, indexOf, atPosition } from './array-helpers';
+import { ContentFile, CurrentRow } from '../models/ascii';
+import { bracketsEndNotFound, bracketsStartNotFound, closingSeparatorNotFound, propertyIsNull } from '../methods/errors-helpers';
+
+export const returnCssLinkByteArray = (cssPage: string) => {
+    let string = `<link rel="stylesheet" href="./${cssPage}.css">`;
+    let result = [] as number[];
+
+    for(let char of string){
+        result = [...result, asciiTable.ascii.find(x=> x.char == char)!.code];
+    }
+    
+    return result;
+}
+
+export const returnJSLinkByteArray = (jsPage: string) => {
+    let string = `<script src='${jsPage}.js'></script>`;
+
+    let result = [] as number[];
+
+    for(let char of string){
+        result = [...result, asciiTable.ascii.find(x=> x.char == char)!.code];
+    }
+    
+    return result;
+}
+
+
+export const TranslateRegularPage = (number: number[], name: string = '') : { arrays: number[] }[] => {
+    let data: DataList = new DataList();
+    let trimWhiteSpace: number[] = [];
+    let prevWasSpace = false;
+
+    for (let i = 0; i < number.length; i++) {
+        if (number[i] === 32) {
+            if (!prevWasSpace) {
+                trimWhiteSpace = [...trimWhiteSpace, 32];
+                prevWasSpace = true;
+            }
+        } else {
+            trimWhiteSpace = [...trimWhiteSpace, number[i]];
+            prevWasSpace = false;
+        }
+    }
+
+    let i = 0;
+    for(let num of trimWhiteSpace){
+        if(i == trimWhiteSpace.length - 1) { break; }
+        if(!data.list.length){
+            data.list[i] = new DataListType();
+            data.list[i].array = [num];
+
+        }else if(i > 0 && fitRowSeparator(num, data.list[i - 1].array[data.list[i - 1].array.length - 1])){
+            i++;
+            data.list[i].array = [...data.list[i].array, num];
+        }else{
+            data.list[i].array = [...data.list[i].array, num];
+        }
+    }
+
+    let square = new TsSquareMethods();
+
+    let squaring: Squaring = new Squaring();
+
+    let squaringComponents: ComponentData[] = [];
+    let notations: NotationData[] = [];
+    let methods: Methods[] = [];
+    let imports: ImportData[] = [];
+
+    squaringComponents = [{
+        name: "",
+        properties: [],
+        template: "",
+        annotations: [],
+        version: "1.0.0"
+    } as ComponentData];
+
+    notations = [{
+        name: "",
+        properties: [],
+        template: "",
+        annotations: [],
+        version: "1.0.0"
+    } as NotationData];
+
+    methods = [{
+        name: "",
+        type: "",
+        body: [],
+        value: null,
+        parameters: [],
+        returnType: "" 
+    } as Methods];
+
+    imports = [{
+        name: "",
+        type: "",
+        properties: []
+    } as ImportData];
+
+    squaring.data = square.createComponentData(squaringComponents, notations, methods, imports);
+    let content = fromAscii(data.list[0].array).split('\n');
+    squaring.name = "Inital";
+
+    let squaringParameters: SquaringParameters[] = []
+
+    let bracketValue = "";
+    let bracketClosed = true;
+    let bracketProperty: DataProperty | null = null;
+    for(let listItem of content){
+        let dataRow = fromString(listItem);
+       
+        if(dataRow.length && 
+           !byteMapStartWith(dataRow, commentSeparation.bitMap) && 
+           !(dataRow.length == 1 && dataRow[0] == 32)) {
+
+                ///using statement
+                if(byteMapStartWith(dataRow, using.bitMap) && bracketClosed){
+                    let array = splitArray(dataRow, 32); let value;
+                    let property = square.createComponentProperty(fromAscii(array[1]), fromAscii(array[0]), value, value == null || value == undefined ? true : false);
+
+                    let usingStatements = splitArray(dataRow, 32);
+                    let using = atPosition(usingStatements, 0);
+                    let from = atPosition(usingStatements, 1);
+
+                    squaringParameters = [...squaringParameters, { 
+                        name: fromAscii(using),
+                        path: fromAscii(from),
+                        parameters: [fromAscii(using), fromAscii(from)],
+                        version: "1.0.0"
+                    } as SquaringParameters]
+                }  
+
+                ///dataType string title = "";
+                for(let tbm of typeBitMap){
+                    if(byteMapStartWith(trimWhiteSpaceFromLeft(dataRow), tbm.code)){
+                        let array = splitArray(dataRow, 32); let value;
+                        let property = square.createComponentProperty(fromAscii(array[1]), fromAscii(array[0]), value, value == null || value == undefined ? true : false);
+        
+                        let usingStatements = splitArray(dataRow, 32);
+                        let using = atPosition(usingStatements, 0);
+                        let from = atPosition(usingStatements, 1);
+
+                        if(closingSeparatorNotFound(from)){
+                            let equal = atPosition(usingStatements, 2);
+
+                            if(bracketsStartNotFound(from)){
+                                try{
+                                    bracketValue += fromAscii(atPosition(usingStatements, 3));
+                                    bracketValue += newRow.name;
+                                    bracketClosed = false;
+                                    bracketProperty = property;
+
+                                }catch(ex){
+
+                                }
+                                
+                            }else{
+                                bracketValue += fromAscii(atPosition(usingStatements, 3));
+                                bracketValue += newRow.name;
+                                bracketClosed = false;
+                                bracketProperty = property;
+                            }
+                        }
+
+                        if(!closingSeparatorNotFound(from)){
+                            let equal = atPosition(usingStatements, 2);
+                            let value = atPosition(usingStatements, 3);
+                            property.value = value;
+                            property.nullable = propertyIsNull(dataRow);
+                            squaring.data.components[0].properties.push(property);
+                        }
+
+                    }   
+
+                    if(!bracketClosed){
+                        if(bracketsEndNotFound(dataRow)){
+                            bracketValue += fromAscii(dataRow);
+                            bracketValue += newRow.name;
+                            bracketProperty!.value += bracketValue;
+                        }else{
+                            if(closingSeparatorNotFound(dataRow)){
+                                bracketValue += fromAscii(dataRow); 
+                                bracketValue += newRow.name;
+                                bracketProperty!.value += bracketValue;
+                            }else{
+                                bracketValue += fromAscii(dataRow); 
+                                bracketValue += newRow.name;
+                                bracketProperty!.value += bracketValue;
+                                squaring.data.components[0].properties.push(bracketProperty!);
+                                bracketClosed = true;
+                                bracketProperty = null;
+                            }
+                        }
+                    }
+
+                } 
+
+                ///methodType override void beforeInit()
+                let currentRow = new CurrentRow();
+                for(let mts of methodReturnTypeBitMap){
+                    if(byteMapStartWith(trimWhiteSpaceFromLeft(dataRow), mts.code) && !currentRow.begin){
+                        let array = splitArray(dataRow, 32);
+                        let name = fromAscii(array[2]).replace(/[^a-zA-Z]/g, '');
+                        let returnType = fromAscii(array[1]);
+                        let method = square.createSquareMethods(name.replace('()', ''), returnType, null, [], returnType);
+                        squaring.data.methods.push(method);   
+
+                        currentRow.begin = true;
+                        currentRow.current = currentRow.out;
+                        currentRow.currentData = dataRow;
+                    }else if(currentRow.begin && 
+                            currentRow.current == currentRow.out && 
+                            !byteMapStartWith(trimWhiteSpaceFromLeft(dataRow), mts.code), !byteMapStartWith(trimWhiteSpaceFromLeft(dataRow), [125]) && 
+                            !equal(dataRow, currentRow.currentData) && 
+                            !startsWithMultipleByteMap(dataRow, methodReturnTypeBitMap)){      
+                        currentRow.lastDataBody = currentRow.currentDataBody;
+                        currentRow.currentDataBody = dataRow;
+
+                        if(!equal(currentRow.lastDataBody, currentRow.currentDataBody) || currentRow.lastDataBody.length == 0){
+                            let method = findLast(squaring.data.methods);
+                            method.body.push(fromAscii(dataRow));
+                            method.body.push(newRow.name);
+                        }
+                    }else{
+                        currentRow.begin = false;
+                        currentRow.out = currentRow.out++;
+                    }
+                }
+
+            }
+    }
+
+    let contentFile = new ContentFile();
+    for(let item of squaring.data.squaringReferences){
+        for(let parameters of item.squaringParameters){
+            contentFile.contentFile.push(`import ${parameters.name} from ${parameters.path}`);
+            contentFile.contentFile.push(newRow.name);
+        }
+    }
+
+    contentFile.contentFile.push(newRow.name);
+    contentFile.contentFile.push(newRow.name);
+    contentFile.contentFile.push(`export default class ${squaring.name} extends Component {`);
+    contentFile.contentFile.push(newRow.name);
+
+    for(let item of squaring.data.components){
+        for(let property of item.properties){
+            contentFile.contentFile.push(newTab.name);
+            contentFile.contentFile.push(`${property.name}${property.nullable ? nullable.name: empty.name}: ${property.type}`);
+            contentFile = setProperty(property, contentFile);
+            contentFile.contentFile.push(`${fromAscii(propertyCloseSeparator.bitMap)}`);
+            contentFile.contentFile.push(newRow.name);
+        }
+    }
+
+    for(let item of squaring.data.notations){
+        for(let property of item.properties){
+            contentFile.contentFile.push(newTab.name);
+            contentFile.contentFile.push(`${property.name}${property.nullable ? nullable.name: empty.name}: ${property.type}`);
+            contentFile = setProperty(property, contentFile);
+            contentFile.contentFile.push(`${fromAscii(propertyCloseSeparator.bitMap)}`);
+            contentFile.contentFile.push(newRow.name);
+        }
+    }
+
+    for(let item of squaring.data.methods){
+        if(item.name){
+            contentFile.contentFile.push(newTab.name);
+            contentFile.contentFile.push(`\t${item.name}`);
+            if(item.parameters.length){
+                for(let parameter of item.parameters){
+                    contentFile.contentFile.push(newTab.name);
+                    contentFile.contentFile.push(`(${parameter.name}: ${parameter.type}) `);
+                    contentFile.contentFile.push(newRow.name);
+                }
+            }
+            else{
+                contentFile.contentFile.push(newTab.name);
+                contentFile.contentFile.push('()');
+                contentFile.contentFile.push(newRow.name);
+            }
+
+            contentFile.contentFile.push(newTab.name);
+            contentFile.contentFile.push(`: ${item.returnType} {`);
+            contentFile.contentFile.push(newRow.name);
+            if(item.body.length){
+                contentFile.contentFile.push(newTab.name);
+                for(let bd of item.body){
+                    contentFile.contentFile.push(`${bd}`);
+                }
+                contentFile.contentFile.push(`${newRow.name}`);
+            }
+            contentFile.contentFile.push(newTab.name);
+            contentFile.contentFile.push(`}`);
+            contentFile.contentFile.push(newRow.name);
+        }
+    }
+
+    contentFile.contentFile.push(newRow.name);
+    contentFile.contentFile.push(`}`);
+
+
+    setCurrentSquaring([...getCurrentSquaring(), squaring])
+    return createFromString(contentFile);
+}
+
+
+
+export const translateTS = (number: number[], name: string = '') : { arrays: number[] }[] => {
+    let data: DataList = new DataList();
+    let trimWhiteSpace: number[] = [];
+    let prevWasSpace = false;
+
+    for (let i = 0; i < number.length; i++) {
+        if (number[i] === 32) {
+            if (!prevWasSpace) {
+                trimWhiteSpace = [...trimWhiteSpace, 32];
+                prevWasSpace = true;
+            }
+        } else {
+            trimWhiteSpace = [...trimWhiteSpace, number[i]];
+            prevWasSpace = false;
+        }
+    }
+
+    let i = 0;
+    for(let num of trimWhiteSpace){
+        if(i == trimWhiteSpace.length - 1) { break; }
+        if(!data.list.length){
+            data.list[i] = new DataListType();
+            data.list[i].array = [num];
+
+        }else if(i > 0 && fitRowSeparator(num, data.list[i - 1].array[data.list[i - 1].array.length - 1])){
+            i++;
+            data.list[i].array = [...data.list[i].array, num];
+        }else{
+            data.list[i].array = [...data.list[i].array, num];
+        }
+    }
+
+    let result: number[] = [];
+
+    let square = new TsSquareMethods();
+
+    let squaring: Squaring = new Squaring();
+
+    let squaringComponents: ComponentData[] = [];
+    let notations: NotationData[] = [];
+    let methods: Methods[] = [];
+    let imports: ImportData[] = [];
+
+    squaringComponents = [{
+        name: "",
+        properties: [],
+        template: "",
+        annotations: [],
+        version: "1.0.0"
+    } as ComponentData];
+
+    notations = [{
+        name: "",
+        properties: [],
+        template: "",
+        annotations: [],
+        version: "1.0.0"
+    } as NotationData];
+
+    methods = [{
+        name: "",
+        type: "",
+        body: [],
+        value: null,
+        parameters: [],
+        returnType: "" 
+    } as Methods];
+
+    imports = [{
+        name: "",
+        type: "",
+        properties: []
+    } as ImportData];
+
+    let squaringParameters: SquaringParameters[] = []
+    squaring.data = square.createComponentData(squaringComponents, notations, methods, imports);
+    let content = fromAscii(data.list[0].array).split('\n');
+    for(let listItem of content){
+        let dataRow = fromString(listItem);
+       
+        if(dataRow.length && 
+           !byteMapStartWith(dataRow, commentSeparation.bitMap) && 
+           !(dataRow.length == 1 && dataRow[0] == 32)) {
+
+            ///class declaration => public class App {
+            if(isArrayEqual(classDeclartionSeparator.bitMap, trimWhiteSpaceFromLeft(dataRow).slice(0, classDeclartionSeparator.bitMap.length))){    
+                let name = splitArray(dataRow, 32)[2];
+                squaring.name = fromAscii(name);
+            }
+
+
+            ///using statement
+            if(byteMapStartWith(dataRow, using.bitMap)){
+                let array = splitArray(dataRow, 32); let value;
+                let property = square.createComponentProperty(fromAscii(array[1]), fromAscii(array[0]), value, value == null || value == undefined ? true : false);
+
+                let usingStatements = splitArray(dataRow, 32);
+                let using = atPosition(usingStatements, 0);
+                let from = atPosition(usingStatements, 1);
+
+                squaringParameters = [...squaringParameters, { 
+                    name: fromAscii(using),
+                    path: fromAscii(from),
+                    parameters: [fromAscii(using), fromAscii(from)],
+                    version: "1.0.0"
+                } as SquaringParameters]
+            }  
+
+
+            /// imports => import Test from './test';
+            if(isArrayEqual(importTypeSeparator.bitMap, trimWhiteSpaceFromLeft(dataRow).slice(0, importTypeSeparator.bitMap.length))){
+                let notation = splitArray(dataRow, 32);
+                // Remove all single quotes and semicolons from the import path
+                let cleanedPath = fromAscii(notation[3]).replace(/[\';]/g, "");
+                let notationProperty = square.createImportProperty(fromAscii(notation[1]), fromAscii(notation[0]), fromAscii(notation[1]), cleanedPath);
+                squaring.data.imports[0].properties.push(notationProperty);
+            }
+
+            /// Component<T> => 
+
+            if(isArrayEqual(componentTypeSeparator.bitMap, trimWhiteSpaceFromLeft(dataRow).slice(0, componentTypeSeparator.bitMap.length))){
+                let notation = splitArray(dataRow, 32);
+                let type = fromAscii(splitArray(notation[0], 60)[1].slice(0, -1));
+
+                let propertyCodeName = removeArrayExclamationMark(notation[1], propertyCloseSeparator.bitMap);
+
+                let notationProperty = square.createComponentProperty(fromAscii(propertyCodeName), type, null, true);
+                squaring.data.components[0].properties.push(notationProperty);
+            }
+
+            //// Event<Type> => 
+
+            if(isArrayEqual(eventTypeSeparator.bitMap, trimWhiteSpaceFromLeft(dataRow).slice(0, eventTypeSeparator.bitMap.length))){
+                let notation = splitArray(dataRow, 32);
+                let type = fromAscii(splitArray(notation[0], 60)[1].slice(0, -1));
+
+                let propertyCodeName = removeArrayExclamationMark(notation[1], propertyCloseSeparator.bitMap);
+
+                let notationProperty = square.createComponentProperty(fromAscii(propertyCodeName), type, null, true);
+                squaring.data.components[0].properties.push(notationProperty);
+            }
+
+            ////Notation<boolean> notation;
+
+            if(isArrayEqual(NotationTypeSeparator.bitMap, trimWhiteSpaceFromLeft(dataRow).slice(0, NotationTypeSeparator.bitMap.length))){
+                let notation = splitArray(dataRow, 32);
+                let type = fromAscii(splitArray(notation[0], 60)[1].slice(0, -1));
+
+                let propertyCodeName = removeArrayExclamationMark(notation[1], propertyCloseSeparator.bitMap);
+
+                let notationProperty = square.createComponentProperty(fromAscii(propertyCodeName), type, null, true);
+                squaring.data.notations[0].properties.push(notationProperty);
+            }
+
+            ///dataType string title = "";
+            for(let tbm of typeBitMap){
+                if(byteMapStartWith(trimWhiteSpaceFromLeft(dataRow), tbm.code)){
+                    let array = splitArray(dataRow, 32); let value;
+                    if(array.length == 4){
+                        value = fromAscii(removeArrayExclamationMark(array[3], propertyCloseSeparator.bitMap));
+                    }
+                    
+                    let property = square.createComponentProperty(fromAscii(array[1]), fromAscii(array[0]), value, value == null || value == undefined ? true : false);
+                    squaring.data.components[0].properties.push(property);
+                }
+            }
+
+            ///methodType override void beforeInit()
+            let currentRow = new CurrentRow();
+            for(let mts of methodReturnTypeBitMap){
+                if(byteMapStartWith(trimWhiteSpaceFromLeft(dataRow), mts.code) && !currentRow.begin){
+                    let array = splitArray(dataRow, 32);
+                    let name = fromAscii(array[2]).replace(/[^a-zA-Z]/g, '');
+                    let returnType = fromAscii(array[1]);
+                    let method = square.createSquareMethods(name.replace('()', ''), returnType, null, [], returnType);
+                    squaring.data.methods.push(method);   
+
+                    currentRow.begin = true;
+                    currentRow.current = currentRow.out;
+                    currentRow.currentData = dataRow;
+                }else if(currentRow.begin && 
+                         currentRow.current == currentRow.out && 
+                         !byteMapStartWith(trimWhiteSpaceFromLeft(dataRow), mts.code), !byteMapStartWith(trimWhiteSpaceFromLeft(dataRow), [125]) && 
+                         !equal(dataRow, currentRow.currentData) && 
+                         !startsWithMultipleByteMap(dataRow, methodReturnTypeBitMap)){      
+                    currentRow.lastDataBody = currentRow.currentDataBody;
+                    currentRow.currentDataBody = dataRow;
+
+                    if(!equal(currentRow.lastDataBody, currentRow.currentDataBody) || currentRow.lastDataBody.length == 0){
+                        let method = findLast(squaring.data.methods);
+                        method.body.push(fromAscii(dataRow));
+                        method.body.push(newRow.name);
+                    }
+                }else{
+                    currentRow.begin = false;
+                    currentRow.out = currentRow.out++;
+                }
+            }
+
+        }
+    }
+
+    let contentFile = new ContentFile();
+    contentFile.contentFile.push(`import { Component } from './Component'`);
+    contentFile.contentFile.push(newRow.name);
+    for(let item of squaring.data.imports){
+        for(let property of item.properties){
+            contentFile.contentFile.push(`import ${property.name} from './index.js'`);
+            contentFile.contentFile.push(newRow.name);
+        }
+    }
+
+    for(let item of squaring.data.squaringReferences){
+        for(let parameters of item.squaringParameters){
+            contentFile.contentFile.push(`import ${parameters.name} from ${parameters.path}`);
+            contentFile.contentFile.push(newRow.name);
+        }
+    }
+
+    contentFile.contentFile.push(newRow.name);
+    contentFile.contentFile.push(newRow.name);
+    contentFile.contentFile.push(`export default class ${squaring.name} extends Component {`);
+    contentFile.contentFile.push(newRow.name);
+
+    for(let item of squaring.data.components){
+        for(let property of item.properties){
+            contentFile.contentFile.push(newTab.name);
+            contentFile.contentFile.push(`${property.name}${property.nullable ? nullable.name: empty.name}: ${property.type}`);
+            contentFile = setProperty(property, contentFile);
+            contentFile.contentFile.push(`${fromAscii(propertyCloseSeparator.bitMap)}`);
+            contentFile.contentFile.push(newRow.name);
+        }
+    }
+
+    for(let item of squaring.data.notations){
+        for(let property of item.properties){
+            contentFile.contentFile.push(newTab.name);
+            contentFile.contentFile.push(`${property.name}${property.nullable ? nullable.name: empty.name}: ${property.type}`);
+            contentFile = setProperty(property, contentFile);
+            contentFile.contentFile.push(`${fromAscii(propertyCloseSeparator.bitMap)}`);
+            contentFile.contentFile.push(newRow.name);
+        }
+    }
+
+    for(let item of squaring.data.methods){
+        if(item.name){
+            contentFile.contentFile.push(newTab.name);
+            contentFile.contentFile.push(`\t${item.name}`);
+            if(item.parameters.length){
+                for(let parameter of item.parameters){
+                    contentFile.contentFile.push(newTab.name);
+                    contentFile.contentFile.push(`(${parameter.name}: ${parameter.type}) `);
+                    contentFile.contentFile.push(newRow.name);
+                }
+            }
+            else{
+                contentFile.contentFile.push(newTab.name);
+                contentFile.contentFile.push('()');
+                contentFile.contentFile.push(newRow.name);
+            }
+
+            contentFile.contentFile.push(newTab.name);
+            contentFile.contentFile.push(`: ${item.returnType} {`);
+            contentFile.contentFile.push(newRow.name);
+            if(item.body.length){
+                contentFile.contentFile.push(newTab.name);
+                for(let bd of item.body){
+                    contentFile.contentFile.push(`${bd}`);
+                }
+                contentFile.contentFile.push(`${newRow.name}`);
+            }
+            contentFile.contentFile.push(newTab.name);
+            contentFile.contentFile.push(`}`);
+            contentFile.contentFile.push(newRow.name);
+        }
+    }
+
+    contentFile.contentFile.push(newRow.name);
+    contentFile.contentFile.push(`}`);
+
+
+    setCurrentSquaring([...getCurrentSquaring(), squaring])
+    return createFromString(contentFile);
+}
+
+
+export const componentType = (number: number[]) => {
+    
+}
+
+export const eventType = (number: number[]) => {
+
+}
+
+export const notationType = (number: number[]) => {
+
+}
+
+export const fitRowSeparator = (number: number, lastNumber: number) => {
+    let rows = rowSeparation.bitMap;
+
+    for(let row of rows){
+        if(number == row[1]){
+            if(row[0] == lastNumber){
+                return true;
+            }
+        }
+    }
+
+    return false;
+}
+
+export const translateDataType = (number: number[]) => {
+    let data: DataList = new DataList();
+
+    let i = 0;
+    for(let num of number){
+        if(num == 10){ //// newrow
+            i++;
+        }else{
+            data.list[i].array = [...data.list[i].array, num];
+        }
+    }
+
+    for(let array of data.list){  ///// check dataType, check methodType
+        for(let data of array.array){
+            if(data != 32){
+
+            }
+        }
+    }
+}
+
+export const dataType = (number: number[]) => {
+    let data: DataList = new DataList();
+
+    let i = 0;
+    for(let num of number){
+        if(num == 32){
+            i++;
+        }
+        else if(!data.list!.length){
+            data.list[i] = new DataListType();
+            data.list[i].array = [num];
+        }
+        else{
+            if(data.list[i] == undefined){
+                data.list[i] = new DataListType();
+            }
+            data.list[i].array = [...data.list[i].array, num];
+        }
+    }
+for (let page of data.list) {
+    if (page === undefined) continue;
+
+    for (let tbm of typeBitMap) {
+        const same =
+            tbm.code.length === page.array.length &&
+            tbm.code.every((v, i) => v === page.array[i]);
+
+        if (same) {
+            // remove / handle match
+        }
+    }
+}
+    let change = data.list[0];
+    data.list[0] = data.list[1];
+    data.list[1] = change;
+
+    let result = [] as number[];
+
+    for(let i = 0; i < data.list.length; i++){
+        if(i == 0){
+            result = [...result, 58]; //// ts : translate
+        }else{
+
+            result = [...result, ...data.list[i].array];
+
+        }
+
+        if(i !== data.list.length){
+            result = [...result, 32];  //// divider
+        }
+    }
+
+    return result;
+}
+
+export const methodType = (number: number[]) => {
+    let data: DataList = new DataList();
+
+    let i = 0;
+    for(let num of number){
+        if(num == 32){
+            i++;
+        }
+        else if(num == methodTypeSeparator.bitMap[1]){
+            if(methodTypeSeparator.bitMap[0] == data.list[i].array[data.list[i].array.length - 1]){
+                i++;
+            data.list[i] = new DataListType();
+                data.list[i].array = [...data.list[i].array, num];/// separator between joined
+            }
+        }
+        else{
+            data.list[i] = new DataListType();
+            data.list[i].array = [...data.list[i].array, num];
+        }
+    }
+
+    if(data.list.length < 4){
+        console.log("warn" + data.list.length)
+    }
+
+    let change = data.list[1];
+    data.list[1] = data.list[2];
+    data.list[2] = change;
+
+    let result = [] as number[];
+
+    for(let i = 0; i < data.list.length; i++){
+        if(i == 1){
+            result = [...result, ...data.list[i].array, 58]; //// ts : translate
+        }
+
+        result = [...result, ...data.list[i].array];
+
+        if(i !== data.list.length){
+            result = [...result, 32];  //// divider
+        }
+    }
+
+    return result;
+
+}
+
+
+export const equal = (number: number[], number2: number[]) => {
+    for(let i = 0; i < number.length; i++){
+        if(number[i] != number2[i]){
+            return false;
+        }
+    }
+    
+    return true;
+}
+
+export const fromPageToString = (number: number[]) => {
+    let result = "";
+    for(let num of number){
+        result = result + asciiTable.ascii.find(x=> x.code == num)?.char;
+    }
+    return result;
+}
+
+export const createPage = (number: { arrays: number[] }[]) => {
+    let result = "";
+    let tab = newTab.bitMap;
+    let row = newRow.bitMap;
+
+    try{
+        for(let i = 0; i < number.length; i++){
+            let filePart = number[i].arrays;
+            if(isArrayEqual(tab, filePart)){
+                result = result + newTab.name.replace(/[']/g, '\t');
+                continue;
+            }
+
+            if(isArrayEqual(row, filePart)){
+                result = result + newRow.name.replace(/[']/g, '\t');
+                continue;
+            }
+
+            result = result + fromAscii(filePart);
+        }
+    }catch(ex){
+        console.log(ex);
+    }
+
+    return result;
+}
+
+export const createFromString = (contentFile: ContentFile) => {
+    let result: { arrays: number[] }[] = [];
+    let tab = newTab.name.split('');
+    let row = newRow.name.split('');
+
+    try{
+        for(let i = 0; i < contentFile.contentFile.length; i++){
+            let filePart = contentFile.contentFile[i];
+            let fileExclamation = filePart.split('');
+
+            if(isListEqual(fileExclamation, tab)){
+                result = [...result, { arrays: newTab.bitMap }];
+                continue;
+            }
+
+            if(isListEqual(fileExclamation, row)){
+                result = [...result, { arrays: newRow.bitMap }];
+                continue;
+            }
+
+            result = [...result, { arrays: fromString(filePart) }];
+        }
+    }catch(ex){
+        console.log("Error message"+ex);
+    }
+    return result;
+}
+
+export const fromPage = (array: string) => {
+        let result: number[] = [];
+
+        for(let i = 0; i < array.length; i++){
+            let number = asciiTable.ascii.find(x=> x.char == array[i])?.code;
+            
+            if(number == undefined)
+                console.log("warn, code number not found!");
+            
+            result = [...result, number!];
+        }
+
+        return result;
+    }
+
+export const nestedComponents = (number: number[], currentFile: string = 'App.elen') => {
+    let content = fromAscii(number);
+    let roots = extractComponentTree(content);
+
+    const sourceBytes = fs.existsSync(currentFile)
+        ? Array.from(fs.readFileSync(currentFile))
+        : number;
+
+    const result: Array<{
+        tree?: any[];
+        filepaths?: string[];
+        component: string;
+        valid?: boolean;
+        errors?: string[];
+    }> = [];
+
+    for(let root of roots){
+        try{
+            result.push(validateTemplate(sourceBytes, currentFile));
+        }catch(ex){
+            console.log(ex);
+        }
+    }
+
+    return result;
+}
+
+export function fromAscii(arr: number[]): string {
+    return String.fromCharCode(...arr);
+}
+
+export function fromString(text: string): number[] {
+    let result: number[] = [];
+    for(let i = 0; i < text.length; i++){
+        let code = asciiTable.ascii.find(x=> x.char == text[i])?.code;
+        result = [...result, code!];
+        
+    }
+
+    let copyResult: number[] = [];
+
+    for(let num of result){
+        if(num != undefined){
+            copyResult = [...copyResult, num];
+        }
+    }
+
+    return copyResult;
+}
+
+// extract all component tags in order (including nested)
+function extractComponentTree(content: string) {
+
+    const tagRegex = /<\/?([A-Z][A-Za-z0-9_]*)\b/g;
+
+    const stack: any[] = [];
+    const roots: any[] = [];
+
+    let match;
+
+    while ((match = tagRegex.exec(content)) !== null) {
+
+        const name = match[1];
+        const isClosing = match[0][1] === "/";
+
+        if (!isClosing) {
+            const node = {
+                name,
+                children: []
+            };
+
+            if (stack.length > 0) {
+                stack[stack.length - 1].children.push(node);
+            } else {
+                roots.push(node);
+            }
+
+            stack.push(node);
+        } else {
+            // pop until matching tag
+            let i = stack.length - 1;
+            while (i >= 0) {
+                if (stack[i].name === name) {
+                    stack.splice(i);
+                    break;
+                }
+                i--;
+            }
+        }
+    }
+
+    return roots;
+}
+
+function validateTemplate(contentArray: number[], currentFile: string) {
+
+    const content = fromAscii(contentArray);
+
+    const importRegex =
+        /import\s+([A-Za-z0-9_]+)\s+from\s+['"]([^'"]+)['"]/g;
+
+    const componentRegex =
+        /@component\s+([A-Za-z0-9_]+)/g;
+
+    const imports = new Map<string, string>();
+    const declared = new Set<string>();
+
+    let match;
+
+    // imports
+    while ((match = importRegex.exec(content)) !== null) {
+        const name = match[1];
+        const importPath = match[2];
+
+        imports.set(
+            name,
+            path.resolve(path.dirname(currentFile), importPath)
+        );
+    }
+
+    // @component declarations
+    while ((match = componentRegex.exec(content)) !== null) {
+        declared.add(match[1]);
+    }
+
+    const tree = extractComponentTree(content);
+
+    const errors: string[] = [];
+    const filepaths: string[] = [];
+    let component: string = '';
+
+    function walk(node: any) {
+
+        const name = node.name;
+        component = name;
+
+        if (!imports.has(name)) {
+            errors.push(`${name} is not imported`);
+        }
+
+        if (!declared.has(name)) {
+            errors.push(`${name} missing @component`);
+        }
+
+        const importPath = imports.get(name);
+
+        if (importPath) {
+            const filePath = importPath.endsWith('.elen') ? importPath : importPath + ".elen";
+            filepaths.push(filePath);
+
+            if (!fs.existsSync(filePath)) {
+                errors.push(`${name} file not found: ${filePath}`);
+            }
+        }
+
+        for (const child of node.children) {
+            walk(child);
+        }
+    }
+
+    for (const root of tree) {
+        walk(root);
+    }
+
+    return {
+        tree,
+        filepaths,
+        component,
+        valid: errors.length === 0,
+        errors
+    };
+}