.jsx script extremely slow

After some talk with my team, the target changed a little, to make it easier to work with.

Right now what the script is supposed to do - ignore groups that are visible on top level.

For the rest of the groups, find those that are in the objects.txt file. Remove everything else (except parent groups of groups to keep). It also deletes the top groups first to make it faster.

Huge thanks to this community, I wouldn't have been able to make it at all without you.

removeGroups(loadObjectsFile());


// Load objects.txt file, to lowercase and some clean-up
function loadObjectsFile() {

    var title = getObjectProperty('document', 'title');
    var full_path = String(getObjectProperty('document', 'fileReference')).split('%20').join(' ');

    var textFile = File(full_path.replace(title, 'objects.txt'));
    textFile.encoding = 'UTF-8';
    textFile.open('r');

    return textFile.read().toLowerCase();
}


// Hide all groups the script will work with
function hideAll(start, end) {

    var toDo = [];

    for (var i = end - 1; i >= start; i--) {
        var section = getLayerPropertyByIndex(i, 'layerSection').value;
        
        // It's a group
        if (section == 'layerSectionStart') {
            var ID = getLayerPropertyByIndex(i, 'layerID');

            // Ignore groups that are visible on top level
            if (!isTopVisible(ID)) {
                toDo.push(ID);
            }
        }
    }

    // Hide all at once
    if (toDo.length != 0) {
        executeActionOnLayers('hide', toDo);
    }
}


// Show all groups that should be kept (but not top level), return top level groups to keep
function showTarget(start, end, objectString) {

    var toDo = [];
    var topGroups = [];

    for (var i = end - 1; i >= start; i--) {
        var section = getLayerPropertyByIndex(i, 'layerSection').value;
        
        // It's a group
        if (section == 'layerSectionStart') {
            var ID = getLayerPropertyByIndex(i, 'layerID');

            if (!isTopVisible(ID)) {
                var name = getLayerPropertyByIndex(i, 'name');

                if (objectString.indexOf(String(name).toLowerCase()) != -1) {
                    if (!arrayContains(toDo, ID)) {
                        toDo.push(ID);
                    }
                    
                    var parents = getParentGroups(ID);
                    topGroups.push(parents[parents.length - 1]);

                    for (j in parents) {
                        if (!arrayContains(toDo, parents[j])) {
                            toDo.push(parents[j]);
                        }
                    }
                }
            }
        }
    }

    // Show all at once
    if (toDo.length != 0) {
        executeActionOnLayers('show', toDo);
    }

    return topGroups;
}


// Delete all groups that are not visible, keep top level array groups
function deleteRest(start, end, topGroups) {

    var toDo = [];

    // Loop through all layers
    for (var i = end - 1; i >= start; i--) {
        var section = getLayerPropertyByIndex(i, 'layerSection').value;
        
        // It's a group
        if (section == 'layerSectionStart') {
            var ID = getLayerPropertyByIndex(i, 'layerID');
            var visible = getLayerPropertyByID(ID, 'visible');

            // Only push if a parent group is not in list, and group is hidden
            if ((!isTopVisible(ID) || isParentInList(ID, topGroups)) && !visible) {
                toDo.push(ID);
            }
        }
    }

    // Delete all at once
    if (toDo.length != 0) {
        executeActionOnLayers('delete', toDo);
    }
}


// Remove all groups that are not in the objectString
function removeGroups(objectString) {

    var start = getObjectProperty('document', 'hasBackgroundLayer') ? 0 : 1;
    var end = getObjectProperty('document', 'numberOfLayers');

    hideAll(start, end);
    var topGroups = showTarget(start, end, objectString);
    deleteRest(start, end, topGroups);
}




// Return if top group is visible
function isTopVisible(ID) {

    var parentID = getLayerPropertyByID(ID, 'parentLayerID');

    while (parentID != -1) {

        ID = getLayerPropertyByID(ID, 'parentLayerID');
        parentID = getLayerPropertyByID(ID, 'parentLayerID');
    }

    return getLayerPropertyByID(ID, 'visible');
}


// Return if any parent is in a list
function isParentInList(ID, list) {

    if (list.length == 0) {
        return false;
    }
    
    var parentID = getLayerPropertyByID(ID, 'parentLayerID');

    if (arrayContains(list, parentID)) {
        return true;
    }

    while (parentID != -1) {
        ID = getLayerPropertyByID(ID, 'parentLayerID');
        parentID = getLayerPropertyByID(ID, 'parentLayerID');

        if (arrayContains(list, parentID)) {
            return true;
        }
    }

    return false;
}


// Return IDs of all parent groups
function getParentGroups(ID) {

    var parentID = getLayerPropertyByID(ID, 'parentLayerID');
    var parents = [];

    while (parentID != -1) {

        parents.push(parentID);
        ID = getLayerPropertyByID(ID, 'parentLayerID');
        parentID = getLayerPropertyByID(ID, 'parentLayerID');
    }

    return parents;
}


// Return if array contains an element
function arrayContains(array, element) {

    for (var i = 0; i < array.length; i++) {
        if (array[i] == element) {
            return true;
        }
    }

    return false;
}


function s2t(s) { return stringIDToTypeID(s); }
function t2s(t) { return typeIDToStringID(t); }


function getObjectProperty(obj, property) {

    var ref = new ActionReference();
    ref.putProperty(s2t('property'), s2t(property));
    ref.putEnumerated(s2t(obj), s2t('ordinal'), s2t('targetEnum'));
    return getDescValue(executeActionGet(ref), s2t(property));
}


function getLayerPropertyByIndex(index, property) {

    ref = new ActionReference();
    ref.putProperty(s2t('property'), s2t(property))
    ref.putIndex(s2t('layer'), index);
    var desc = executeActionGet(ref);
    return getDescValue(desc, s2t(property));
}


function getLayerPropertyByID(ID, property) {

    ref = new ActionReference();
    ref.putProperty(s2t('property'), s2t(property))
    ref.putIdentifier(s2t('layer'), ID);
    var desc = executeActionGet(ref);
    return getDescValue(desc, s2t(property));
}


function executeActionOnLayers(action, IDs) {

    ref = new ActionReference();

    for (i in IDs) {
        ref.putIdentifier(s2t('layer'), IDs[i]);
    }

    var d = new ActionDescriptor();
    d.putReference(s2t('null'), ref);

    executeAction(s2t(action), d);
}


function getDescValue(descriptor, property) {
    switch (descriptor.getType(property)) {
        case DescValueType.OBJECTTYPE: return { type: t2s(descriptor.getObjectType(property)), value: descriptor.getObjectValue(property) };
        case DescValueType.LISTTYPE: return descriptor.getList(property);
        case DescValueType.REFERENCETYPE: return descriptor.getReference(property);
        case DescValueType.BOOLEANTYPE: return descriptor.getBoolean(property);
        case DescValueType.STRINGTYPE: return descriptor.getString(property);
        case DescValueType.INTEGERTYPE: return descriptor.getInteger(property);
        case DescValueType.LARGEINTEGERTYPE: return descriptor.getLargeInteger(property);
        case DescValueType.DOUBLETYPE: return descriptor.getDouble(property);
        case DescValueType.ALIASTYPE: return descriptor.getPath(property);
        case DescValueType.CLASSTYPE: return descriptor.getClass(property);
        case DescValueType.UNITDOUBLE: return (descriptor.getUnitDoubleValue(property));
        case DescValueType.ENUMERATEDTYPE: return { type: t2s(descriptor.getEnumerationType(property)), value: t2s(descriptor.getEnumerationValue(property)) };
        default: return 0;
    };
}