monocart-coverage-reports 2.3.4 → 2.4.0

package/lib/converter/find-original-range.js

@@ -1,3 +1,5 @@
+const Util = require('../utils/util.js');
+const EC = Util.EC;
 
 const findMapping = (list, offset) => {
     let start = 0;
@@ -16,166 +18,73 @@ const findMapping = (list, offset) => {
         return list[i];
     }
     // last two items, less is start
-    const endItem = list[end];
-    if (offset < endItem.generatedOffset) {
-        return list[start];
-    }
-    return list[end];
-
-};
-
-const findOffsetMapping = (state, offset) => {
-
-    const decodedMappings = state.decodedMappings;
-
-    // possible no length
-    if (!decodedMappings.length) {
-        return {
-            error: true,
-            errors: [`not found decoded mappings for offset: ${offset}`]
-        };
-    }
-
-    const mapping = findMapping(decodedMappings, offset);
-
-    const generatedOffset = mapping.generatedOffset;
-
-    // not found, allow > last, not allow < first
-    if (offset < generatedOffset) {
-        return {
-            error: true,
-            errors: [`not found generated offset: ${offset}`]
-        };
-    }
-
-    // exact matched no need fix
-    const exact = generatedOffset === offset;
-
-    return {
-        ... mapping,
-        // could be fixed if not exact matched
-        column: mapping.originalColumn,
-        exact
-    };
-};
-
-const findNextOriginalDiffMapping = (originalState, mapping) => {
-    const decodedMappings = originalState.decodedMappings;
-    const { originalIndex, originalOffset } = mapping;
-
-    let i = originalIndex + 1;
-    const l = decodedMappings.length;
-    while (i < l) {
-        const item = decodedMappings[i];
-        // sometimes next is same line/column
-        if (item.originalOffset > originalOffset) {
-            return item;
-        }
-        i += 1;
-    }
-};
-
-const findNextGeneratedDiffMapping = (state, mapping) => {
-    const decodedMappings = state.decodedMappings;
-    const i = mapping.generatedIndex + 1;
-    const l = decodedMappings.length;
-    if (i < l) {
-        return decodedMappings[i];
-    }
-};
-
-const getGeneratedText = (mapping, state) => {
-
-    const generatedText = mapping.generatedText;
-    if (typeof generatedText === 'string') {
-        return generatedText;
-    }
-
-    let text = '';
-
-    const locator = state.locator;
-    const nextMapping = findNextGeneratedDiffMapping(state, mapping);
-    if (nextMapping) {
-        text = locator.getSlice(mapping.generatedOffset, nextMapping.generatedOffset);
-    } else {
-        // to the end
-        text = locator.getSlice(mapping.generatedOffset);
+    const startItem = list[start];
+    if (offset === startItem.generatedOffset) {
+        return startItem;
     }
-
-    // never cross line
-    if (mapping.generatedEndOffset) {
-        const len = mapping.generatedEndOffset - mapping.generatedOffset;
-        text = text.slice(0, len);
-    }
-
-    // keep cache
-    mapping.generatedText = text;
-
-    return text;
-
-};
-
-const getOriginalText = (mapping, originalState) => {
-
-    const originalText = mapping.originalText;
-    if (typeof originalText === 'string') {
-        return originalText;
-    }
-
-    let text = '';
-
-    const { locator } = originalState;
-    const nextMapping = findNextOriginalDiffMapping(originalState, mapping);
-    if (nextMapping) {
-        text = locator.getSlice(mapping.originalOffset, nextMapping.originalOffset);
-    } else {
-        // to the end
-        text = locator.getSlice(mapping.originalOffset);
+    const endItem = list[end];
+    if (offset === endItem.generatedOffset) {
+        return endItem;
     }
 
-    // the last two items could have same line and column
-    // so can NOT pre-calculate original end offset, just search new line with regex
-
-    // never cross line
-    const newLineIndex = text.search(/\r?\n/);
-    if (newLineIndex !== -1) {
-        text = text.slice(0, newLineIndex);
+    // between two mappings
+    if (offset > startItem.generatedOffset && offset < endItem.generatedOffset) {
+        return [startItem, endItem];
     }
 
-    // keep cache
-    mapping.originalText = text;
+    // not found the mappings
 
-    return text;
 };
 
 // ========================================================================================================
 
-const getBlockStartPosition = (originalText) => {
-    // start block characters
-
+const getBlockStartPosition = (originalLineText) => {
     // originalText: 'argument) {',
     // generatedLeft: 'o',
     // generatedRight: '&&'
 
     // function/block could be started with {(
-    const startBlockIndex = originalText.search(/[<{(]/);
+    const startBlockIndex = originalLineText.search(/[<{(]/);
     if (startBlockIndex !== -1) {
-        return startBlockIndex;
+        return {
+            pos: startBlockIndex
+        };
     }
 
     // end a block
     const list = ['>', '}', ')'];
     for (const s of list) {
-        const endBlockIndex = originalText.lastIndexOf(s);
+        const endBlockIndex = originalLineText.lastIndexOf(s);
         if (endBlockIndex !== -1) {
-            return endBlockIndex + 1;
+            return {
+                pos: endBlockIndex + 1
+            };
         }
     }
 
-    return -1;
+    // ============================
+    // end characters
+
+    // ends with ">" in vue
+    // <span v-if="data.distFile">
+
+    // originalText: '">',
+    // generatedText: ' ? ((0,vue__.openBlock)(), '
+
+    // originalMethod?.apply
+    // originalText: '?.'  no ?
+
+    const indexEndBlock = originalLineText.search(/(?<=[;,:"'\s])/);
+    if (indexEndBlock !== -1) {
+        return {
+            pos: indexEndBlock
+        };
+    }
+
 };
 
-const getBlockEndPosition = (originalText) => {
+const getBlockEndPosition = (originalLineText) => {
+
     // generatedText: 'e),',
     // generatedPos: 2,
     // originalText: 'prop))'
@@ -190,28 +99,61 @@ const getBlockEndPosition = (originalText) => {
 
     const list = ['>', '}', ')'];
     for (const s of list) {
-        const endBlockIndex = originalText.lastIndexOf(s);
+        const endBlockIndex = originalLineText.lastIndexOf(s);
         if (endBlockIndex !== -1) {
-            return endBlockIndex + 1;
+            return {
+                pos: endBlockIndex + 1
+            };
         }
     }
 
-    const startBlockIndex = originalText.search(/[<{(]/);
+    const startBlockIndex = originalLineText.search(/[<{(]/);
     if (startBlockIndex !== -1) {
-        return startBlockIndex;
+        return {
+            pos: startBlockIndex
+        };
     }
 
-    return -1;
 };
 
-const getOriginalStartPosition = (originalText, generatedText, generatedPos) => {
+const getComparedPosition = (gt, gp, ot, direction) => {
 
-    if (!originalText.length) {
-        return 0;
+    // before trim
+    const oLen = ot.length;
+
+    gt = gt.trimEnd();
+    ot = ot.trimEnd();
+
+    // no content after trim
+    if (!ot.length) {
+        return {
+            pos: direction === 'start' ? oLen : 0
+        };
+    }
+
+    // same content
+    if (gt === ot) {
+        return {
+            pos: gp
+        };
     }
 
-    if (originalText === generatedText) {
-        return generatedPos;
+    // =============================
+
+    // generatedText: '"false";\n',
+    // originalText: "'false';\r\n    ",
+    // generatedPos: 7
+
+    // length not change, replace " to '
+    gt = gt.replace(/"/g, "'");
+    ot = ot.replace(/"/g, "'");
+
+
+    // same content too
+    if (gt === ot) {
+        return {
+            pos: gp
+        };
     }
 
     // ============================
@@ -221,407 +163,525 @@ const getOriginalStartPosition = (originalText, generatedText, generatedPos) =>
     // generatedText: '1;else',
     // generatedLeft: '1;'
 
-    const generatedLeft = generatedText.slice(0, generatedPos);
-    if (originalText.startsWith(generatedLeft)) {
-        return generatedLeft.length;
+    // generatedText: '    var id = options.base ? item[0] + options.base : item[0];\r\n',
+    // originalText: '    var id = options.base ? item[0] + options.base : item[0];\n',
+
+    const left = gt.slice(0, gp);
+    if (ot.startsWith(left)) {
+        return {
+            pos: gp
+        };
     }
 
     // ============================
     // right matched
 
-    // originalText: "'true' : ",
-    // generatedText: '"true" : '
-
-    const generatedRight = generatedText.slice(generatedPos);
-    if (originalText.endsWith(generatedRight)) {
-        return originalText.length - generatedRight.length;
+    const right = gt.slice(gp);
+    if (ot.endsWith(right)) {
+        return {
+            pos: ot.length - right.length
+        };
     }
 
-    // ============================
-    // starts with original text (few case possible useless)
-
-    // generatedText "(void 0, void 0, void 0, function* () {"
-    // originalText " {"
-
-    //   generatedLen: 1629,
-    //   generatedText: '__exports__);\r\n\r\n/***/ }),\r\n\r\n/***/ "./packages/v8',
-    //   generatedPos: 489,
-    //   originalText: '__exports__',
-
-    // original less, generated more
-    // const includeIndex = generatedText.indexOf(originalText);
-    // if (includeIndex !== -1) {
-
-    //     console.log('=================== includeIndex', includeIndex, generatedPos);
-    //     console.log(JSON.stringify(generatedText.slice(0, originalText.length + includeIndex + 10)));
-    //     console.log(JSON.stringify(originalText));
+};
 
-    //     if (includeIndex >= generatedPos) {
-    //         return 0;
-    //     }
+const getSimilarPosition = (info, direction) => {
 
-    //     return originalText.length;
-    // }
+    const {
+        generatedText, generatedPos, originalText
+    } = info;
 
-    // ============================
-    // {} () <>
-    const blockIndex = getBlockStartPosition(originalText);
-    if (blockIndex !== -1) {
-        return blockIndex;
+    const textPos = getComparedPosition(generatedText, generatedPos, originalText, direction);
+    if (textPos) {
+        return textPos;
     }
 
-    // ============================
-    // end characters
-
-    // ends with ">" in vue
-    // <span v-if="data.distFile">
+    // never cross line, using first line of original text
+    // trim end remove \r\n and \n
+    const originalLines = originalText.split(/\n/);
+    if (originalLines.length === 1) {
+        // already single line
+        info.originalLineText = originalText;
+        return;
+    }
 
-    // originalText: '">',
-    // generatedText: ' ? ((0,vue__.openBlock)(), '
+    const originalLineText = originalLines[0].trimEnd();
+    info.originalLineText = originalLineText;
 
-    // originalMethod?.apply
-    // originalText: '?.'  no ?
+    // generatedPos not in first line
+    if (generatedPos > originalLineText.length) {
+        return;
+    }
 
-    const indexEndBlock = originalText.search(/(?<=[;,:"'\s])/);
-    if (indexEndBlock !== -1) {
-        return indexEndBlock;
+    const linePos = getComparedPosition(generatedText, generatedPos, originalLineText, direction);
+    if (linePos) {
+        return linePos;
     }
 
     // console.log('====================================================================');
-    // console.log('start position can NOT be fixed');
+    // console.log(`${EC.magenta(direction)} similar position can NOT be fixed`);
     // console.log({
+    //     sourcePath: info.originalState.sourcePath,
     //     generatedText,
     //     generatedPos,
     //     originalText
-    //     // originalPos
     // });
 
-    // ============================
-    // can NOT be fixed
-    // using original column
-    return 0;
 };
 
-const getOriginalEndPosition = (originalText, generatedText, generatedPos) => {
+const getFixedPosition = (info, direction) => {
 
-    if (!originalText.length) {
-        return 0;
+    const similarPos = getSimilarPosition(info, direction);
+    if (similarPos) {
+        return similarPos.pos;
     }
 
-    if (originalText === generatedText) {
-        return generatedPos;
+    // generatedText: never cross lines
+    // originalText: could be multiple lines
+    // originalLineText: single line originalText
+    const { originalLineText } = info;
+
+    if (direction === 'start') {
+        const blockPos = getBlockStartPosition(originalLineText);
+        if (blockPos) {
+            return blockPos.pos;
+        }
+        return 0;
     }
 
-    // ============================
-    // {} () <>
-    const blockIndex = getBlockEndPosition(originalText);
-    if (blockIndex !== -1) {
-        return blockIndex;
+    const blockPos = getBlockEndPosition(originalLineText);
+    if (blockPos) {
+        return blockPos.pos;
     }
+    return originalLineText.length;
+};
 
-    // console.log('====================================================================');
-    // console.log('end position can NOT be fixed');
-    // console.log({
-    //     generatedText,
-    //     generatedPos,
-    //     originalText
-    //     // originalPos
-    // });
+// ========================================================================================================
 
-    // ============================
-    // can NOT be fixed
-    // to the line end
-    return originalText.length;
+const getOriginalEndOffset = (m, rangeInfo) => {
+    if (!m.originalEndOffset) {
+        const line = rangeInfo.originalState.locator.getLine(m.originalLine + 1);
+        m.originalEndOffset = line ? line.end : m.originalOffset;
+    }
+    return m.originalEndOffset;
 };
 
-// ========================================================================================================
+const getOriginalText = (m1, m2, rangeInfo) => {
+    const originalLocator = rangeInfo.originalState.locator;
 
-const fixStartColumn = (startMapping, range, state, originalState) => {
-    // exact matched no need fix
-    if (startMapping.exact) {
-        // originalColumn is the column
-        return;
+    const o1 = m1.originalOffset;
+    const o2 = m2.originalOffset;
+
+    // most of time o1 < o2
+    if (o1 < o2) {
+        // could be multiple lines for original text
+        return {
+            originalOffset: o1,
+            originalText: originalLocator.getSlice(o1, o2)
+        };
     }
 
-    // fix column
-    const originalColumn = startMapping.originalColumn;
+    // esbuild fixing two mapping have same original
+    // m1 to end line
+    if (o1 === o2) {
+        const originalEndOffset = getOriginalEndOffset(m1, rangeInfo);
+        return {
+            originalOffset: o1,
+            originalText: originalLocator.getSlice(o1, originalEndOffset)
+        };
+    }
 
-    const originalText = getOriginalText(startMapping, originalState);
-    const generatedText = getGeneratedText(startMapping, state);
+    // o1 > o2
+    return {
+        originalOffset: o2,
+        originalText: originalLocator.getSlice(o2, o1)
+    };
 
-    // actual generatedOffset < startOffset
-    const generatedPos = range.startOffset - startMapping.generatedOffset;
+};
 
-    const originalPos = getOriginalStartPosition(originalText, generatedText, generatedPos);
+const getGeneratedText = (m1, m2, state, offset) => {
+    const generatedLocator = state.locator;
 
-    // if (originalState.sourcePath.endsWith('conditional.js') && range.startOffset === 2153) {
-    //     console.log('====================================================================');
-    //     console.log('fix startMapping', originalState.sourcePath);
-    //     console.log(startMapping);
-    //     console.log({
-    //         generatedPos,
-    //         originalPos
-    //     });
-    // }
+    const o1 = m1.generatedOffset;
+    const o2 = m2.generatedOffset;
 
-    // failed if originalPos = 0
-    startMapping.column = originalColumn + originalPos;
+    // same line
+    if (m1.generatedLine === m2.generatedLine) {
+        return {
+            generatedText: generatedLocator.getSlice(o1, o2),
+            generatedPos: offset - o1
+        };
+    }
 
-};
+    // =======================================
+    // different lines
+    // never cross lines
 
-// ========================================================================================================
+    // 1-base
+    const lineInfo = generatedLocator.offsetToLocation(offset);
+    // 0-base
+    const targetLine = lineInfo.line - 1;
 
-const fixEndColumn = (endMapping, range, startMapping, state, originalState) => {
+    // m1 p (case 1, right to end)
+    // p (case 2, mid line)
+    // p (case 3) m2
 
-    const originalColumn = endMapping.originalColumn;
+    // case 1
+    if (targetLine === m1.generatedLine) {
+        return {
+            generatedText: generatedLocator.getSlice(o1, lineInfo.end),
+            generatedPos: offset - o1
+        };
+    }
 
-    // exact matched, but already -1 so need +1
-    if (endMapping.exact) {
-        endMapping.column = originalColumn + 1;
+    // case 3
+    if (targetLine === m2.generatedLine) {
+        return {
+            generatedText: generatedLocator.getSlice(lineInfo.start, o2),
+            generatedPos: offset - lineInfo.start
+        };
+    }
+
+    // case 2
+    return {
+        generatedText: lineInfo.text,
+        generatedPos: offset - lineInfo.start
+    };
+
+};
+
+const checkOriginalMappings = (m1, m2, direction) => {
+    // check original offset order
+    if (m1.originalOffset <= m2.originalOffset) {
         return;
     }
 
-    // ================================
-    // diff line, to the line end
-    // if (endMapping.originalLine !== startMapping.originalLine) {
-    // endMapping.column = Infinity;
-    // return;
+    // just reverse offsets if few cross lines
+    const crossLines = m1.originalLine - m2.originalLine;
+    if (crossLines < 2) {
+        return;
+    }
 
-    // console.log(originalState.sourcePath, '-------------------------------diff line---------------------------------------');
-    // console.log(range, startMapping, endMapping);
+    // console.log('================================================');
+    // console.log(crossLines);
+    // console.log(m1, m2);
 
-    // }
+    // should be mistake
+    return {
+        error: true,
+        errors: [`invalid original ${direction}: ${EC.yellow(m1.originalOffset)} > ${EC.yellow(m2.originalOffset)}`]
+    };
+};
 
-    // ================================
-    // in the same line
+// ========================================================================================================
 
-    const originalText = getOriginalText(endMapping, originalState);
+const getFixedOriginalStart = (start, mappings, state, rangeInfo) => {
+    const { originalState, crossStart } = rangeInfo;
+    const [m1, m2] = mappings;
 
-    // if (originalState.sourcePath.indexOf('comments.js') !== -1) {
-    //     if (range.endOffset === 1077) {
-    //         console.log('----------------------------------------------------------------------');
-    //         console.log(originalText);
-    //         console.log(range, startMapping, endMapping);
-    //     }
-    // }
+    // cross file from start of line
+    if (crossStart) {
+        return {
+            originalStart: m2.originalOffset
+        };
+    }
 
-    // exclusive, need exclude some end strings
-    if (!endMapping.exclusive) {
-        endMapping.column = originalColumn + originalText.length;
-        return;
+    const direction = 'start';
+    const errorInfo = checkOriginalMappings(m1, m2, direction);
+    if (errorInfo) {
+        return errorInfo;
     }
 
+    const { originalText, originalOffset } = getOriginalText(m1, m2, rangeInfo);
+    const { generatedText, generatedPos } = getGeneratedText(m1, m2, state, start);
 
-    const generatedText = getGeneratedText(endMapping, state);
+    const originalPos = getFixedPosition({
+        generatedText,
+        generatedPos,
+        originalText,
+        originalState
+    }, direction);
 
-    // actual generatedOffset < endOffset
-    const generatedPos = range.endOffset - endMapping.generatedOffset;
+    return {
+        originalStart: originalOffset + originalPos
+    };
+};
 
-    const originalPos = getOriginalEndPosition(originalText, generatedText, generatedPos);
+const getFixedOriginalEnd = (end, mappings, state, rangeInfo) => {
 
-    // if (originalState.sourcePath.endsWith('v8/src/app.vue')) {
-    //     console.log('====================================================================');
-    //     console.log('fix endMapping', originalState.sourcePath);
-    //     console.log(startMapping, endMapping);
-    //     const generatedLen = generatedText.length;
-    //     const gt = generatedLen > 50 ? generatedText.slice(0, 50) : generatedText;
-    //     console.log({
-    //         generatedLen,
-    //         generatedText: gt,
-    //         generatedPos,
-    //         originalText,
-    //         originalPos
-    //     });
-    // }
+    const { decodedMappings } = state;
+
+    // end is exclusive, try previous one if exact match
+    const prevMapping = findMapping(decodedMappings, end - 1);
+    if (prevMapping && !Array.isArray(prevMapping)) {
+        return {
+            originalEnd: prevMapping.originalOffset + 1
+        };
+    }
 
-    // failed if originalPos = 0
-    endMapping.column = originalColumn + originalPos;
+    const { originalState, crossEnd } = rangeInfo;
+    const [m1, m2] = mappings;
 
+    // cross file until e1 line end (not file end)
+    if (crossEnd) {
+        const originalEndOffset = getOriginalEndOffset(m1, rangeInfo);
+        return {
+            originalEnd: originalEndOffset
+        };
+    }
+
+    const direction = 'end';
+    const errorInfo = checkOriginalMappings(m1, m2, direction);
+    if (errorInfo) {
+        return errorInfo;
+    }
+
+    const { originalText, originalOffset } = getOriginalText(m1, m2, rangeInfo);
+    const { generatedText, generatedPos } = getGeneratedText(m1, m2, state, end);
+
+    const originalPos = getFixedPosition({
+        generatedText,
+        generatedPos,
+        originalText,
+        originalState
+    }, direction);
+
+    return {
+        originalEnd: originalOffset + originalPos
+    };
 };
 
 // ========================================================================================================
 
-const isOffsetCrossLine = (startMapping, offset) => {
-    const { exact, generatedEndOffset } = startMapping;
-    if (!exact && generatedEndOffset) {
-        if (offset >= generatedEndOffset) {
-            return true;
-        }
+const getOriginalStart = (start, startMapping, state, rangeInfo) => {
+    if (Array.isArray(startMapping)) {
+        return getFixedOriginalStart(start, startMapping, state, rangeInfo);
+    }
+    // Exact match
+    return {
+        originalStart: startMapping.originalOffset
+    };
+};
+
+const getOriginalEnd = (end, endMapping, state, rangeInfo) => {
+    if (Array.isArray(endMapping)) {
+        return getFixedOriginalEnd(end, endMapping, state, rangeInfo);
     }
-    return false;
+    // Exact match
+    return {
+        originalEnd: endMapping.originalOffset
+    };
 };
 
-const findStartMapping = (range, state, originalMap) => {
+// ========================================================================================================
 
-    // startOffset: inclusive
-    const startOffset = range.startOffset;
+const checkSourceFileIndexes = (startIndexes, endIndexes) => {
 
-    const startMapping = findOffsetMapping(state, startOffset);
-    if (startMapping.error) {
+    const checkIndex11 = (s1, e1) => {
+        if (s1 === e1) {
+            return {
+                sourceIndex: s1
+            };
+        }
         return {
-            error: true,
-            errors: startMapping.errors.concat(`not found start mapping: ${startOffset}`)
+            error: true
         };
-    }
+    };
 
-    // check end offset for start mapping only
-    // start mapping is inclusive, do not allow cross line
-    // but end mapping is exclusive and offset do -1, possible no mapping found, do not check it
-    if (isOffsetCrossLine(startMapping, startOffset)) {
-        // try next mapping if its offset in the range
-        const nextMapping = findNextGeneratedDiffMapping(state, startMapping);
-        if (!nextMapping) {
+    const checkIndex21 = (s1, s2, e1) => {
+        if (s1 === e1 || s2 === e1) {
+            if (s1 === s2) {
+                return {
+                    sourceIndex: e1
+                };
+            }
             return {
-                error: true,
-                errors: [`not found next generated mapping: ${startMapping}`]
+                crossStart: true,
+                sourceIndex: e1
             };
         }
+        return {
+            error: true
+        };
+    };
+
+    const checkIndex12 = (s1, e1, e2) => {
+        if (s1 === e1 || s1 === e2) {
+            if (e1 === e2) {
+                return {
+                    sourceIndex: s1
+                };
+            }
+            return {
+                crossEnd: true,
+                sourceIndex: s1
+            };
+        }
+        return {
+            error: true
+        };
+    };
 
-        // ignore out of range
-        if (nextMapping.generatedOffset >= range.endOffset) {
+    const checkIndex22 = (s1, s2, e1, e2) => {
+        // 4 same
+        if (s1 === s2 && e1 === e2 && s1 === e1) {
             return {
-                error: true,
-                errors: [`next generated mapping is out of end offset: ${nextMapping.generatedOffset} >= ${range.endOffset}`]
+                sourceIndex: s1
             };
         }
 
-        // exact and column
-        Object.assign(startMapping, nextMapping, {
-            exact: true,
-            column: nextMapping.originalColumn
-        });
+        if (e1 === e2) {
+            return checkIndex21(s1, s2, e1);
+        }
 
-    }
+        if (s1 === s2) {
+            return checkIndex12(s1, e1, e2);
+        }
 
+        if (s2 === e1) {
+            return {
+                crossStart: true,
+                crossEnd: true,
+                sourceIndex: s2
+            };
+        }
 
-    // check source first, sourceIndex could be undefined
-    const sourceIndex = startMapping.sourceIndex;
+        // both between two mappings: 38,39 ~ 38,39
+        // if (s1 === e1 && s2 === e2) {
+        // }
 
-    const originalState = originalMap.get(sourceIndex);
-    if (!originalState) {
         return {
-            error: true,
-            errors: [`not found original state by source index: ${sourceIndex}`]
+            error: true
         };
+    };
+
+    // both exact matched
+    if (startIndexes.length === 1 && endIndexes.length === 1) {
+        return checkIndex11(startIndexes[0], endIndexes[0]);
     }
 
-    return {
-        startMapping,
-        originalState
-    };
-};
+    if (startIndexes.length === 2 && endIndexes.length === 1) {
+        return checkIndex21(startIndexes[0], startIndexes[1], endIndexes[0]);
+    }
 
+    if (startIndexes.length === 1 && endIndexes.length === 2) {
+        return checkIndex12(startIndexes[0], endIndexes[0], endIndexes[1]);
+    }
 
-const findEndMapping = (range, state, startMapping) => {
+    // both 2 mappings
+    return checkIndex22(startIndexes[0], startIndexes[1], endIndexes[0], endIndexes[1]);
 
-    // endOffset: exclusive
-    const endOffset = range.endOffset;
+};
 
-    // there could be some comments before end mapping even exact matched
-    const endMapping = findOffsetMapping(state, endOffset - 1);
-    if (endMapping.error) {
+const getOriginalState = (startMappings, endMappings, originalMap) => {
+
+    // check source file indexes
+    const startIndexes = [].concat(startMappings).map((it) => it.sourceIndex);
+    const endIndexes = [].concat(endMappings).map((it) => it.sourceIndex);
+    const rangeInfo = checkSourceFileIndexes(startIndexes, endIndexes);
+    if (rangeInfo.error) {
         return {
             error: true,
-            errors: startMapping.errors.concat(`not found end mapping: ${endOffset} - 1 (exclusive)`)
+            errors: [`invalid source indexes: ${EC.yellow(`${startIndexes} ~ ${endIndexes}`)}`]
         };
     }
 
-    // cross file ignore
-    if (endMapping.sourceIndex !== startMapping.sourceIndex) {
+    const {
+        sourceIndex, crossStart, crossEnd
+    } = rangeInfo;
+
+    // if (crossStart || crossEnd) {
+    //     console.log(EC.magenta('cross file'), EC.yellow(`${startIndexes} ~ ${endIndexes}`));
+    // }
+
+    const originalState = originalMap.get(sourceIndex);
+    if (!originalState) {
         return {
             error: true,
-            errors: [`The source index of start and end are not equal: ${startMapping.sourceIndex} != ${endMapping.sourceIndex}`]
+            errors: [`not found original file: ${EC.yellow(sourceIndex)}`]
         };
     }
 
-    // still exclusive
-    const exclusiveMapping = findOffsetMapping(state, endOffset);
-    if (exclusiveMapping && exclusiveMapping.originalOffset === endMapping.originalOffset) {
-        endMapping.exclusive = true;
-    }
+    return {
+        // for debug
+        // startIndexes,
+        // endIndexes,
 
-    return endMapping;
+        sourceIndex,
+        crossStart,
+        crossEnd,
+        originalState
+    };
 };
 
-const findOriginalRange = (range, state, originalMap) => {
+const findOriginalRange = (start, end, state, originalMap) => {
 
-    // if (typeof range.startOffset !== 'number') {
-    //     console.log('=========================================================================', state.sourcePath);
-    //     console.log(range);
-    // }
+    const { sourcePath, decodedMappings } = state;
 
-    // startOffset: inclusive
-    // endOffset: exclusive
-    const startResult = findStartMapping(range, state, originalMap);
-    if (startResult.error) {
+    const createMappingError = (errors) => {
         return {
             error: true,
-            errors: startResult.errors.concat(`not found start mapping: ${range.startOffset}`)
+            start,
+            end,
+            sourcePath,
+            errors
         };
+    };
+
+    // possible no length
+    if (decodedMappings.length < 2) {
+        return createMappingError(['not found decoded mappings']);
     }
-    const { startMapping, originalState } = startResult;
 
-    // ==================================================================================
-    // if (originalState.sourcePath.endsWith('conditional.js') && range.startOffset === 2153) {
-    //     console.log('============================================================', originalState.sourcePath);
-    //     console.log(range);
-    //     console.log(startMapping);
-    // }
-    // ==================================================================================
+    // start: inclusive
+    // end: exclusive
+    // could be 4 mappings found
+
+    const startMappings = findMapping(decodedMappings, start);
+    if (!startMappings) {
+        return {
+            error: true,
+            errors: ['not found start mappings']
+        };
+    }
 
-    const endMapping = findEndMapping(range, state, startMapping);
-    if (endMapping.error) {
+    const endMappings = findMapping(decodedMappings, end);
+    if (!endMappings) {
         return {
             error: true,
-            errors: endMapping.errors.concat(`not found end mapping: ${range.endOffset}`)
+            errors: ['not found end mappings']
         };
     }
 
-    // fix start
-    fixStartColumn(startMapping, range, state, originalState);
+    const rangeInfo = getOriginalState(startMappings, endMappings, originalMap);
+    if (rangeInfo.error) {
+        return createMappingError(rangeInfo.errors);
+    }
 
-    // fix end
-    fixEndColumn(endMapping, range, startMapping, state, originalState);
+    const originalStartResult = getOriginalStart(start, startMappings, state, rangeInfo);
+    if (originalStartResult.error) {
+        return createMappingError(originalStartResult.errors);
+    }
 
-    // after column fixed, the originalOffset could be not right
+    const originalEndResult = getOriginalEnd(end, endMappings, state, rangeInfo);
+    if (originalEndResult.error) {
+        return createMappingError(originalEndResult.errors);
+    }
 
-    const locator = originalState.locator;
-    const originalStart = locator.locationToOffset({
-        line: startMapping.originalLine + 1,
-        column: startMapping.column
-    });
-    const originalEnd = locator.locationToOffset({
-        line: endMapping.originalLine + 1,
-        column: endMapping.column
-    });
+    const { originalStart } = originalStartResult;
+    const { originalEnd } = originalEndResult;
 
-    // range start greater than end
+    // range start > end
     if (originalStart > originalEnd) {
-        // console.log(`start > end: ${originalState.sourcePath}`);
-        // console.log(range, originalRange);
-        return {
-            error: true,
-            errors: [`original start is greater than end: ${originalStart} > ${originalEnd}`]
-        };
+        return createMappingError([`invalid original start > end: ${EC.yellow(originalStart)} > ${EC.yellow(originalEnd)}`]);
     }
 
-    const originalRange = {
-        ... range,
-        startOffset: originalStart,
-        endOffset: originalEnd
-    };
-
-    // if (originalState.showLog) {
-    //     console.log('startMapping and endMapping:');
-    //     console.log(startMapping, endMapping);
-    //     console.log(originalStart, originalEnd);
-    // }
+    const { originalState } = rangeInfo;
 
     return {
-        originalRange,
-        originalState,
-        startMapping,
-        endMapping
+        start: originalStart,
+        end: originalEnd,
+        originalState
     };
 
 };