1

wwl

2025-07-30 61b58bd03d04d2eb50ac2d93a188c819fe67e01e

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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
/*
    MIT License http://www.opensource.org/licenses/mit-license.php
    Author Tobias Koppers @sokra
*/
 
"use strict";
 
const RawSource = require("./RawSource");
const Source = require("./Source");
const { getMap, getSourceAndMap } = require("./helpers/getFromStreamChunks");
const streamChunks = require("./helpers/streamChunks");
 
/** @typedef {import("./Source").HashLike} HashLike */
/** @typedef {import("./Source").MapOptions} MapOptions */
/** @typedef {import("./Source").RawSourceMap} RawSourceMap */
/** @typedef {import("./Source").SourceAndMap} SourceAndMap */
/** @typedef {import("./Source").SourceValue} SourceValue */
/** @typedef {import("./helpers/getGeneratedSourceInfo").GeneratedSourceInfo} GeneratedSourceInfo */
/** @typedef {import("./helpers/streamChunks").OnChunk} OnChunk */
/** @typedef {import("./helpers/streamChunks").OnName} OnName */
/** @typedef {import("./helpers/streamChunks").OnSource} OnSource */
/** @typedef {import("./helpers/streamChunks").Options} Options */
 
const REPLACE_REGEX = /\n(?=.|\s)/g;
 
class PrefixSource extends Source {
    /**
     * @param {string} prefix prefix
     * @param {string | Buffer | Source} source source
     */
    constructor(prefix, source) {
        super();
        /**
         * @private
         * @type {Source}
         */
        this._source =
            typeof source === "string" || Buffer.isBuffer(source)
                ? new RawSource(source, true)
                : source;
        this._prefix = prefix;
    }
 
    getPrefix() {
        return this._prefix;
    }
 
    original() {
        return this._source;
    }
 
    /**
     * @returns {SourceValue} source
     */
    source() {
        const node = /** @type {string} */ (this._source.source());
        const prefix = this._prefix;
        return prefix + node.replace(REPLACE_REGEX, `\n${prefix}`);
    }
 
    // TODO efficient buffer() implementation
 
    /**
     * @param {MapOptions=} options map options
     * @returns {RawSourceMap | null} map
     */
    map(options) {
        return getMap(this, options);
    }
 
    /**
     * @param {MapOptions=} options map options
     * @returns {SourceAndMap} source and map
     */
    sourceAndMap(options) {
        return getSourceAndMap(this, options);
    }
 
    /**
     * @param {Options} options options
     * @param {OnChunk} onChunk called for each chunk of code
     * @param {OnSource} onSource called for each source
     * @param {OnName} onName called for each name
     * @returns {GeneratedSourceInfo} generated source info
     */
    streamChunks(options, onChunk, onSource, onName) {
        const prefix = this._prefix;
        const prefixOffset = prefix.length;
        const linesOnly = Boolean(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 + /** @type {number} */ (generatedColumn),
            source:
                source !== undefined
                    ? prefix + source.replace(REPLACE_REGEX, `\n${prefix}`)
                    : undefined,
        };
    }
 
    /**
     * @param {HashLike} hash hash
     * @returns {void}
     */
    updateHash(hash) {
        hash.update("PrefixSource");
        this._source.updateHash(hash);
        hash.update(this._prefix);
    }
}
 
module.exports = PrefixSource;