如何在Javascript Sweet alert中显示表中的数据

我想在SweetAlert表中显示错误。目前，错误显示在SweetAlert中，但不是以表格形式。我已经在SweetAlert中创建了一个表，但我不知道如何在SweetAlert中显示这些错误。使用开关盒显示错误

if (!app.validator) {
        console.log('Starting Validation');
        let model =  app.project.models[0]
        var errorss = []
        for (let diagram of model.diagrams) {
            for (let element of diagram.elements) {
                
                const s = element.state;
                let prefix = `${diagram.name}(${diagram.type}) > ${s.name}:`;
                switch (s.type) {
                    case 'InitialNode':
                        if (s.outgoing.length === 0) {
                            errorss.push(prefix + s.type + `<p style="color:lightblue;"> Initial Node is not used </p>`)
                            // console.warn(`${prefix} Initial Node is not used`);
                        }
                        break;
                    case 'ActivityFinalNode':
                        if(s.incoming.length === 0){
                            errorss.push(prefix + s.type + `<p style="color:lightblue;"> Initial Final Node is not used </p>`)
                            
                        }
                        break;
                    case 'FlowFinalNode':
                        if(s.incoming.length === 0){
                            errorss.push(prefix + s.type + `<p style="color:lightblue;">Flow Final Node is not used</p>`)
                        
                        }
                        break;
                    case 'ControlFlow':
                        if(s.target == null){
                            errorss.push(prefix + s.type + `<p style="color:lightblue;">Control flow target not set</p>`)
                         
                            // console.error(`${prefix} Control flow target not set`);
                        }
                        if(s.source == null){
                            errorss.push(prefix + s.type + `<p style="color:lightblue;">Control flow source not set</p>`)
                           
                            // console.error(`${prefix} Control flow source not set`);
                        }
                        break;
                    case 'ObjectFlow':
                        if(s.target == null){
                            errorss.push(prefix + s.type + `<p style="color:lightblue;">Object flow target not set</p>`)
                         
                            // console.error(`${prefix} Object flow target not set`);
                        }
                        if(s.source == null){
                            errorss.push(prefix + s.type + `<p style="color:lightblue;">Object flow source not set</p>`)
                            // showAlert(prefix + s.type + `  Object flow source not set`)
                            //   return;
                            // console.error(`${prefix} Object flow source not set`);
                        }
                        break;
                    case 'CallBehaviorAction':
                        //TODO
                        break;
                    case 'ValueSpecificationAction':
                        
                        console.log('error log');
                        if (typeof (s.value) == 'undefined' || typeof (s.valueType) == 'undefined') {
                            // showAlert(prefix + s.type + `   Type/Value is undefined`)
                            //   return;
                            // console.warn(`${prefix} Type/Value is undefined`);
                        } else if (s.valueType === 'LiteralBoolean' && !/^(true|false)$/.test(s.value)) {
                            // showAlert(prefix + s.type + `is not a LiteralBoolean value`)
                            //   return;
                            // console.error(`${prefix} '${s.value}' is not a LiteralBoolean value`);
                        } else if (s.valueType === 'LiteralInteger' && !/^-?\d+$/.test(s.value)) {
                            // showAlert(prefix + s.type + `is not a LiteralInteger value`)
                            // return;
                            // console.error(`${prefix} '${s.value}' is not a LiteralInteger value`);
                        } else if (s.valueType === 'LiteralNull' && !/^$/.test(s.value)) {
                            // showAlert(prefix + s.type + `is not a LiteralNull value`)
                            // return;
                            // console.error(`${prefix} '${s.value}' is not a LiteralNull value`);
                        } else if (s.valueType === 'LiteralReal' && !/^-?\d*\.?\d+([eE][-]?\d+)?$/.test(s.value)) {
                            // showAlert(prefix + s.type + `is not a LiteralReal value`)
                            // return;
                           // console.error(`${prefix} '${s.value}' is not a LiteralReal value`);
                        } else if (s.valueType === 'LiteralString' && !/.*/.test(s.value)) {
                            // showAlert(prefix + s.type + `is not a LiteralString value`)
                            // return;
                          //  console.error(`${prefix} '${s.value}' is not a LiteralString value`);
                        } else if (s.valueType === 'LiteralUnlimitedNatural' && !/^(\d+|\*)$/.test(s.value)) {
                            // showAlert(prefix + s.type + `is not a LiteralUnlimitedNatural value`)
                            // return;
                           // console.error(`${prefix} '${s.value}' is not a LiteralUnlimitedNatural value`);
                        } else {
                            if (s.outputPins[0].state.outgoing.length === 0) {
                                // showAlert(prefix + s.type + `The specified value ${s.value} is not use`)
                        //    return;
                               // console.warn(`${prefix} The specified value ${s.value} is not used`);
                            }
                        }
                        break;
                    case 'Class':
                        if (!s.isActive && s.receptions.length > 0) {
                           // console.error(`${prefix} ${s.type} has at least 1 signal reception but has 'isActive' set to false.`);
                        }
                        break;
                }
            }
        
        }

        if (errorss.length != 0) {
        var errorMsg = ''

            for (let err of errorss) {
                errorMsg += '* ' + err + ' <br> '
            }
                showAlert(errorMsg)
                return
            }
            



    }
    setTimeout(() => { 
        Swal.fire({
            text: 'Validation completed',
            icon: 'success',
            confirmButtonText: 'Close',
          })
     }, 5000);
};

if（！app.validator）{
log（“开始验证”）；
让model=app.project.models[0]
var errorss=[]
用于（模型图的let图）{
for（让图的元素。元素）{
常数s=元素状态；
让前缀=`${diagram.name}（${diagram.type}）>${s.name}:`；
开关（s型）{
案例“InitialNode”：
如果（s.outing.length==0）{
errorss.push（未使用前缀+s.type+`
初始节点）
//warn（`${prefix}初始节点未使用`）；
}
打破
案例“活动最终节点”：
如果（s.incoming.length==0）{
errorss.push（未使用前缀+s.type+`
初始-最终节点）
}
打破
案例“FlowFinalNode”：
如果（s.incoming.length==0）{
errorss.push（未使用前缀+s.type+`
流最终节点）
}
打破
案例“控制流”：
如果（s.target==null）{
错误推送（前缀+s.type+`
未设置控制流目标）
//错误（`${prefix}未设置控制流目标`）；
}
如果（s.source==null）{
错误推送（前缀+s.type+`
未设置控制流源）
//错误（`${prefix}控制流源未设置`）；
}
打破
案例“ObjectFlow”：
如果（s.target==null）{
错误推送（前缀+s.type+`
未设置对象流目标）
//错误（`${prefix}对象流目标未设置`）；
}
如果（s.source==null）{
错误推送（前缀+s.type+`
未设置对象流源
`）
//showAlert（前缀+s.type+`Object flow source not set`）
//返回；
//错误（`${prefix}对象流源未设置`）；
}
打破
案例“CallBehaviorAction”：
//待办事项
打破
案例“ValueSpecificationAction”：
console.log（“错误日志”）；
如果（typeof（s.value）=‘未定义’| | typeof（s.valueType）==‘未定义’）{
//showAlert（前缀+s.type+`type/值未定义`）
//返回；
//warn（`${prefix}类型/值未定义`）；
}else if（s.valueType=='LiteralBoolean'&&！/^（true | false）$/.test（s.value））{
//showAlert（前缀+s.type+`不是LiteralBoolean值`）
//返回；
//错误（`${prefix}'${s.value}'不是一个LiteralBoolean值`）；
}else if（s.valueType=='LiteralInteger'&&！/^-？\d+$/.test（s.value））{
//showAlert（前缀+s.type+`不是LiteralInteger值`）
//返回；
//错误（`${prefix}'${s.value}'不是LiteralInteger值`）；
}else if（s.valueType=='LiteralNull'&&！/^$/.test（s.value））{
//showAlert（前缀+s.type+`不是LiteralNull值`）
//返回；
//错误（`${prefix}'${s.value}'不是LiteralNull值`）；
}否则如果（s.valueType=='LiteralReal'&&&！/^-？\d*\。？\d+（[eE][-]？\d+）？$/.test（s.value））{
//showAlert（前缀+s.type+`不是一个LiteralReal值`）
//返回；
//错误（`${prefix}'${s.value}'不是一个LiteralReal值`）；
}else if（s.valueType=='LiteralString'&&&！/./.test（s.value））{
//showAlert（前缀+s.type+`不是文字字符串值`）
//返回；
//错误（`${prefix}'${s.value}'不是文字字符串值`）；
}否则如果（s.valueType=='LiteralUnlimitedNatural'&&&！/^（\d+\*）$/.test（s.value））{
//showAlert（前缀+s.type+`不是LiteralUnlimitedNatural值`）
//返回；
//错误（`${prefix}'${s.value}'不是LiteralUnlimitedNatural值`）；
}否则{
如果（s.outputPins[0].state.outgoing.length==0）{
//showAlert（前缀+s.type+`指定的值${s.value}未被使用`）
//返回；
function showAlert() {
    Swal.fire({
        html: `<table id="table" border=1>
    <thead>
        <tr>
            <th>Errors</th>
            <th>Info</th>
            <th>Warning</th>
            <th>Message</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td>1</td>
            <td>Dakota Rice</td>
            <td>$36,738</td>
            <td>Niger</td>
        </tr>
        <tr>
            <td>2</td>
            <td>Minerva Hooper</td>
            <td>Curaçao</td>
            <td>Sinaai-Waas</td>
        </tr>
        <tr>
            <td>3</td>
            <td>Sage Rodriguez</td>
            <td>$56,142</td>
            <td>Netherlands</td>
        </tr>
        <tr>
            <td>4</td>
            <td>Philip Chaney</td>
            <td>$38,735</td>
            <td>Overland Park</td>
        </tr>