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
/*
    MIT License http://www.opensource.org/licenses/mit-license.php
    Author Tobias Koppers @sokra
*/
 
"use strict";
 
const createMappingsSerializer = require("./createMappingsSerializer");
const streamChunks = require("./streamChunks");
 
/** @typedef {import("../Source").RawSourceMap} RawSourceMap */
/** @typedef {import("./streamChunks").GeneratedSourceInfo} GeneratedSourceInfo */
/** @typedef {import("./streamChunks").OnChunk} OnChunk */
/** @typedef {import("./streamChunks").OnName} OnName */
/** @typedef {import("./streamChunks").OnSource} OnSource */
/** @typedef {import("./streamChunks").Options} Options */
/** @typedef {import("./streamChunks").SourceMaybeWithStreamChunksFunction} SourceMaybeWithStreamChunksFunction */
 
/**
 * @param {SourceMaybeWithStreamChunksFunction} inputSource input source
 * @param {Options} options options
 * @param {OnChunk} onChunk on chunk
 * @param {OnSource} onSource on source
 * @param {OnName} onName on name
 * @returns {{ result: GeneratedSourceInfo, source: string, map: RawSourceMap | null }} result
 */
const streamAndGetSourceAndMap = (
    inputSource,
    options,
    onChunk,
    onSource,
    onName,
) => {
    let code = "";
    let mappings = "";
    /** @type {(string | null)[]} */
    const potentialSources = [];
    /** @type {(string | null)[]} */
    const potentialSourcesContent = [];
    /** @type {(string | null)[]} */
    const potentialNames = [];
    const addMapping = createMappingsSerializer({ ...options, columns: true });
    const finalSource = Boolean(options && options.finalSource);
    const { generatedLine, generatedColumn, source } = streamChunks(
        inputSource,
        options,
        (
            chunk,
            generatedLine,
            generatedColumn,
            sourceIndex,
            originalLine,
            originalColumn,
            nameIndex,
        ) => {
            if (chunk !== undefined) code += chunk;
            mappings += addMapping(
                generatedLine,
                generatedColumn,
                sourceIndex,
                originalLine,
                originalColumn,
                nameIndex,
            );
            return onChunk(
                finalSource ? undefined : chunk,
                generatedLine,
                generatedColumn,
                sourceIndex,
                originalLine,
                originalColumn,
                nameIndex,
            );
        },
        (sourceIndex, source, sourceContent) => {
            while (potentialSources.length < sourceIndex) {
                potentialSources.push(null);
            }
            potentialSources[sourceIndex] = source;
            if (sourceContent !== undefined) {
                while (potentialSourcesContent.length < sourceIndex) {
                    potentialSourcesContent.push(null);
                }
                potentialSourcesContent[sourceIndex] = sourceContent;
            }
            return onSource(sourceIndex, source, sourceContent);
        },
        (nameIndex, name) => {
            while (potentialNames.length < nameIndex) {
                potentialNames.push(null);
            }
            potentialNames[nameIndex] = name;
            return onName(nameIndex, name);
        },
    );
    const resultSource = source !== undefined ? source : code;
 
    return {
        result: {
            generatedLine,
            generatedColumn,
            source: finalSource ? resultSource : undefined,
        },
        source: resultSource,
        map:
            mappings.length > 0
                ? {
                        version: 3,
                        file: "x",
                        mappings,
                        // We handle broken sources as `null`, in spec this field should be string, but no information what we should do in such cases if we change type it will be breaking change
                        sources: /** @type {string[]} */ (potentialSources),
                        sourcesContent:
                            potentialSourcesContent.length > 0
                                ? /** @type {string[]} */ (potentialSourcesContent)
                                : undefined,
                        names: /** @type {string[]} */ (potentialNames),
                    }
                : null,
    };
};
 
module.exports = streamAndGetSourceAndMap;