monocart-coverage-reports 2.3.3 → 2.4.0

package/lib/converter/converter.js

@@ -17,19 +17,37 @@ const {
 const { getSourceType, initSourceMapSourcePath } = require('../utils/source-path.js');
 const { decode } = require('../packages/monocart-coverage-vendor.js');
 
-const InfoLine = require('./info-line.js');
 const InfoBranch = require('./info-branch.js');
 const InfoFunction = require('./info-function.js');
-const findInRanges = require('./find-in-ranges.js');
+const InfoStatement = require('./info-statement.js');
+
+// ========================================================================================================
+
+// debug info
+const logMappingErrors = (type, result) => {
+
+    // const {
+    //     errors, start, end, sourcePath
+    // } = result;
+    // // if (!sourcePath.endsWith('monocart-v8.js') || type !== 'byte') {
+    // //     return;
+    // // }
+    // const list = [
+    //     Util.EC.red('[Mapping]'),
+    //     Util.EC.magenta(type),
+    //     errors.join(' -> '),
+    //     Util.EC.blue(`${start} ~ ${end}`),
+    //     sourcePath
+    // ];
+    // console.log(list.join(' '));
+
+};
 
 // ========================================================================================================
 
 const handleIgnoredRanges = (list, ignoredRanges) => {
     list.forEach((item) => {
-        if (item.count > 0) {
-            return;
-        }
-        const range = findInRanges(item.start, item.end, ignoredRanges);
+        const range = Util.findInRanges(item.start, item.end, ignoredRanges, 'start', 'end');
         if (range) {
             // console.log(item, range);
             item.ignored = true;
@@ -37,15 +55,18 @@ const handleIgnoredRanges = (list, ignoredRanges) => {
     });
 };
 
-// ========================================================================================================
 
-const updateLinesCount = (bytes, locator, lineMap) => {
+const applyBytesToLines = (bytes, locator, lineMap) => {
     bytes.forEach((range) => {
-
         const {
             start, end, count, ignored
         } = range;
 
+        // no need handle ignored and uncovered byte
+        if (count === 0 && ignored) {
+            return;
+        }
+
         const sLoc = locator.offsetToLocation(start);
         const eLoc = locator.offsetToLocation(end);
 
@@ -53,155 +74,150 @@ const updateLinesCount = (bytes, locator, lineMap) => {
         const lines = Util.getRangeLines(sLoc, eLoc);
 
         lines.forEach((it) => {
-            const line = lineMap.get(it.line);
-            if (!line) {
+            const lineItem = lineMap.get(it.line);
+            if (!lineItem) {
+                // not found line, could be comment or blank line
+                return;
+            }
+            if (lineItem.ignored) {
                 return;
             }
 
-            // from outside into inside, uncovered is certain
-            // default is covered
-            if (it.entire) {
-                line.covered = count > 0;
-                line.count = count;
+            it.count = count;
 
-                if (ignored) {
-                    if (!line.covered) {
-                        line.ignored = true;
-                    }
+            // default is covered, so only focus on
+            // 1, biggest covered count
+            // 2, uncovered entire and pieces
+            if (count > 0) {
+                lineItem.coveredCount = Math.max(lineItem.coveredCount, count);
+            } else {
+                if (it.entire) {
+                    lineItem.uncoveredEntire = it;
+                } else {
+                    lineItem.uncoveredPieces.push(it);
                 }
+            }
+        });
 
-            } else {
+    });
 
-                if (!ignored) {
-                    if (count > 0) {
-                        line.count = count;
-                    } else {
-                    // not covered if any count = 0
-                        line.covered = false;
-                    }
-                }
+    // no ignore items
+    lineMap.forEach((lineItem, line) => {
 
-            }
+        const {
+            uncoveredEntire, uncoveredPieces, coveredCount
+        } = lineItem;
 
-            // if (!line.history) {
-            //     line.history = [];
-            // }
-            // line.history.push(`${it.entire}-${count}`);
+        // default count to 1, both js and css
+        let count = 1;
+        // full covered true/false for entire line
+        let covered = true;
 
-        });
+        if (uncoveredEntire) {
+            count = 0;
+            covered = false;
+        } else {
+            count = coveredCount;
+            const uncoveredLen = uncoveredPieces.length;
+            if (uncoveredLen > 0) {
+                covered = false;
+                // uncovered
+                count = `1/${uncoveredLen + 1}`;
+            }
+        }
 
-    });
+        lineItem.covered = covered;
+        lineItem.count = count;
 
-    // if (state.sourcePath.endsWith('component.js')) {
-    //     console.log('===========================================', state.sourcePath);
-    // }
+    });
 
 };
 
-const handleLinesCoverage = (bytes, locator) => {
-
-    const lines = [];
-    // line 1 based
-    const lineMap = new Map();
+const handleLinesCoverage = (bytes, locator, ignoredRanges) => {
 
     // init lines
     let blankCount = 0;
     let commentCount = 0;
-
-    locator.lines.forEach((it) => {
+    // line 1 based
+    const lineMap = new Map();
+    locator.lines.forEach((lineItem) => {
         // exclude blank and comment
-        if (it.blank) {
+        if (lineItem.blank) {
             blankCount += 1;
             return;
         }
-        if (it.comment) {
+        if (lineItem.comment) {
             commentCount += 1;
             return;
         }
+        const ignored = Util.findInRanges(lineItem.start, lineItem.end, ignoredRanges);
+        if (ignored) {
+            return;
+        }
         // line 1-base
-        const line = it.line + 1;
-        // default count to 1, both js and css
-        const lineInfo = new InfoLine(line, it.length, 1);
-        lineMap.set(line, lineInfo);
-        lines.push(lineInfo);
+        const line = lineItem.line + 1;
+        lineItem.coveredCount = 1;
+        lineItem.uncoveredEntire = null;
+        lineItem.uncoveredPieces = [];
+        lineMap.set(line, lineItem);
     });
 
-    updateLinesCount(bytes, locator, lineMap);
-
-    return {
-        lines,
-        blankCount,
-        commentCount
-    };
-};
-
-// ========================================================================================================
-
-const calculateV8Functions = (functions) => {
+    applyBytesToLines(bytes, locator, lineMap);
 
-    const v8Functions = {
+    const summaryLines = {
         total: 0,
-        covered: 0
+        covered: 0,
+        blank: blankCount,
+        comment: commentCount
     };
-
-    functions.forEach((fn) => {
-        if (fn.ignored) {
-            return;
-        }
-
-        v8Functions.total += 1;
-        if (fn.count > 0) {
-            v8Functions.covered += 1;
+    // data lines for codecov
+    // https://docs.codecov.com/docs/codecov-custom-coverage-format
+    const dataLines = {};
+
+    // no ignore items
+    lineMap.forEach((lineItem, line) => {
+        const { count, covered } = lineItem;
+        // data lines
+        dataLines[line] = count;
+
+        summaryLines.total += 1;
+        if (covered) {
+            summaryLines.covered += 1;
         }
     });
 
-    return v8Functions;
-};
-
-const calculateV8Branches = (branches) => {
-    const v8Branches = {
-        total: 0,
-        covered: 0
+    return {
+        dataLines,
+        summaryLines
     };
+};
 
-    branches.forEach((branch) => {
-        if (branch.ignored) {
-            return;
-        }
-        v8Branches.total += 1;
-        if (branch.count > 0) {
-            v8Branches.covered += 1;
-        }
-    });
+// ========================================================================================================
 
-    return v8Branches;
-};
+const calculateV8Summary = (list) => {
 
-const calculateV8Lines = (lines, blankCount, commentCount) => {
-    const v8Lines = {
+    const summary = {
         total: 0,
-        covered: 0,
-        blank: blankCount,
-        comment: commentCount
+        covered: 0
     };
 
-    lines.forEach((ln) => {
-        if (ln.ignored) {
-            // console.log(ln);
+    list.forEach((item) => {
+        if (item.ignored) {
             return;
         }
-        v8Lines.total += 1;
-        // full line covered
-        if (ln.covered) {
-            v8Lines.covered += 1;
+
+        summary.total += 1;
+        if (item.count > 0) {
+            summary.covered += 1;
         }
     });
 
-    return v8Lines;
+    return summary;
 };
 
 // ========================================================================================================
 // istanbul coverage format
+// https://github.com/istanbuljs/istanbuljs/blob/master/docs/raw-output.md
 /**
  * * `path` - the file path for which coverage is being tracked
  * * `statementMap` - map of statement locations keyed by statement index
@@ -217,6 +233,7 @@ const collectFileCoverage = (v8Data, state, options) => {
         bytes,
         functions,
         branches,
+        statements,
 
         sourcePath,
         locator
@@ -227,7 +244,8 @@ const collectFileCoverage = (v8Data, state, options) => {
     const data = {
         bytes: dedupeCountRanges(bytes),
         functions: [],
-        branches: []
+        branches: [],
+        statements: []
     };
 
     // ==========================================
@@ -235,13 +253,15 @@ const collectFileCoverage = (v8Data, state, options) => {
     const ignoredRanges = getIgnoredRanges(locator, options);
     if (ignoredRanges) {
 
+        data.ignores = ignoredRanges;
+
         // data bytes is start/end/count object
         handleIgnoredRanges(data.bytes, ignoredRanges);
 
-        // functions is InfoFunction start/end/count instance
+        // functions start/end/count instance
         handleIgnoredRanges(functions, ignoredRanges);
 
-        // branches is InfoBranch start/end/count instance
+        // branches start/end/count instance
         handleIgnoredRanges(branches, ignoredRanges);
 
         // branch locations start/end/count object
@@ -256,10 +276,24 @@ const collectFileCoverage = (v8Data, state, options) => {
             }
         });
 
+        // statements start/end/count instance
+        handleIgnoredRanges(statements, ignoredRanges);
+
         // console.log(ignoredRanges);
 
     }
 
+    // ==========================================
+    // lines
+    // after bytes with ignored, before calculateV8Lines
+    const { dataLines, summaryLines } = handleLinesCoverage(data.bytes, locator, ignoredRanges);
+
+    data.lines = dataLines;
+
+    // console.log('statements', state.sourcePath, statements.length);
+
+    // ==========================================
+
     data.functions = functions.map((info) => {
         return info.getRange();
     });
@@ -271,21 +305,24 @@ const collectFileCoverage = (v8Data, state, options) => {
     }).flat();
     sortRanges(data.branches);
 
+    data.statements = statements.map((info) => {
+        return info.getRange();
+    });
+    sortRanges(data.statements);
+
     // ==========================================
-    // lines
-    // after bytes with ignored, before calculateV8Lines
-    const {
-        lines, blankCount, commentCount
-    } = handleLinesCoverage(data.bytes, locator);
+
+    const summary = {
+        functions: calculateV8Summary(data.functions),
+        branches: calculateV8Summary(data.branches),
+        statements: calculateV8Summary(data.statements),
+        lines: summaryLines
+    };
 
     // ==========================================
     // v8 data and summary
     v8Data.data = data;
-    v8Data.summary = {
-        functions: calculateV8Functions(data.functions),
-        branches: calculateV8Branches(data.branches),
-        lines: calculateV8Lines(lines, blankCount, commentCount)
-    };
+    v8Data.summary = summary;
 
     // ==========================================
     // istanbul
@@ -301,25 +338,13 @@ const collectFileCoverage = (v8Data, state, options) => {
         b: {}
     };
 
-    // for codecov https://docs.codecov.com/docs/codecov-custom-coverage-format
-    data.lines = {};
-
-    lines.filter((it) => !it.ignored).forEach((line, index) => {
-        istanbulData.statementMap[`${index}`] = line.generate();
-        istanbulData.s[`${index}`] = line.count;
-
-        let count = 0;
-        if (line.covered) {
-            count = line.count;
-        } else if (!line.covered && line.count > 0) {
-            count = '1/2';
-        }
-        // 1-base
-        data.lines[`${line.line}`] = count;
+    statements.filter((it) => !it.ignored).forEach((statement, index) => {
+        istanbulData.statementMap[`${index}`] = statement.generate(locator);
+        istanbulData.s[`${index}`] = statement.count;
     });
 
     functions.filter((it) => !it.ignored).forEach((fn, index) => {
-        istanbulData.fnMap[`${index}`] = fn.generate(locator);
+        istanbulData.fnMap[`${index}`] = fn.generate(locator, index);
         istanbulData.f[`${index}`] = fn.count;
     });
 
@@ -329,7 +354,6 @@ const collectFileCoverage = (v8Data, state, options) => {
         istanbulData.b[`${index}`] = counts;
     });
 
-    // istanbul data
     return istanbulData;
 
 };
@@ -341,11 +365,17 @@ const addJsBytesCoverage = (state, range) => {
         startOffset, endOffset, count
     } = range;
     // add bytes range
-    state.bytes.push({
+    const byte = {
         start: startOffset,
         end: endOffset,
         count
-    });
+    };
+    // for debug
+    if (Util.isDebug() && state.original) {
+        byte.generatedStart = range.generatedStart;
+        byte.generatedEnd = range.generatedEnd;
+    }
+    state.bytes.push(byte);
 };
 
 const addCssBytesCoverage = (state, range) => {
@@ -371,11 +401,14 @@ const handleFunctionsCoverage = (state) => {
 
     const { functions, astInfo } = state;
     astInfo.functions.forEach((it) => {
-        const {
-            start, end, functionName, count
-        } = it;
-        const functionInfo = new InfoFunction(start, end, count, functionName);
-        functions.push(functionInfo);
+
+        const { start, end } = it;
+        if (start >= end) {
+            // console.log('invalid function', start, end);
+            return;
+        }
+
+        functions.push(new InfoFunction(it, state.original));
     });
 
 };
@@ -389,11 +422,35 @@ const handleBranchesCoverage = (state) => {
 
     const { branches, astInfo } = state;
     astInfo.branches.forEach((it) => {
-        const {
-            start, end, locations, type
-        } = it;
-        const branchInfo = new InfoBranch(start, end, locations, type);
-        branches.push(branchInfo);
+
+        const { start, end } = it;
+        if (start >= end) {
+            // console.log('invalid branch', state.sourcePath, it);
+            return;
+        }
+
+        branches.push(new InfoBranch(it, state.original));
+    });
+
+};
+
+const handleStatementsCoverage = (state) => {
+
+    // statement only for js
+    if (!state.js) {
+        return;
+    }
+
+    const { statements, astInfo } = state;
+    astInfo.statements.forEach((it) => {
+
+        const { start, end } = it;
+        if (start >= end) {
+            // console.log('invalid statement', start, end);
+            return;
+        }
+
+        statements.push(new InfoStatement(it, state.original));
     });
 
 };
@@ -427,10 +484,22 @@ const handleOriginalFunctionsCoverage = (state, originalStateMap) => {
 
     // console.log(state.astInfo.functions);
 
+    const updateFunctionBodyRange = (start, end, bodyStart, bodyEnd, originalFunction) => {
+        if (bodyStart !== start || bodyEnd !== end) {
+            const result = findOriginalRange(bodyStart, bodyEnd, state, originalStateMap);
+            if (result.error) {
+                logMappingErrors('function body', result);
+            } else {
+                originalFunction.bodyStart = result.start;
+                originalFunction.bodyEnd = result.end;
+            }
+        }
+    };
+
     // function count
     state.astInfo.functions.forEach((it) => {
         const {
-            start, end, wrap
+            start, end, bodyStart, bodyEnd, wrap
         } = it;
 
         // remove webpack wrap functions for functions count, not for ranges here
@@ -438,31 +507,27 @@ const handleOriginalFunctionsCoverage = (state, originalStateMap) => {
             return;
         }
 
-        // rename to startOffset and endOffset
-        const range = {
-            startOffset: start,
-            endOffset: end
-        };
-
-        const result = findOriginalRange(range, state, originalStateMap);
+        const result = findOriginalRange(start, end, state, originalStateMap);
         if (result.error) {
+            logMappingErrors('function', result);
             return;
         }
-        const { originalRange, originalState } = result;
 
-        // add back to original ast
-        originalState.astInfo.functions.push({
+        const originalFunction = {
             ... it,
             generatedStart: start,
             generatedEnd: end,
-            start: originalRange.startOffset,
-            end: originalRange.endOffset
-        });
+            start: result.start,
+            end: result.end,
+            bodyStart: result.start,
+            bodyEnd: result.end
+        };
 
-        // if (originalState.sourcePath.endsWith('store.js')) {
-        //     console.log('==========================================================');
-        //     console.log(it, result.startMapping, result.endMapping);
-        // }
+        // body start and end
+        updateFunctionBodyRange(start, end, bodyStart, bodyEnd, originalFunction);
+
+        // add back to original ast
+        result.originalState.astInfo.functions.push(originalFunction);
 
     });
 
@@ -478,26 +543,20 @@ const handleOriginalBranchesCoverage = (state, originalStateMap) => {
     // console.log(state.astInfo.branches);
 
     // function count
-    state.astInfo.branches.forEach((it) => {
+    state.astInfo.branches.forEach((group) => {
 
-        const { type, locations } = it;
-
-        // rename to startOffset and endOffset
-        const bRange = {
-            startOffset: it.start,
-            endOffset: it.end
-        };
+        const { type, locations } = group;
 
         // start
-        const result = findOriginalRange(bRange, state, originalStateMap);
+        const result = findOriginalRange(group.start, group.end, state, originalStateMap);
         if (result.error) {
-            // not in the original files
+            logMappingErrors('branch group', result);
             return;
         }
-        const { originalRange, originalState } = result;
 
-        const groupStart = originalRange.startOffset;
-        const groupEnd = originalRange.endOffset;
+        // new group start and end
+        const groupStart = result.start;
+        const groupEnd = result.end;
 
         let hasError;
         const newLocations = locations.map((oLoc) => {
@@ -512,29 +571,19 @@ const handleOriginalBranchesCoverage = (state, originalStateMap) => {
                 return newLoc;
             }
 
-            const { start, end } = newLoc;
-
-            const lRange = {
-                startOffset: start,
-                endOffset: end
-            };
-            const res = findOriginalRange(lRange, state, originalStateMap);
-            if (res.error) {
+            const locResult = findOriginalRange(newLoc.start, newLoc.end, state, originalStateMap);
+            if (locResult.error) {
                 // It should not happen unless it is minify files, the SourceMap has some order problems
-
+                logMappingErrors('branch', locResult);
                 hasError = true;
-
-                // console.log('====================================', state.sourcePath, loc);
-                // console.log(res.errors);
-                // Util.logError(`Not found original branch. start: ${start}, end: ${end}`);
-
                 return newLoc;
             }
 
             // mapping to new range
-            const oRage = res.originalRange;
-            newLoc.start = oRage.startOffset;
-            newLoc.end = oRage.endOffset;
+            newLoc.start = locResult.start;
+            newLoc.end = locResult.end;
+            newLoc.generatedStart = newLoc.start;
+            newLoc.generatedEnd = newLoc.end;
 
             return newLoc;
         });
@@ -545,7 +594,7 @@ const handleOriginalBranchesCoverage = (state, originalStateMap) => {
         }
 
         // add back to original ast
-        originalState.astInfo.branches.push({
+        result.originalState.astInfo.branches.push({
             type,
             start: groupStart,
             end: groupEnd,
@@ -556,6 +605,50 @@ const handleOriginalBranchesCoverage = (state, originalStateMap) => {
 
 };
 
+const handleOriginalStatementsCoverage = (state, originalStateMap) => {
+
+    // statements only for js
+    if (!state.js) {
+        return;
+    }
+
+    // statement count
+    state.astInfo.statements.forEach((it) => {
+        const { start, end } = it;
+
+        const result = findOriginalRange(start, end, state, originalStateMap);
+        if (result.error) {
+            logMappingErrors('statement', result);
+            return;
+        }
+
+        // add back to original ast
+        result.originalState.astInfo.statements.push({
+            ... it,
+            generatedStart: start,
+            generatedEnd: end,
+            start: result.start,
+            end: result.end
+        });
+
+    });
+
+    originalStateMap.forEach((originalState) => {
+        const statements = originalState.astInfo.statements;
+        if (Util.isList(statements)) {
+            return;
+        }
+        // fake source nothing matched
+        statements.push({
+            start: 0,
+            end: originalState.source.length,
+            count: 1
+        });
+
+    });
+
+};
+
 const handleOriginalBytesCoverage = (state, originalStateMap) => {
 
     const { js, coverageList } = state;
@@ -572,18 +665,23 @@ const handleOriginalBytesCoverage = (state, originalStateMap) => {
                     return;
                 }
 
-                const result = findOriginalRange(range, state, originalStateMap);
+                const {
+                    startOffset, endOffset, count
+                } = range;
+
+                const result = findOriginalRange(startOffset, endOffset, state, originalStateMap);
                 if (result.error) {
+                    logMappingErrors('byte', result);
                     return;
                 }
 
-                const { originalRange, originalState } = result;
-                addJsBytesCoverage(originalState, originalRange);
-
-                // if (originalRange.startOffset === 110 && originalRange.endOffset === 271) {
-                //     console.log('===============================', originalState.sourcePath);
-                //     console.log(result.startMapping, result.endMapping);
-                // }
+                addJsBytesCoverage(result.originalState, {
+                    generatedStart: startOffset,
+                    generatedEnd: endOffset,
+                    startOffset: result.start,
+                    endOffset: result.end,
+                    count
+                });
 
             });
         });
@@ -613,7 +711,15 @@ const handleOriginalBytesCoverage = (state, originalStateMap) => {
         const endMapping = decodedMappings[len - 1];
         // console.log(startMapping, endMapping);
         const startOffset = startMapping.generatedOffset;
-        const endOffset = endMapping.generatedEndOffset || endMapping.generatedOffset;
+
+        if (!endMapping.generatedEndOffset) {
+            // line last one
+            const line = state.locator.getLine(endMapping.generatedLine + 1);
+            // last column
+            const toEndLength = line.length - endMapping.generatedColumn;
+            endMapping.generatedEndOffset = endMapping.generatedOffset + toEndLength;
+        }
+        const endOffset = endMapping.generatedEndOffset;
 
         // console.log('===========================================================', originalState.sourcePath);
         // console.log(originalState.source.length, endMapping);
@@ -654,11 +760,22 @@ const decodeSourceMappings = (state, originalDecodedMap) => {
     });
 
     const allDecodedMappings = [];
-    let generatedIndex = 0;
     decodedList.forEach((segments, generatedLine) => {
         let info = null;
         segments.forEach((segment) => {
+
+            // const COLUMN = 0;
+            // const SOURCES_INDEX = 1;
+            // const SOURCE_LINE = 2;
+            // const SOURCE_COLUMN = 3;
+            // const NAMES_INDEX = 4;
             const [generatedColumn, sourceIndex, originalLine, originalColumn] = segment;
+            // the segment length could be 1, 4 or 5
+
+            if (typeof sourceIndex === 'undefined') {
+                return;
+            }
+
             const generatedOffset = generatedLocator.locationToOffset({
                 // 1-base
                 line: generatedLine + 1,
@@ -669,7 +786,6 @@ const decodeSourceMappings = (state, originalDecodedMap) => {
                 generatedOffset,
                 generatedLine,
                 generatedColumn,
-                generatedIndex,
 
                 sourceIndex,
                 originalLine,
@@ -677,23 +793,11 @@ const decodeSourceMappings = (state, originalDecodedMap) => {
             };
 
             allDecodedMappings.push(info);
-            generatedIndex += 1;
-
-            if (typeof sourceIndex === 'undefined') {
-                return;
-            }
 
             originalDecodedMap.get(sourceIndex).push(info);
 
         });
 
-        // line last one
-        if (info) {
-            const line = generatedLocator.getLine(info.generatedLine + 1);
-            // last column
-            info.generatedEndOffset = info.generatedOffset + (line.length - info.generatedColumn);
-        }
-
     });
 
     // defaults to sort by generated offset, not need sort
@@ -782,9 +886,11 @@ const initOriginalList = (state, originalDecodedMap, options) => {
             bytes: [],
             functions: [],
             branches: [],
+            statements: [],
             astInfo: {
                 functions: [],
-                branches: []
+                branches: [],
+                statements: []
             },
             // coverage data
             v8Data: {}
@@ -837,6 +943,7 @@ const generateCoverageForDist = (state) => {
 
     handleFunctionsCoverage(state);
     handleBranchesCoverage(state);
+    handleStatementsCoverage(state);
     handleBytesCoverage(state);
 
 };
@@ -868,12 +975,14 @@ const unpackSourceMap = (state, options) => {
     // handle functions before handle original state functions
     handleOriginalFunctionsCoverage(state, originalStateMap);
     handleOriginalBranchesCoverage(state, originalStateMap);
+    handleOriginalStatementsCoverage(state, originalStateMap);
 
     // handle lines info before handle ranges to update line count
     originalStateMap.forEach((originalState) => {
 
         handleFunctionsCoverage(originalState);
         handleBranchesCoverage(originalState);
+        handleStatementsCoverage(originalState);
 
         // if (originalState.sourcePath.endsWith('demo.js')) {
         //     console.log('=================================', originalState.sourcePath);
@@ -881,7 +990,7 @@ const unpackSourceMap = (state, options) => {
 
     });
 
-    // handle ranges after lines ready
+    // handle bytes ranges
     handleOriginalBytesCoverage(state, originalStateMap);
 
     // collect coverage for original list
@@ -892,7 +1001,7 @@ const unpackSourceMap = (state, options) => {
 const unpackDistFile = (item, state, options) => {
 
     if (state.sourceMap) {
-        if (Util.loggingType === 'debug') {
+        if (Util.isDebug()) {
             // js self
             item.debug = true;
             generateCoverageForDist(state);
@@ -1197,7 +1306,7 @@ const convertV8List = (v8list, options) => {
         if (js) {
             coverageList = filterCoverageList(item);
             // remove original functions
-            if (Util.loggingType !== 'debug') {
+            if (!Util.isDebug()) {
                 delete item.functions;
             }
             astInfo = getJsAstInfo(item, coverageList);
@@ -1205,11 +1314,12 @@ const convertV8List = (v8list, options) => {
             // convent css covered ranges to rules ranges and include uncovered ranges
             astInfo = getCssAstInfo(item, coverageList);
             // remove original ranges
-            if (Util.loggingType !== 'debug') {
+            if (!Util.isDebug()) {
                 delete item.ranges;
             }
         }
 
+        // console.log(sourcePath, astInfo.statements.length);
         // ============================
 
         // current file and it's sources from sourceMap
@@ -1226,6 +1336,7 @@ const convertV8List = (v8list, options) => {
             bytes: [],
             functions: [],
             branches: [],
+            statements: [],
             astInfo,
             // for sub source files
             coverageList,