qxtj

qx

2025-08-06 fcc0076c3507bc4e544c3cb3915204937fa46f60

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
/*
    MIT License http://www.opensource.org/licenses/mit-license.php
    Author Tobias Koppers @sokra
*/
 
"use strict";
 
/** @typedef {import("./CachedSource").CachedData} CachedData */
/** @typedef {import("./CompatSource").SourceLike} SourceLike */
/** @typedef {import("./ConcatSource").Child} ConcatSourceChild */
/** @typedef {import("./ReplaceSource").Replacement} Replacement */
/** @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} StreamChunksOptions */
 
/**
 * @template T
 * @param {() => T} fn memorized function
 * @returns {() => T} new function
 */
const memoize = (fn) => {
    let cache = false;
    /** @type {T | undefined} */
    let result;
    return () => {
        if (cache) {
            return /** @type {T} */ (result);
        }
 
        result = fn();
        cache = true;
        // Allow to clean up memory for fn
        // and all dependent resources
        /** @type {(() => T) | undefined} */
        (fn) = undefined;
        return /** @type {T} */ (result);
    };
};
 
/**
 * @template A
 * @template B
 * @param {A} obj input a
 * @param {B} exports input b
 * @returns {A & B} merged
 */
const mergeExports = (obj, exports) => {
    const descriptors = Object.getOwnPropertyDescriptors(exports);
    for (const name of Object.keys(descriptors)) {
        const descriptor = descriptors[name];
        if (descriptor.get) {
            const fn = descriptor.get;
            Object.defineProperty(obj, name, {
                configurable: false,
                enumerable: true,
                get: memoize(fn),
            });
        } else if (typeof descriptor.value === "object") {
            Object.defineProperty(obj, name, {
                configurable: false,
                enumerable: true,
                writable: false,
                value: mergeExports({}, descriptor.value),
            });
        } else {
            throw new Error(
                "Exposed values must be either a getter or an nested object",
            );
        }
    }
    return /** @type {A & B} */ (Object.freeze(obj));
};
 
module.exports = mergeExports(
    {},
    {
        get Source() {
            return require("./Source");
        },
        get RawSource() {
            return require("./RawSource");
        },
        get OriginalSource() {
            return require("./OriginalSource");
        },
        get SourceMapSource() {
            return require("./SourceMapSource");
        },
        get CachedSource() {
            return require("./CachedSource");
        },
        get ConcatSource() {
            return require("./ConcatSource");
        },
        get ReplaceSource() {
            return require("./ReplaceSource");
        },
        get PrefixSource() {
            return require("./PrefixSource");
        },
        get SizeOnlySource() {
            return require("./SizeOnlySource");
        },
        get CompatSource() {
            return require("./CompatSource");
        },
        util: {
            get stringBufferUtils() {
                return require("./helpers/stringBufferUtils");
            },
        },
    },
);