fn buildTree(tokens: Vec<String>) -> Vec<DomElement> {
    let mut elements: Vec<DomElement> = vec![];
    let mut openTags: Vec<String> = vec![];

    let mut parent: Option<DomElement> = None;

    for token in tokens {
        let tagName = getTagName(&token);
        let tagType = getTagType(&token, &tagName);
        let nodeType = getNodeType(&token, &tagName);

        match tagType {
            TagType::Closing => match &parent {
                Some(item) => {
                    let openTagIndex = &openTags.iter().rev().position(|s| s == &tagName);
                    match openTagIndex {
                        Some(index) => {
                            if item.tagName == tagName.to_string() {
                                parent = Some((*item.parentNode.clone()).unwrap())
                            } else {
                                let openingElement = getOpeningTag(&tagName, &Some(item.clone()));
                                match openingElement {
                                    Some(el) => parent = Some((*el.parentNode).unwrap()),
                                    None => {}
                                }
                            }

                            openTags.remove(*index);
                        }
                        None => {}
                    }
                }
                None => {}
            },
            _ => {
                let mut element = DomElement::new(nodeType);

                match &parent {
                    Some(item) => {
                        element.parentNode = Box::from(parent);
                    }
                    None => {
                        elements.push(element);
                    }
                }
            }
        }
    }

    return elements;
}