monocart-coverage-reports 2.0.7 → 2.0.9

package/lib/converter/converter.js

@@ -1,3 +1,23 @@
+// https://github.com/demurgos/v8-coverage
+/**
+ * @ranges is always non-empty. The first range is called the "root range".
+ * @isBlockCoverage indicates if the function has block coverage information
+ *   @false means that there is a single range and its count is the number of times the function was called.
+ *   @true means that the ranges form a tree of blocks representing how many times each statement or expression inside was executed.
+ *        It detects skipped or repeated statements. The root range counts the number of function calls.
+ * @functionName can be an empty string. This is common for the FunctionCov representing the whole module.
+ */
+// https://github.com/bcoe/v8-coverage
+/**
+* @ranges is always non-empty. The first range is called the "root range".
+* @isBlockCoverage indicates if the function has block coverage information.
+    If this is false, it usually means that the functions was never called.
+    It seems to be equivalent to ranges.length === 1 && ranges[0].count === 0.
+* @functionName can be an empty string. This is common for the FunctionCov representing the whole module.
+*/
+
+// if you have a line of code that says `var x= 10; console.log(x);` that's one line and 2 statements.
+
 const path = require('path');
 
 const Util = require('../utils/util.js');
@@ -7,6 +27,7 @@ const decodeMappings = require('../utils/decode-mappings.js');
 const { Locator } = require('monocart-formatter/node');
 const findOriginalRange = require('./find-original-range.js');
 const { getJsAstInfo, getCssAstInfo } = require('./ast.js');
+const { getIgnoredRanges } = require('./ignore.js');
 
 const { dedupeCountRanges } = require('../utils/dedupe.js');
 const { getSourceType, initSourceMapSourcePath } = require('../utils/source-path.js');
@@ -14,6 +35,120 @@ const { getSourceType, initSourceMapSourcePath } = require('../utils/source-path
 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 handleIgnoredRanges = (list, ignoredRanges) => {
+    list.forEach((item) => {
+        if (item.count > 0) {
+            return;
+        }
+        const range = findInRanges(item.start, item.end, ignoredRanges);
+        if (range) {
+            // console.log(item, range);
+            item.ignored = true;
+        }
+    });
+};
+
+// ========================================================================================================
+
+const updateLinesCount = (bytes, locator, lineMap) => {
+    bytes.forEach((range) => {
+
+        const {
+            start, end, count, ignored
+        } = range;
+
+        const sLoc = locator.offsetToLocation(start);
+        const eLoc = locator.offsetToLocation(end);
+
+        // update lines coverage
+        const lines = Util.getRangeLines(sLoc, eLoc);
+
+        lines.forEach((it) => {
+            const line = lineMap.get(it.line);
+            if (!line) {
+                return;
+            }
+
+            // from outside into inside, uncovered is certain
+            // default is covered
+            if (it.entire) {
+                line.covered = count > 0;
+                line.count = count;
+
+                if (ignored) {
+                    if (!line.covered) {
+                        line.ignored = true;
+                    }
+                }
+
+            } else {
+
+                if (!ignored) {
+                    if (count > 0) {
+                        line.count = count;
+                    } else {
+                    // not covered if any count = 0
+                        line.covered = false;
+                    }
+                }
+
+            }
+
+            // if (!line.history) {
+            //     line.history = [];
+            // }
+            // line.history.push(`${it.entire}-${count}`);
+
+        });
+
+    });
+
+    // if (state.sourcePath.endsWith('component.js')) {
+    //     console.log('===========================================', state.sourcePath);
+    // }
+
+};
+
+const handleLinesCoverage = (bytes, locator) => {
+
+    const lines = [];
+    // line 1 based
+    const lineMap = new Map();
+
+    // init lines
+    let blankCount = 0;
+    let commentCount = 0;
+
+    locator.lines.forEach((it) => {
+        // exclude blank and comment
+        if (it.blank) {
+            blankCount += 1;
+            return;
+        }
+        if (it.comment) {
+            commentCount += 1;
+            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);
+    });
+
+    updateLinesCount(bytes, locator, lineMap);
+
+    return {
+        lines,
+        blankCount,
+        commentCount
+    };
+};
 
 // ========================================================================================================
 
@@ -25,6 +160,10 @@ const calculateV8Functions = (functions) => {
     };
 
     functions.forEach((fn) => {
+        if (fn.ignored) {
+            return;
+        }
+
         v8Functions.total += 1;
         if (fn.count > 0) {
             v8Functions.covered += 1;
@@ -41,12 +180,13 @@ const calculateV8Branches = (branches) => {
     };
 
     branches.forEach((branch) => {
-        branch.locations.forEach((location) => {
-            v8Branches.total += 1;
-            if (location.count > 0) {
-                v8Branches.covered += 1;
-            }
-        });
+        if (branch.ignored) {
+            return;
+        }
+        v8Branches.total += 1;
+        if (branch.count > 0) {
+            v8Branches.covered += 1;
+        }
     });
 
     return v8Branches;
@@ -61,6 +201,10 @@ const calculateV8Lines = (lines, blankCount, commentCount) => {
     };
 
     lines.forEach((ln) => {
+        if (ln.ignored) {
+            // console.log(ln);
+            return;
+        }
         v8Lines.total += 1;
         // full line covered
         if (ln.covered) {
@@ -71,44 +215,7 @@ const calculateV8Lines = (lines, blankCount, commentCount) => {
     return v8Lines;
 };
 
-const createEmptyCoverageInfo = () => {
-
-    // data for v8 UI
-    const data = {
-        bytes: [],
-        functions: [],
-        branches: []
-    };
-
-    const branches = [];
-
-    const functions = [];
-
-    const lines = [];
-    // line 1 based
-    const lineMap = new Map();
-
-    const blankCount = 0;
-    const commentCount = 0;
-
-
-    return {
-        // v8
-        data,
-
-        // istanbul
-        branches,
-
-        functions,
-
-        lines,
-        lineMap,
-        blankCount,
-        commentCount
-
-    };
-};
-
+// ========================================================================================================
 // istanbul coverage format
 /**
  * * `path` - the file path for which coverage is being tracked
@@ -119,32 +226,76 @@ const createEmptyCoverageInfo = () => {
  * * `f` - hit count for functions
  * * `b` - hit count for branches
  */
-const collectFileCoverage = (item, coverageInfo, state) => {
+const collectFileCoverage = (item, state, coverageData, options) => {
 
     const { sourcePath } = item;
-
     const {
-        // v8
-        data,
-
-        // istanbul
+        bytes,
+        functions,
         branches,
+        locator
+    } = state;
 
-        functions,
+    // ==========================================
+    // v8 data
+    const data = {
+        bytes: dedupeCountRanges(bytes),
+        functions: [],
+        branches: []
+    };
 
-        lines,
-        blankCount,
-        commentCount
+    // ==========================================
+    // ignore
+    const ignoredRanges = getIgnoredRanges(locator, options);
+    if (ignoredRanges) {
+
+        // data bytes is start/end/count object
+        handleIgnoredRanges(data.bytes, ignoredRanges);
+
+        // functions is InfoFunction start/end/count instance
+        handleIgnoredRanges(functions, ignoredRanges);
+
+        // branches is InfoBranch start/end/count instance
+        handleIgnoredRanges(branches, ignoredRanges);
+
+        // branch locations start/end/count object
+        branches.forEach((group) => {
+            if (group.ignored) {
+                // all branch group ignored
+                group.locations.forEach((it) => {
+                    it.ignored = true;
+                });
+            } else {
+                handleIgnoredRanges(group.locations, ignoredRanges);
+            }
+        });
+
+        // console.log(ignoredRanges);
+
+    }
+
+    data.functions = functions.map((info) => {
+        return info.getRange();
+    });
+
+    // branch group with locations to flat branches
+    data.branches = branches.map((info) => {
+        return info.getRanges();
+    }).flat();
 
-    } = coverageInfo;
+    // ==========================================
+    // lines
+    // after bytes with ignored, before calculateV8Lines
+    const {
+        lines, blankCount, commentCount
+    } = handleLinesCoverage(data.bytes, locator);
 
     // ==========================================
-    // v8
-    data.bytes = dedupeCountRanges(data.bytes);
+    // v8 data and summary
     item.data = data;
     item.summary = {
-        functions: calculateV8Functions(functions),
-        branches: calculateV8Branches(branches),
+        functions: calculateV8Functions(data.functions),
+        branches: calculateV8Branches(data.branches),
         lines: calculateV8Lines(lines, blankCount, commentCount)
     };
 
@@ -162,296 +313,288 @@ const collectFileCoverage = (item, coverageInfo, state) => {
         b: {}
     };
 
-    lines.forEach((line, index) => {
+    lines.filter((it) => !it.ignored).forEach((line, index) => {
         istanbulCoverage.statementMap[`${index}`] = line.generate();
         istanbulCoverage.s[`${index}`] = line.count;
     });
 
-    functions.forEach((fn, index) => {
-        istanbulCoverage.fnMap[`${index}`] = fn.generate();
+    functions.filter((it) => !it.ignored).forEach((fn, index) => {
+        istanbulCoverage.fnMap[`${index}`] = fn.generate(locator);
         istanbulCoverage.f[`${index}`] = fn.count;
     });
 
-    branches.forEach((branch, index) => {
-        istanbulCoverage.branchMap[`${index}`] = branch.generate();
-        istanbulCoverage.b[`${index}`] = branch.generateCounts();
+    branches.filter((it) => !it.ignored).forEach((branch, index) => {
+        const { map, counts } = branch.generate(locator);
+        istanbulCoverage.branchMap[`${index}`] = map;
+        istanbulCoverage.b[`${index}`] = counts;
     });
 
     // append to dist file state
-    state.coverageData[sourcePath] = istanbulCoverage;
+    coverageData[sourcePath] = istanbulCoverage;
 
 };
 
 // ========================================================================================================
 
-const updateLineCoverage = (start, end, count, lineMap, locator) => {
-    const sLoc = locator.offsetToLocation(start);
-    const eLoc = locator.offsetToLocation(end);
-
-    // update lines coverage
-    const lines = Util.getRangeLines(sLoc, eLoc);
-
-    lines.forEach((it) => {
-        const line = lineMap.get(it.line);
-        if (!line) {
-            return;
-        }
-
-        // from outside into inside, uncovered is certain
-        // default is covered
-        if (it.entire) {
-            line.covered = count > 0;
-            line.count = count;
-        } else {
-            if (count > 0) {
-                line.count = count;
-            } else {
-                // not covered if any count = 0
-                line.covered = false;
-            }
-        }
-
-        // if (!line.history) {
-        //     line.history = [];
-        // }
-        // line.history.push(`${it.entire}-${count}`);
-
-    });
-
-    // if (state.sourcePath.endsWith('component.js')) {
-    //     console.log('===========================================', state.sourcePath);
-    //     console.log(coverageInfo.lines);
-    // }
-};
-
-// https://github.com/demurgos/v8-coverage
-/**
- * @ranges is always non-empty. The first range is called the "root range".
- * @isBlockCoverage indicates if the function has block coverage information
- *   @false means that there is a single range and its count is the number of times the function was called.
- *   @true means that the ranges form a tree of blocks representing how many times each statement or expression inside was executed.
- *        It detects skipped or repeated statements. The root range counts the number of function calls.
- *
- * @functionName can be an empty string. This is common for the FunctionCov representing the whole module.
- */
-// if you have a line of code that says `var x= 10; console.log(x);` that's one line and 2 statements.
-
-const addJsLineCoverage = (state, range) => {
-
-    const { locator, coverageInfo } = state;
-
-    const { data, lineMap } = coverageInfo;
-
+const addJsBytesCoverage = (state, range) => {
     const {
         startOffset, endOffset, count
     } = range;
-
     // add bytes range
-    data.bytes.push({
-        // index,
+    state.bytes.push({
         start: startOffset,
         end: endOffset,
         count
     });
+};
 
-    updateLineCoverage(startOffset, endOffset, count, lineMap, locator);
-
+const addCssBytesCoverage = (state, range) => {
+    const {
+        start, end, count
+    } = range;
+    // add css bytes range, already start, end
+    state.bytes.push({
+        start,
+        end,
+        count
+    });
 };
 
-const addCssLineCoverage = (state, range) => {
+// ========================================================================================================
 
-    const { coverageInfo, locator } = state;
+const handleFunctionsCoverage = (state) => {
 
-    const { lineMap, data } = coverageInfo;
+    // functions only for js
+    if (!state.js) {
+        return;
+    }
 
-    const {
-        start, end, count
-    } = range;
+    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);
+    });
 
-    // add bytes range
-    data.bytes.push(range);
+};
 
-    updateLineCoverage(start, end, count, lineMap, locator);
+const handleBranchesCoverage = (state) => {
+
+    // functions only for js
+    if (!state.js) {
+        return;
+    }
+
+    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 handleBytesCoverage = (state) => {
+
+    const { js, coverageList } = state;
+
+    if (js) {
+        coverageList.forEach((block) => {
+            block.ranges.forEach((range) => {
+                addJsBytesCoverage(state, range);
+            });
+        });
+    } else {
+        coverageList.forEach((range) => {
+            addCssBytesCoverage(state, range);
+        });
+    }
 
-const updateOffsetToLocation = (locator, loc) => {
-    const sLoc = locator.offsetToLocation(loc.start);
-    loc.start = {
-        line: sLoc.line,
-        column: sLoc.column
-    };
-    const eLoc = locator.offsetToLocation(loc.end);
-    loc.end = {
-        line: eLoc.line,
-        column: eLoc.column
-    };
 };
 
-const handleFunctionsCoverage = (state) => {
+// ========================================================================================================
+
+const handleOriginalFunctionsCoverage = (state, originalMap) => {
 
     // functions only for js
     if (!state.js) {
-        // use css rules data for functions
         return;
     }
 
-    const {
-        locator, coverageInfo, astInfo
-    } = state;
-
-    const v8Functions = coverageInfo.data.functions;
-    const istanbulFunctions = coverageInfo.functions;
+    // console.log(state.astInfo.functions);
 
-    astInfo.functions.forEach((it) => {
+    // function count
+    state.astInfo.functions.forEach((it) => {
         const {
-            start, end, functionName, count
+            start, end, wrap
         } = it;
 
-        v8Functions.push({
-            start,
-            end,
-            count
-        });
+        // remove webpack wrap functions for functions count, not for ranges here
+        if (wrap) {
+            return;
+        }
 
-        const loc = {
-            start,
-            end
+        // rename to startOffset and endOffset
+        const range = {
+            startOffset: start,
+            endOffset: end
         };
-        updateOffsetToLocation(locator, loc);
-        const functionInfo = new InfoFunction(loc, count, functionName);
-        istanbulFunctions.push(functionInfo);
-    });
 
-    // if (state.sourcePath.endsWith('store.js')) {
-    //     console.log('==========================================================');
-    //     console.log(astInfo.functions);
-    //     console.log(functions);
-    // }
+        const result = findOriginalRange(range, state, originalMap);
+        if (result.error) {
+            return;
+        }
+        const { originalRange, originalState } = result;
+
+        // add back to original ast
+        originalState.astInfo.functions.push({
+            ... it,
+            generatedStart: start,
+            generatedEnd: end,
+            start: originalRange.startOffset,
+            end: originalRange.endOffset
+        });
+
+        // if (originalState.sourcePath.endsWith('store.js')) {
+        //     console.log('==========================================================');
+        //     console.log(it, result.startMapping, result.endMapping);
+        // }
+
+    });
 
 };
 
-const handleBranchesCoverage = (state) => {
+const handleOriginalBranchesCoverage = (state, originalMap) => {
 
-    // functions only for js
+    // branches only for js
     if (!state.js) {
         return;
     }
 
-    const {
-        locator, coverageInfo, astInfo
-    } = state;
+    // console.log(state.astInfo.branches);
 
-    const v8Branches = coverageInfo.data.branches;
-    const isTanbulBranches = coverageInfo.branches;
-    astInfo.branches.forEach((it) => {
+    // function count
+    state.astInfo.branches.forEach((it) => {
 
-        const branchType = it.type;
-        const branchLoc = {
-            ... it.loc
+        const { type, locations } = it;
+
+        // rename to startOffset and endOffset
+        const bRange = {
+            startOffset: it.start,
+            endOffset: it.end
         };
-        updateOffsetToLocation(locator, branchLoc);
 
-        // locations
-        // [ { start:{line,column}, end:{line,column}, count }, ...]
-        const locations = it.locations.map((oLoc) => {
+        // start
+        const result = findOriginalRange(bRange, state, originalMap);
+        if (result.error) {
+            // not in the original files
+            return;
+        }
+        const { originalRange, originalState } = result;
+
+        const groupStart = originalRange.startOffset;
+        const groupEnd = originalRange.endOffset;
+
+        let hasError;
+        const newLocations = locations.map((oLoc) => {
+
             const newLoc = {
                 ... oLoc
             };
+
             if (newLoc.none) {
+                newLoc.start = groupStart;
+                newLoc.end = groupEnd;
+                return newLoc;
+            }
 
-                // the branch count is not very accurate
-                v8Branches.push({
-                    start: it.loc.start,
-                    end: it.loc.end,
-                    count: oLoc.count,
-                    none: true
-                });
+            const { start, end } = newLoc;
+
+            const lRange = {
+                startOffset: start,
+                endOffset: end
+            };
+            const res = findOriginalRange(lRange, state, originalMap);
+            if (res.error) {
+                // It should not happen unless it is minify files, the SourceMap has some order problems
+
+                hasError = true;
+
+                // console.log('====================================', state.sourcePath, loc);
+                // console.log(res.errors);
+                // Util.logError(`Not found original branch. start: ${start}, end: ${end}`);
 
                 return newLoc;
             }
 
-            // the branch count is not very accurate
-            v8Branches.push({
-                start: oLoc.start,
-                end: oLoc.end,
-                count: oLoc.count
-            });
+            // mapping to new range
+            const oRage = res.originalRange;
+            newLoc.start = oRage.startOffset;
+            newLoc.end = oRage.endOffset;
 
-            updateOffsetToLocation(locator, newLoc);
             return newLoc;
         });
 
-        const branchInfo = new InfoBranch(branchLoc, locations, branchType);
-        isTanbulBranches.push(branchInfo);
-    });
-
-
-};
-
-const handleLinesCoverage = (state) => {
-
-    const { locator, coverageInfo } = state;
-
-    const lines = coverageInfo.lines;
-    const lineMap = coverageInfo.lineMap;
-
-    // init lines
-    let blankCount = 0;
-    let commentCount = 0;
-
-    locator.lines.forEach((it) => {
-        // exclude blank and comment
-        if (it.blank) {
-            blankCount += 1;
-            return;
-        }
-        if (it.comment) {
-            commentCount += 1;
+        // ignored group when found error
+        if (hasError) {
             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);
+
+        // add back to original ast
+        originalState.astInfo.branches.push({
+            type,
+            start: groupStart,
+            end: groupEnd,
+            locations: newLocations
+        });
+
     });
 
-    coverageInfo.blankCount = blankCount;
-    coverageInfo.commentCount = commentCount;
 };
 
-const handleRangesCoverage = (state) => {
+const handleOriginalBytesCoverage = (state, originalMap) => {
 
     const { js, coverageList } = state;
 
+    // const time_start_mapping = Date.now();
     if (js) {
+        // v8 coverage
         coverageList.forEach((block) => {
-            block.ranges.forEach((range) => {
-                addJsLineCoverage(state, range);
-            });
-        });
+            block.ranges.forEach((range, index) => {
 
-    } else {
-        coverageList.forEach((range) => {
-            addCssLineCoverage(state, range);
-        });
-    }
+                // remove wrap functions for original files
+                if (range.wrap) {
+                    // console.log(range);
+                    return;
+                }
 
-};
+                const result = findOriginalRange(range, state, originalMap);
+                if (result.error) {
+                    return;
+                }
 
-const generateCoverageForDist = (item, state) => {
+                const { originalRange, originalState } = result;
+                addJsBytesCoverage(originalState, originalRange);
 
-    // handle coverage
-    handleFunctionsCoverage(state);
-    handleBranchesCoverage(state);
-    handleLinesCoverage(state);
-    handleRangesCoverage(state);
+                // if (originalRange.startOffset === 110 && originalRange.endOffset === 271) {
+                //     console.log('===============================', originalState.sourcePath);
+                //     console.log(result.startMapping, result.endMapping);
+                // }
+
+            });
+        });
+
+    } else {
+        // support css later
+        // current css no sourceMap, so never come in
+        // coverageList.forEach((range) => {
 
-    collectFileCoverage(item, state.coverageInfo, state);
+        // });
+    }
 
 };
 
@@ -548,6 +691,8 @@ const getOriginalDecodedMappings = (originalDecodedMap, sourceIndex, locator) =>
     return decodedMappings;
 };
 
+// ========================================================================================================
+
 const initOriginalList = (state, originalDecodedMap, options) => {
 
     // source filter
@@ -597,7 +742,10 @@ const initOriginalList = (state, originalDecodedMap, options) => {
             source: sourceContent,
             locator,
             decodedMappings,
-            coverageInfo: createEmptyCoverageInfo(),
+            // coverage info
+            bytes: [],
+            functions: [],
+            branches: [],
             astInfo: {
                 functions: [],
                 branches: []
@@ -610,22 +758,24 @@ const initOriginalList = (state, originalDecodedMap, options) => {
     return originalMap;
 };
 
-const collectOriginalList = (item, state, originalMap) => {
+const collectOriginalList = (item, state, originalMap, options) => {
 
     const { fileUrls, sourceMap } = state;
     const distFile = sourceMap.file || path.basename(item.sourcePath);
 
     // collect original files
     const sourceList = [];
+
     originalMap.forEach((originalState) => {
 
         const {
-            js, type, sourcePath, source, coverageInfo
+            js, type, sourcePath, source
         } = originalState;
 
         // add file item
         const url = fileUrls[sourcePath] || sourcePath;
-        const id = Util.calculateSha1(url + source);
+        // add dist for id
+        const id = Util.calculateSha1(distFile + url + source);
 
         const sourceItem = {
             url,
@@ -637,8 +787,8 @@ const collectOriginalList = (item, state, originalMap) => {
             source
         };
 
-        // generate coverage, coverageInfo for current file, state for dist file
-        collectFileCoverage(sourceItem, coverageInfo, state);
+        // generate coverage for current file, state for dist file
+        collectFileCoverage(sourceItem, originalState, state.coverageData, options);
 
         sourceList.push(sourceItem);
     });
@@ -646,184 +796,15 @@ const collectOriginalList = (item, state, originalMap) => {
     return sourceList;
 };
 
-// =======================================================================================
-
-const handleOriginalFunctionsCoverage = (state, originalMap) => {
-
-    // functions only for js
-    if (!state.js) {
-        return;
-    }
-
-    // console.log(state.astInfo.functions);
-
-    // function count
-    state.astInfo.functions.forEach((it) => {
-        const {
-            start, end, wrap
-        } = it;
-
-        // remove webpack wrap functions for functions count, not for ranges here
-        if (wrap) {
-            return;
-        }
-
-        // rename to startOffset and endOffset
-        const range = {
-            startOffset: start,
-            endOffset: end
-        };
-
-        const result = findOriginalRange(range, state, originalMap);
-        if (result.error) {
-            return;
-        }
-        const { originalRange, originalState } = result;
-
-        // add back to original ast
-        originalState.astInfo.functions.push({
-            ... it,
-            generatedStart: start,
-            generatedEnd: end,
-            start: originalRange.startOffset,
-            end: originalRange.endOffset
-        });
-
-        // if (originalState.sourcePath.endsWith('store.js')) {
-        //     console.log('==========================================================');
-        //     console.log(it, result.startMapping, result.endMapping);
-        // }
-
-    });
-
-};
-
-const handleOriginalBranchesCoverage = (state, originalMap) => {
-
-    // branches only for js
-    if (!state.js) {
-        return;
-    }
-
-    // console.log(state.astInfo.branches);
-
-    // function count
-    state.astInfo.branches.forEach((it) => {
-
-        const {
-            type, loc, locations
-        } = it;
-
-        // rename to startOffset and endOffset
-        const bRange = {
-            startOffset: loc.start,
-            endOffset: loc.end
-        };
-
-        // start
-        const result = findOriginalRange(bRange, state, originalMap);
-        if (result.error) {
-            // not in the original files
-            return;
-        }
-        const { originalRange, originalState } = result;
-
-        const newBranchLoc = {
-            start: originalRange.startOffset,
-            end: originalRange.endOffset
-        };
-
-        let hasError;
-        const newLocations = locations.map((oLoc) => {
-
-            const newLoc = {
-                ... oLoc
-            };
-
-            if (newLoc.none) {
-                return newLoc;
-            }
-
-            const { start, end } = newLoc;
-
-            const lRange = {
-                startOffset: start,
-                endOffset: end
-            };
-            const res = findOriginalRange(lRange, state, originalMap);
-            if (res.error) {
-                // It should not happen unless it is minify files, the SourceMap has some order problems
-
-                hasError = true;
-
-                // console.log('====================================', state.sourcePath, loc);
-                // console.log(res.errors);
-                // Util.logError(`Not found original branch. start: ${start}, end: ${end}`);
-
-                return newLoc;
-            }
-
-            const oRage = res.originalRange;
-            newLoc.start = oRage.startOffset;
-            newLoc.end = oRage.endOffset;
-
-            return newLoc;
-        });
-
-        if (hasError) {
-            return;
-        }
-
-        // add back to original ast
-        originalState.astInfo.branches.push({
-            type,
-            loc: newBranchLoc,
-            locations: newLocations
-        });
-
-    });
-
-};
-
-const handleOriginalRangesCoverage = (state, originalMap) => {
-
-    const { js, coverageList } = state;
-
-    // const time_start_mapping = Date.now();
-    if (js) {
-        // v8 coverage
-        coverageList.forEach((block) => {
-            block.ranges.forEach((range, index) => {
-
-                // remove wrap functions for original files
-                if (range.wrap) {
-                    // console.log(range);
-                    return;
-                }
-
-                const result = findOriginalRange(range, state, originalMap);
-                if (result.error) {
-                    return;
-                }
-
-                const { originalRange, originalState } = result;
-                addJsLineCoverage(originalState, originalRange);
-
-                // if (originalRange.startOffset === 110 && originalRange.endOffset === 271) {
-                //     console.log('===============================', originalState.sourcePath);
-                //     console.log(result.startMapping, result.endMapping);
-                // }
+// ========================================================================================================
 
-            });
-        });
+const generateCoverageForDist = (item, state, options) => {
 
-    } else {
-        // support css later
-        // current css no sourceMap, so never come in
-        // coverageList.forEach((range) => {
+    handleFunctionsCoverage(state);
+    handleBranchesCoverage(state);
+    handleBytesCoverage(state);
 
-        // });
-    }
+    collectFileCoverage(item, state, state.coverageData, options);
 
 };
 
@@ -860,38 +841,31 @@ const unpackSourceMap = async (item, state, options) => {
 
     // handle lines info before handle ranges to update line count
     originalMap.forEach((originalState) => {
+
         handleFunctionsCoverage(originalState);
         handleBranchesCoverage(originalState);
-        handleLinesCoverage(originalState);
-
-        // console.log(originalState.sourcePath, '================================');
-        // console.log(originalState.astInfo.functions);
-        // console.log(originalState.source.length);
-        // console.log(originalState.coverageInfo.functions);
 
         // if (originalState.sourcePath.endsWith('demo.js')) {
         //     console.log('=================================', originalState.sourcePath);
-        //     console.log(originalState.coverageInfo.lineMap);
         // }
 
     });
 
     // handle ranges after lines ready
-    handleOriginalRangesCoverage(state, originalMap);
+    handleOriginalBytesCoverage(state, originalMap);
 
     // collect coverage for original list
-    state.sourceList = collectOriginalList(item, state, originalMap);
+    state.sourceList = collectOriginalList(item, state, originalMap, options);
 
 };
 
-// ========================================================================================================
-
 const unpackDistFile = async (item, state, options) => {
 
     if (state.sourceMap) {
         if (Util.loggingType === 'debug') {
             // js self
-            generateCoverageForDist(item, state);
+            item.debug = true;
+            generateCoverageForDist(item, state, options);
         } else {
             item.dedupe = true;
         }
@@ -902,7 +876,7 @@ const unpackDistFile = async (item, state, options) => {
     } else {
 
         // css/js self
-        generateCoverageForDist(item, state);
+        generateCoverageForDist(item, state, options);
 
     }
 
@@ -927,7 +901,7 @@ const dedupeV8List = (v8list) => {
 
 const convertV8List = async (v8list, options) => {
 
-    // global file sources and coverage data
+    // global file sources and coverage
     const fileSources = {};
     const coverageData = {};
     let sourceList = [];
@@ -956,9 +930,6 @@ const convertV8List = async (v8list, options) => {
             delete item.sourceMap;
         }
 
-        // ============================
-        const coverageInfo = createEmptyCoverageInfo();
-
         // ============================
         // move functions and ranges to coverageList
         let coverageList = [];
@@ -989,9 +960,12 @@ const convertV8List = async (v8list, options) => {
             sourceMap,
             coverageList,
             locator,
-            coverageInfo,
+            // coverage info
+            bytes: [],
+            functions: [],
+            branches: [],
             astInfo,
-            // for istanbul data
+            // for istanbul
             fileSources: {},
             coverageData: {}
         };