monocart-coverage-reports 1.1.0 → 2.0.0

package/lib/converter/converter.js

@@ -4,11 +4,12 @@ const Util = require('../utils/util.js');
 const decodeMappings = require('../utils/decode-mappings.js');
 
 // position mapping for conversion between offset and line/column
-const PositionMapping = require('./position-mapping.js');
+const { Locator } = require('monocart-formatter/node');
 const findOriginalRange = require('./find-original-range.js');
+const { getJsAstInfo, getCssAstInfo } = require('./ast.js');
 
-const { dedupeCountRanges } = require('./dedupe.js');
-const { getSourceType, initSourceMapSourcePath } = require('./source-path.js');
+const { dedupeCountRanges } = require('../utils/dedupe.js');
+const { getSourceType, initSourceMapSourcePath } = require('../utils/source-path.js');
 
 const InfoLine = require('./info-line.js');
 const InfoBranch = require('./info-branch.js');
@@ -16,6 +17,98 @@ const InfoFunction = require('./info-function.js');
 
 // ========================================================================================================
 
+const calculateV8Functions = (functions) => {
+
+    const v8Functions = {
+        total: 0,
+        covered: 0
+    };
+
+    functions.forEach((fn) => {
+        v8Functions.total += 1;
+        if (fn.count > 0) {
+            v8Functions.covered += 1;
+        }
+    });
+
+    return v8Functions;
+};
+
+const calculateV8Branches = (branches) => {
+    const v8Branches = {
+        total: 0,
+        covered: 0
+    };
+
+    branches.forEach((branch) => {
+        branch.locations.forEach((location) => {
+            v8Branches.total += 1;
+            if (location.count > 0) {
+                v8Branches.covered += 1;
+            }
+        });
+    });
+
+    return v8Branches;
+};
+
+const calculateV8Lines = (lines, blankCount, commentCount) => {
+    const v8Lines = {
+        total: 0,
+        covered: 0,
+        blank: blankCount,
+        comment: commentCount
+    };
+
+    lines.forEach((ln) => {
+        v8Lines.total += 1;
+        // full line covered
+        if (ln.covered) {
+            v8Lines.covered += 1;
+        }
+    });
+
+    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
@@ -26,243 +119,387 @@ const InfoFunction = require('./info-function.js');
  * * `f` - hit count for functions
  * * `b` - hit count for branches
  */
-const getFileCoverage = (sourcePath, inputData) => {
+const collectFileCoverage = (item, coverageInfo, state) => {
+
+    const { sourcePath } = item;
 
     const {
-        lines, functions, branches, ranges
-    } = inputData;
+        // v8
+        data,
+
+        // istanbul
+        branches,
 
-    // v8 ranges
-    inputData.ranges = dedupeCountRanges(ranges);
+        functions,
 
-    // istanbul coverage
-    const coverage = {
+        lines,
+        blankCount,
+        commentCount
+
+    } = coverageInfo;
+
+    // ==========================================
+    // v8
+    data.bytes = dedupeCountRanges(data.bytes);
+    item.data = data;
+    item.summary = {
+        functions: calculateV8Functions(functions),
+        branches: calculateV8Branches(branches),
+        lines: calculateV8Lines(lines, blankCount, commentCount)
+    };
+
+    // ==========================================
+    // istanbul
+    const istanbulCoverage = {
         path: sourcePath,
 
         statementMap: {},
-        s: {},
-
         fnMap: {},
-        f: {},
-
         branchMap: {},
+
+        s: {},
+        f: {},
         b: {}
     };
 
     lines.forEach((line, index) => {
-        coverage.statementMap[`${index}`] = line.generate();
-        coverage.s[`${index}`] = line.count;
+        istanbulCoverage.statementMap[`${index}`] = line.generate();
+        istanbulCoverage.s[`${index}`] = line.count;
     });
 
     functions.forEach((fn, index) => {
-        coverage.fnMap[`${index}`] = fn.generate();
-        coverage.f[`${index}`] = fn.count;
+        istanbulCoverage.fnMap[`${index}`] = fn.generate();
+        istanbulCoverage.f[`${index}`] = fn.count;
     });
 
     branches.forEach((branch, index) => {
-        coverage.branchMap[`${index}`] = branch.generate();
-        coverage.b[`${index}`] = [branch.count];
+        istanbulCoverage.branchMap[`${index}`] = branch.generate();
+        istanbulCoverage.b[`${index}`] = branch.generateCounts();
     });
 
-    return coverage;
+    // append to dist file state
+    state.coverageData[sourcePath] = istanbulCoverage;
+
 };
 
 // ========================================================================================================
 
-const setLineCount = (lineMap, line, count) => {
-    const lineInfo = lineMap[line];
-    if (lineInfo) {
-        lineInfo.count = count;
-    }
-};
+// 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 setSingleLineCount = (lineMap, sLoc, eLoc, count) => {
-    // nothing between
-    if (sLoc.column >= eLoc.column) {
-        return;
-    }
+const addJsLineCoverage = (state, range) => {
 
-    // sometimes column > length
-    if (sLoc.column <= sLoc.indent && eLoc.column >= eLoc.length) {
-        // console.log('single', sLoc.line);
-        setLineCount(lineMap, sLoc.line, count);
-    }
+    const { locator, coverageInfo } = state;
+
+    const { data, lineMap } = coverageInfo;
+
+    const {
+        startOffset, endOffset, count
+    } = range;
+
+    // add bytes range
+    data.bytes.push({
+        // index,
+        start: startOffset,
+        end: endOffset,
+        count
+    });
+
+    const sLoc = locator.offsetToLocation(startOffset);
+    const eLoc = locator.offsetToLocation(endOffset);
+
+    // 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);
+    // }
 
 };
 
-const updateLinesCount = (lineMap, sLoc, eLoc, count) => {
+const addCssLineCoverage = (state, range) => {
 
-    // single line
-    if (sLoc.line === eLoc.line) {
-        setSingleLineCount(lineMap, sLoc, eLoc, count);
-        return;
-    }
+    const { coverageInfo, locator } = state;
 
-    const firstELoc = {
-        ... sLoc,
-        column: sLoc.length
-    };
-    setSingleLineCount(lineMap, sLoc, firstELoc, count);
+    const { lineMap, data } = coverageInfo;
+
+    const {
+        start, end, count
+    } = range;
+
+    if (count > 0) {
+        const sLoc = locator.offsetToLocation(start);
+        const eLoc = locator.offsetToLocation(end);
 
-    for (let i = sLoc.line + 1; i < eLoc.line; i++) {
-        setLineCount(lineMap, i, count);
+        // covered css lines
+        const lines = Util.getRangeLines(sLoc, eLoc);
+        lines.forEach((it) => {
+            if (!it.entire) {
+                return;
+            }
+            const line = lineMap.get(it.line);
+            if (line) {
+            // default is uncovered
+            // count always 1, covered is certain
+                line.covered = true;
+            }
+        });
     }
 
-    const lastSLoc = {
-        ... eLoc,
-        column: eLoc.indent
-    };
-    setSingleLineCount(lineMap, lastSLoc, eLoc, count);
+    // add bytes range
+    data.bytes.push(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 initFileCoverage = (positionMapping, count) => {
+const handleFunctionsCoverage = (state) => {
 
-    // istanbul
-    const lines = [];
-    const functions = [];
-    const branches = [];
-    // v8
-    const ranges = [];
+    // functions only for js
+    if (!state.js) {
+        // use css rules data for functions
+        return;
+    }
 
-    // add all lines
-    const lineMap = {};
+    const {
+        locator, coverageInfo, astInfo
+    } = state;
 
-    const { commentedLines, blankLines } = positionMapping;
-    positionMapping.lines.forEach((it) => {
-        // exclude comments and blanks
-        if (commentedLines.includes(it.line) || blankLines.includes(it.line)) {
-            return;
-        }
-        // line 1-base
-        const line = it.line + 1;
-        const lineInfo = new InfoLine(line, it.length, count);
-        lineMap[line] = lineInfo;
-        lines.push(lineInfo);
+    const v8Functions = coverageInfo.data.functions;
+    const istanbulFunctions = coverageInfo.functions;
+
+    astInfo.functions.forEach((it) => {
+        const {
+            start, end, functionName, count
+        } = it;
+
+        v8Functions.push({
+            start,
+            end,
+            count
+        });
+
+        const loc = {
+            start,
+            end
+        };
+        updateOffsetToLocation(locator, loc);
+        const functionInfo = new InfoFunction(loc, count, functionName);
+        istanbulFunctions.push(functionInfo);
     });
 
-    return {
-        lines, functions, branches, ranges, lineMap
-    };
+    // if (state.sourcePath.endsWith('store.js')) {
+    //     console.log('==========================================================');
+    //     console.log(astInfo.functions);
+    //     console.log(functions);
+    // }
+
 };
 
+const handleBranchesCoverage = (state) => {
 
-// 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.
- */
-const addJsCoverage = (coverage, block, range, index, positionMapping) => {
+    // functions only for js
+    if (!state.js) {
+        return;
+    }
 
     const {
-        functions, branches, ranges, lineMap
-    } = coverage;
+        locator, coverageInfo, astInfo
+    } = state;
 
-    const { isBlockCoverage, functionName } = block;
-    const {
-        startOffset, endOffset, count
-    } = range;
+    const v8Branches = coverageInfo.data.branches;
+    const isTanbulBranches = coverageInfo.branches;
+    astInfo.branches.forEach((it) => {
 
-    ranges.push({
-        start: startOffset,
-        end: endOffset,
-        count
-    });
+        const branchType = it.type;
+        const branchLoc = {
+            ... it.loc
+        };
+        updateOffsetToLocation(locator, branchLoc);
 
-    const sLoc = positionMapping.offsetToLocation(startOffset);
-    const eLoc = positionMapping.offsetToLocation(endOffset);
+        // locations
+        // [ { start:{line,column}, end:{line,column}, count }, ...]
+        const locations = it.locations.map((oLoc) => {
+            const newLoc = {
+                ... oLoc
+            };
+            if (newLoc.none) {
 
-    // line, column
-    updateLinesCount(lineMap, sLoc, eLoc, count);
+                // the branch count is not very accurate
+                v8Branches.push({
+                    start: it.loc.start,
+                    end: it.loc.end,
+                    count: oLoc.count,
+                    none: true
+                });
 
-    if (isBlockCoverage) {
-        if (index === 0) {
-            // The root range counts the number of function calls
-            functions.push(new InfoFunction(sLoc, eLoc, count, functionName));
-        }
+                return newLoc;
+            }
 
-        // index 0 not really a branch, but for covered whole function
-        branches.push(new InfoBranch(sLoc, eLoc, count));
+            // the branch count is not very accurate
+            v8Branches.push({
+                start: oLoc.start,
+                end: oLoc.end,
+                count: oLoc.count
+            });
 
-    } else {
-        functions.push(new InfoFunction(sLoc, eLoc, count, functionName));
+            updateOffsetToLocation(locator, newLoc);
+            return newLoc;
+        });
+
+        const branchInfo = new InfoBranch(branchLoc, locations, branchType);
+        isTanbulBranches.push(branchInfo);
+    });
 
-        // possible have branches in the function but no information for it
 
-    }
 };
 
-const addCssCoverage = (coverage, range, positionMapping) => {
-    const { lineMap } = coverage;
+const handleLinesCoverage = (state) => {
+
+    const {
+        js, locator, coverageInfo
+    } = state;
 
-    const { start, end } = range;
+    const lines = coverageInfo.lines;
+    const lineMap = coverageInfo.lineMap;
 
-    const sLoc = positionMapping.offsetToLocation(start);
-    const eLoc = positionMapping.offsetToLocation(end);
+    // init lines
+    let blankCount = 0;
+    let commentCount = 0;
 
-    // line, column
-    updateLinesCount(lineMap, sLoc, eLoc, 1);
+    // js: 1 (functions include all uncovered)
+    // css: 0 (ranges include all covered)
+    const baseLineCount = js ? 1 : 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;
+        const lineInfo = new InfoLine(line, it.length, baseLineCount);
+        lineMap.set(line, lineInfo);
+        lines.push(lineInfo);
+    });
+
+    coverageInfo.blankCount = blankCount;
+    coverageInfo.commentCount = commentCount;
 };
 
-// ========================================================================================================
+const handleRangesCoverage = (state) => {
 
-const getDistCoverage = (item, state) => {
-    const positionMapping = state.positionMapping;
-    if (item.type === 'js') {
-        const coverage = initFileCoverage(positionMapping, 1);
-        item.functions.forEach((block) => {
-            block.ranges.forEach((range, index) => {
-                addJsCoverage(coverage, block, range, index, positionMapping);
+    const { js, coverageList } = state;
+
+    if (js) {
+        coverageList.forEach((block) => {
+            block.ranges.forEach((range) => {
+                addJsLineCoverage(state, range);
             });
         });
-        return coverage;
+
+    } else {
+        coverageList.forEach((range) => {
+            addCssLineCoverage(state, range);
+        });
     }
 
-    const coverage = initFileCoverage(positionMapping, 0);
-    item.ranges.forEach((range) => {
-        addCssCoverage(coverage, range, positionMapping);
-    });
-    return coverage;
 };
 
-const unpackDistSource = (item, state) => {
-    const coverage = getDistCoverage(item, state);
-    const sourcePath = item.sourcePath;
-    state.coverageData[sourcePath] = getFileCoverage(sourcePath, coverage);
-    // after dedupe
-    item.ranges = coverage.ranges;
+const generateCoverageForDist = (item, state) => {
+
+    // handle coverage
+    handleFunctionsCoverage(state);
+    handleBranchesCoverage(state);
+    handleLinesCoverage(state);
+    handleRangesCoverage(state);
+
+    collectFileCoverage(item, state.coverageInfo, state);
+
 };
 
 // ========================================================================================================
 
-const decodeSourceMappings = async (sourceMap, generatedPositionMapping) => {
+const decodeSourceMappings = async (item, state, originalDecodedMap) => {
+
+    const generatedLocator = state.locator;
+
+    const { sources, mappings } = state.sourceMap;
 
-    const decodedList = await decodeMappings(sourceMap.mappings);
+    const decodedList = await decodeMappings(mappings);
 
-    const originalIndexMap = new Map();
-    sourceMap.sources.forEach((item, i) => {
-        originalIndexMap.set(i, []);
+    sources.forEach((source, i) => {
+        originalDecodedMap.set(i, []);
     });
 
     const allDecodedMappings = [];
     let generatedIndex = 0;
     decodedList.forEach((segments, generatedLine) => {
-        let item = null;
+        let info = null;
         segments.forEach((segment) => {
             const [generatedColumn, sourceIndex, originalLine, originalColumn] = segment;
-            const generatedOffset = generatedPositionMapping.locationToOffset({
+            const generatedOffset = generatedLocator.locationToOffset({
                 // 1-base
                 line: generatedLine + 1,
                 column: generatedColumn
             });
 
-            item = {
+            info = {
                 generatedOffset,
                 generatedLine,
                 generatedColumn,
@@ -273,22 +510,22 @@ const decodeSourceMappings = async (sourceMap, generatedPositionMapping) => {
                 originalColumn
             };
 
-            allDecodedMappings.push(item);
+            allDecodedMappings.push(info);
             generatedIndex += 1;
 
             if (typeof sourceIndex === 'undefined') {
                 return;
             }
 
-            originalIndexMap.get(sourceIndex).push(item);
+            originalDecodedMap.get(sourceIndex).push(info);
 
         });
 
         // line last one
-        if (item) {
-            const line = generatedPositionMapping.getLine(item.generatedLine + 1);
+        if (info) {
+            const line = generatedLocator.getLine(info.generatedLine + 1);
             // last column
-            item.generatedEndOffset = item.generatedOffset + (line.length - item.generatedColumn);
+            info.generatedEndOffset = info.generatedOffset + (line.length - info.generatedColumn);
         }
 
     });
@@ -298,16 +535,12 @@ const decodeSourceMappings = async (sourceMap, generatedPositionMapping) => {
     //     return a.generatedOffset - b.generatedOffset;
     // });
 
-    return {
-        allDecodedMappings,
-        originalIndexMap
-    };
-
+    return allDecodedMappings;
 };
 
-const getOriginalDecodedMappings = (originalIndexMap, sourceIndex, positionMapping) => {
+const getOriginalDecodedMappings = (originalDecodedMap, sourceIndex, locator) => {
     // all mappings for the original file sorted
-    const decodedMappings = originalIndexMap.get(sourceIndex);
+    const decodedMappings = originalDecodedMap.get(sourceIndex);
 
     if (!decodeMappings) {
         return [];
@@ -324,7 +557,7 @@ const getOriginalDecodedMappings = (originalIndexMap, sourceIndex, positionMappi
     // add offset and index
     decodedMappings.forEach((item, i) => {
         item.originalIndex = i;
-        item.originalOffset = positionMapping.locationToOffset({
+        item.originalOffset = locator.locationToOffset({
             line: item.originalLine + 1,
             column: item.originalColumn
         });
@@ -333,19 +566,20 @@ const getOriginalDecodedMappings = (originalIndexMap, sourceIndex, positionMappi
     return decodedMappings;
 };
 
-const initOriginalList = (sourceMap, originalIndexMap, fileSources, options) => {
+const initOriginalList = (item, state, originalDecodedMap, options) => {
 
     // source filter
-    const { sources, sourcesContent } = sourceMap;
-
     let sourceFilter = options.sourceFilter;
     if (typeof sourceFilter !== 'function') {
         sourceFilter = () => true;
     }
 
+    const fileSources = state.fileSources;
+
     // create original content mappings
-    const map = new Map();
+    const originalMap = new Map();
 
+    const { sources, sourcesContent } = state.sourceMap;
     sources.forEach((sourcePath, sourceIndex) => {
 
         // filter
@@ -363,83 +597,49 @@ const initOriginalList = (sourceMap, originalIndexMap, fileSources, options) =>
         // keep original formatted content
         fileSources[sourcePath] = sourceContent;
 
-        const positionMapping = new PositionMapping(sourceContent);
+        const locator = new Locator(sourceContent);
 
-        const decodedMappings = getOriginalDecodedMappings(originalIndexMap, sourceIndex, positionMapping);
+        const decodedMappings = getOriginalDecodedMappings(originalDecodedMap, sourceIndex, locator);
 
-        const coverage = initFileCoverage(positionMapping, 1);
+        // unpacked file always is js
 
         const type = getSourceType(sourcePath);
 
         const originalState = {
-            source: sourceContent,
+            original: true,
+            // only js sourceMap for now
+            js: true,
             type,
             sourcePath,
-            positionMapping,
+            source: sourceContent,
+            locator,
             decodedMappings,
-            coverage
+            coverageInfo: createEmptyCoverageInfo(),
+            astInfo: {
+                functions: [],
+                branches: []
+            }
         };
 
-        map.set(sourceIndex, originalState);
+        originalMap.set(sourceIndex, originalState);
     });
 
-    return map;
+    return originalMap;
 };
 
-const unpackSourceMap = async (item, state, options) => {
-    const sourceMap = item.sourceMap;
-    const generatedPositionMapping = state.positionMapping;
-    const distFile = sourceMap.file || path.basename(item.sourcePath);
-
-    // keep original urls
-    const fileUrls = {};
-    const sourcePathHandler = options.sourcePath;
-    initSourceMapSourcePath(sourceMap, fileUrls, sourcePathHandler);
-
-    // decode mappings for each original file
-    const time_start_decode = Date.now();
-    const { allDecodedMappings, originalIndexMap } = await decodeSourceMappings(sourceMap, generatedPositionMapping);
-    // only debug level
-    Util.logTime(`decode source mappings ${distFile}`, time_start_decode);
-
-    // filter original list and init list
-    const fileSources = state.fileSources;
-    const originalMap = initOriginalList(sourceMap, originalIndexMap, fileSources, options);
-
-    originalIndexMap.clear();
+const collectOriginalList = (item, state, originalMap) => {
 
-    const generatedState = {
-        decodedMappings: allDecodedMappings,
-        positionMapping: generatedPositionMapping
-    };
-
-    // const time_start_mapping = Date.now();
-    item.functions.forEach((block) => {
-        block.ranges.forEach((range, index) => {
-
-            const result = findOriginalRange(range, generatedState, originalMap);
-            if (!result) {
-                return;
-            }
-
-            const { originalRange, originalState } = result;
-            const { coverage, positionMapping } = originalState;
-            addJsCoverage(coverage, block, originalRange, index, positionMapping);
-
-        });
-    });
+    const { fileUrls, sourceMap } = state;
+    const distFile = sourceMap.file || path.basename(item.sourcePath);
 
     // collect original files
     const sourceList = [];
     originalMap.forEach((originalState) => {
+
         const {
-            source, type, sourcePath, coverage
+            js, type, sourcePath, source, coverageInfo
         } = originalState;
 
-        // generate coverage
-        state.coverageData[sourcePath] = getFileCoverage(sourcePath, coverage);
-        const ranges = coverage.ranges;
-
         // add file item
         const url = fileUrls[sourcePath] || sourcePath;
         const id = Util.calculateSha1(url + source);
@@ -447,17 +647,257 @@ const unpackSourceMap = async (item, state, options) => {
         const sourceItem = {
             url,
             id,
+            js,
             type,
             sourcePath,
             distFile,
-            ranges,
             source
         };
 
+        // generate coverage, coverageInfo for current file, state for dist file
+        collectFileCoverage(sourceItem, coverageInfo, state);
+
         sourceList.push(sourceItem);
     });
 
-    state.sourceList = sourceList;
+    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);
+                // }
+
+            });
+        });
+
+    } else {
+        // support css later
+        // current css no sourceMap, so never come in
+        // coverageList.forEach((range) => {
+
+        // });
+    }
+
+};
+
+const unpackSourceMap = async (item, state, options) => {
+
+    const { sourcePath } = item;
+    const sourceMap = state.sourceMap;
+
+    // keep original urls
+    const fileUrls = {};
+    const sourcePathHandler = options.sourcePath;
+    initSourceMapSourcePath(sourceMap, fileUrls, sourcePathHandler);
+    state.fileUrls = fileUrls;
+
+    // ===============================================
+    // decode mappings for each original file
+    const time_start_decode = Date.now();
+    const originalDecodedMap = new Map();
+    // for find-original-range
+    state.decodedMappings = await decodeSourceMappings(item, state, originalDecodedMap);
+    // only debug level
+    Util.logTime(`decode source mappings: ${sourcePath}`, time_start_decode);
+
+    // filter original list and init list
+    const originalMap = initOriginalList(item, state, originalDecodedMap, options);
+
+    originalDecodedMap.clear();
+
+    // ===============================================
+
+    // handle functions before handle original state functions
+    handleOriginalFunctionsCoverage(state, originalMap);
+    handleOriginalBranchesCoverage(state, originalMap);
+
+    // 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);
+
+    // collect coverage for original list
+    state.sourceList = collectOriginalList(item, state, originalMap);
 
 };
 
@@ -465,10 +905,10 @@ const unpackSourceMap = async (item, state, options) => {
 
 const unpackDistFile = async (item, state, options) => {
 
-    if (item.sourceMap) {
+    if (state.sourceMap) {
         if (Util.loggingType === 'debug') {
             // js self
-            unpackDistSource(item, state, options);
+            generateCoverageForDist(item, state);
         } else {
             item.dedupe = true;
         }
@@ -476,19 +916,13 @@ const unpackDistFile = async (item, state, options) => {
         // unpack source map
         await unpackSourceMap(item, state, options);
 
-        // remove sourceMap
-        delete item.sourceMap;
-
     } else {
 
         // css/js self
-        unpackDistSource(item, state, options);
+        generateCoverageForDist(item, state);
 
     }
 
-    // clean after all
-    delete item.functions;
-
 };
 
 // ========================================================================================================
@@ -508,7 +942,6 @@ const dedupeV8List = (v8list) => {
     }
 };
 
-
 const convertV8List = async (v8list, options) => {
 
     // global file sources and coverage data
@@ -519,18 +952,68 @@ const convertV8List = async (v8list, options) => {
     for (const item of v8list) {
         // console.log([item.id]);
 
-        const { source, sourcePath } = item;
+        const {
+            type, source, sourcePath
+        } = item;
 
-        const positionMapping = new PositionMapping(source);
+        // for source file, type could be ts or vue as extname, but js = true
+        const js = type === 'js';
+        item.js = js;
 
         // append file source
         fileSources[sourcePath] = source;
 
+        // source mapping
+        const locator = new Locator(source);
+
+        // ============================
+        // move  sourceMap
+        const sourceMap = item.sourceMap;
+        if (sourceMap) {
+            delete item.sourceMap;
+        }
+
+        // ============================
+        const coverageInfo = createEmptyCoverageInfo();
+
+        // ============================
+        // move functions and ranges to coverageList
+        let coverageList;
+        let astInfo;
+        if (js) {
+            coverageList = item.functions;
+            // remove original functions
+            if (Util.loggingType !== 'debug') {
+                delete item.functions;
+            }
+            astInfo = getJsAstInfo(item, coverageList);
+        } else {
+            astInfo = getCssAstInfo(item, locator);
+            // convent css covered ranges to rules ranges and include uncovered ranges
+            coverageList = astInfo.coverageList;
+            // console.log(coverageList);
+
+            // remove original ranges
+            if (Util.loggingType !== 'debug') {
+                delete item.ranges;
+            }
+        }
+
+        // ============================
+
         // current file and it's sources from sourceMap
         const state = {
+            js,
+            type,
+            sourcePath,
+            sourceMap,
+            coverageList,
+            locator,
+            coverageInfo,
+            astInfo,
+            // for istanbul data
             fileSources: {},
-            coverageData: {},
-            positionMapping
+            coverageData: {}
         };
 
         await unpackDistFile(item, state, options);