init

马宇豪

2024-07-16 f591c27b57e2418c9495bc02ae8cfff84d35bc18

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
/*
    MIT License http://www.opensource.org/licenses/mit-license.php
    Author Tobias Koppers @sokra
*/
"use strict";
 
const Source = require("./Source");
const RawSource = require("./RawSource");
const streamChunks = require("./helpers/streamChunks");
const { getMap, getSourceAndMap } = require("./helpers/getFromStreamChunks");
 
const REPLACE_REGEX = /\n(?=.|\s)/g;
 
class PrefixSource extends Source {
    constructor(prefix, source) {
        super();
        this._source =
            typeof source === "string" || Buffer.isBuffer(source)
                ? new RawSource(source, true)
                : source;
        this._prefix = prefix;
    }
 
    getPrefix() {
        return this._prefix;
    }
 
    original() {
        return this._source;
    }
 
    source() {
        const node = this._source.source();
        const prefix = this._prefix;
        return prefix + node.replace(REPLACE_REGEX, "\n" + prefix);
    }
 
    // TODO efficient buffer() implementation
 
    map(options) {
        return getMap(this, options);
    }
 
    sourceAndMap(options) {
        return getSourceAndMap(this, options);
    }
 
    streamChunks(options, onChunk, onSource, onName) {
        const prefix = this._prefix;
        const prefixOffset = prefix.length;
        const linesOnly = !!(options && options.columns === false);
        const { generatedLine, generatedColumn, source } = streamChunks(
            this._source,
            options,
            (
                chunk,
                generatedLine,
                generatedColumn,
                sourceIndex,
                originalLine,
                originalColumn,
                nameIndex
            ) => {
                if (generatedColumn !== 0) {
                    // In the middle of the line, we just adject the column
                    generatedColumn += prefixOffset;
                } else if (chunk !== undefined) {
                    // At the start of the line, when we have source content
                    // add the prefix as generated mapping
                    // (in lines only mode we just add it to the original mapping
                    // for performance reasons)
                    if (linesOnly || sourceIndex < 0) {
                        chunk = prefix + chunk;
                    } else if (prefixOffset > 0) {
                        onChunk(prefix, generatedLine, generatedColumn, -1, -1, -1, -1);
                        generatedColumn += prefixOffset;
                    }
                } else if (!linesOnly) {
                    // Without source content, we only need to adject the column info
                    // expect in lines only mode where prefix is added to original mapping
                    generatedColumn += prefixOffset;
                }
                onChunk(
                    chunk,
                    generatedLine,
                    generatedColumn,
                    sourceIndex,
                    originalLine,
                    originalColumn,
                    nameIndex
                );
            },
            onSource,
            onName
        );
        return {
            generatedLine,
            generatedColumn:
                generatedColumn === 0 ? 0 : prefixOffset + generatedColumn,
            source:
                source !== undefined
                    ? prefix + source.replace(REPLACE_REGEX, "\n" + prefix)
                    : undefined
        };
    }
 
    updateHash(hash) {
        hash.update("PrefixSource");
        this._source.updateHash(hash);
        hash.update(this._prefix);
    }
}
 
module.exports = PrefixSource;