const {

ArrayPrototypePush,

JSONParse,

ObjectKeys,

RegExpPrototypeExec,

SafeMap,

StringPrototypeCodePointAt,

} = require('internal/errors');

const { getLazy } = require('internal/util');

// Since the CJS module cache is mutable, which leads to memory leaks when

// modules are deleted, we use a WeakMap so that the source map cache will

// be purged automatically:

const getCjsSourceMapCache = getLazy(() => {

const { IterableWeakMap } = require('internal/util/iterable_weak_map');

return new IterableWeakMap();

const getModuleSourceMapCache = getLazy(() => {

const { SourceMapCacheMap } = require('internal/source_map/source_map_cache_map');

return new SourceMapCacheMap();

});

// The esm cache is not mutable, so we can use a Map without memory concerns:

const esmSourceMapCache = new SafeMap();

// The generated sources is not mutable, so we can use a Map without memory concerns:

// The generated source module/script instance is not accessible, so we can use

// a Map without memory concerns. Separate generated source entries with the module

// source entries to avoid overriding the module source entries with arbitrary

// source url magic comments.

const generatedSourceMapCache = new SafeMap();

const kLeadingProtocol = /^\w+:\/\//;

const kSourceMappingURLMagicComment = /\/[*/]#\s+sourceMappingURL=(?<sourceMappingURL>[^\s]+)/g;

return sourceMapsEnabled;

}

/**

* Enables or disables source maps programmatically.

* @param {boolean} val

*/

function setSourceMapsEnabled(val) {

validateBoolean(val, 'val');

sourceMapsEnabled = val;

}

/**

* Extracts the source url from the content if present. For example

* //# sourceURL=file:///path/to/file

*

* Read more at: https://tc39.es/source-map-spec/#linking-evald-code-to-named-generated-code

* @param {string} content - source content

* @returns {string | null} source url or null if not present

*/

function extractSourceURLMagicComment(content) {

let match;

let matchSourceURL;

return sourceURL;

}

/**

* Extracts the source map url from the content if present. For example

* //# sourceMappingURL=file:///path/to/file

*

* Read more at: https://tc39.es/source-map-spec/#linking-generated-code

* @param {string} content - source content

* @returns {string | null} source map url or null if not present

*/

function extractSourceMapURLMagicComment(content) {

let match;

let lastMatch;

return lastMatch.groups.sourceMappingURL;

}

function maybeCacheSourceMap(filename, content, cjsModuleInstance, isGeneratedSource, sourceURL, sourceMapURL) {

/**

* Caches the source map if it is present in the content, with the given filename, moduleInstance, and sourceURL.

* @param {string} filename - the actual filename

* @param {string} content - the actual source content

* @param {import('internal/modules/cjs/loader').Module | ModuleWrap} moduleInstance - a module instance that

* associated with the source, once this is reclaimed, the source map entry will be removed from the cache

* @param {boolean} isGeneratedSource - if the source was generated and evaluated with the global eval

* @param {string | undefined} sourceURL - the source url

* @param {string | undefined} sourceMapURL - the source map url

*/

function maybeCacheSourceMap(filename, content, moduleInstance, isGeneratedSource, sourceURL, sourceMapURL) {

const sourceMapsEnabled = getSourceMapsEnabled();

if (!(process.env.NODE_V8_COVERAGE || sourceMapsEnabled)) return;

const { normalizeReferrerURL } = require('internal/modules/helpers');

}

const data = dataFromUrl(filename, sourceMapURL);

const url = data ? null : sourceMapURL;

if (cjsModuleInstance) {

getCjsSourceMapCache().set(cjsModuleInstance, {

__proto__: null,

filename,

lineLengths: lineLengths(content),

data,

url,

sourceURL,

});

} else if (isGeneratedSource) {

const entry = {

__proto__: null,

lineLengths: lineLengths(content),

data,

url,

sourceURL,

};

const entry = {

__proto__: null,

lineLengths: lineLengths(content),

data,

// Save the source map url if it is not a data url.

sourceMapURL: data ? null : sourceMapURL,

sourceURL,

};

if (isGeneratedSource) {

generatedSourceMapCache.set(filename, entry);

if (sourceURL) {

generatedSourceMapCache.set(sourceURL, entry);

}

} else {

// If there is no cjsModuleInstance and is not generated source assume we are in a

// "modules/esm" context.

const entry = {

__proto__: null,

lineLengths: lineLengths(content),

data,

url,

sourceURL,

};

esmSourceMapCache.set(filename, entry);

if (sourceURL) {

esmSourceMapCache.set(sourceURL, entry);

}

return;

}

// If it is not a generated source, we assume we are in a "cjs/esm"

// context.

const keys = sourceURL ? [filename, sourceURL] : [filename];

getModuleSourceMapCache().set(keys, entry, moduleInstance);

}

/**

* Caches the source map if it is present in the eval'd source.

* @param {string} content - the eval'd source code

*/

function maybeCacheGeneratedSourceMap(content) {

const sourceMapsEnabled = getSourceMapsEnabled();

if (!(process.env.NODE_V8_COVERAGE || sourceMapsEnabled)) return;

}

}

/**

* Resolves source map payload data from the source url and source map url.

* If the source map url is a data url, the data is returned.

* Otherwise the source map url is resolved to a file path and the file is read.

* @param {string} sourceURL - url of the source file

* @param {string} sourceMappingURL - url of the source map

* @returns {object} deserialized source map JSON object

*/

function dataFromUrl(sourceURL, sourceMappingURL) {

try {

const url = new URL(sourceMappingURL);

return output;

}

/**

* Read source map from file.

* @param {string} mapURL - file url of the source map

* @returns {object} deserialized source map JSON object

*/

function sourceMapFromFile(mapURL) {

try {

const fs = require('fs');

return data;

}

// WARNING: The `sourceMapCacheToObject` and `appendCJSCache` run during

// shutdown. In particular, they also run when Workers are terminated, making

// it important that they do not call out to any user-provided code, including

// built-in prototypes that might have been tampered with.

// WARNING: The `sourceMapCacheToObject` runs during shutdown. In particular,

// it also runs when Workers are terminated, making it important that it does

// not call out to any user-provided code, including built-in prototypes that

// might have been tampered with.

// Get serialized representation of source-map cache, this is used

// to persist a cache of source-maps to disk when NODE_V8_COVERAGE is enabled.

function sourceMapCacheToObject() {

const obj = { __proto__: null };

for (const { 0: k, 1: v } of esmSourceMapCache) {

obj[k] = v;

}

appendCJSCache(obj);

if (ObjectKeys(obj).length === 0) {

const moduleSourceMapCache = getModuleSourceMapCache();

if (moduleSourceMapCache.size === 0) {

return undefined;

}

return obj;

}

function appendCJSCache(obj) {

for (const value of getCjsSourceMapCache()) {

obj[value.filename] = {

const obj = { __proto__: null };

for (const { 0: k, 1: v } of moduleSourceMapCache) {

obj[k] = {

__proto__: null,

lineLengths: value.lineLengths,

data: value.data,

url: value.url,

lineLengths: v.lineLengths,

data: v.data,

url: v.sourceMapURL,

};

}

return obj;

}

/**

* Find a source map for a given actual source URL or path.

* @param {string} sourceURL - actual source URL or path

* @returns {import('internal/source_map/source_map').SourceMap | undefined} a source map or undefined if not found

*/

function findSourceMap(sourceURL) {

if (RegExpPrototypeExec(kLeadingProtocol, sourceURL) === null) {

sourceURL = pathToFileURL(sourceURL).href;

}

if (!SourceMap) {

SourceMap = require('internal/source_map/source_map').SourceMap;

}

let entry = esmSourceMapCache.get(sourceURL) ?? generatedSourceMapCache.get(sourceURL);

if (entry === undefined) {

for (const value of getCjsSourceMapCache()) {

const filename = value.filename;

const cachedSourceURL = value.sourceURL;

if (sourceURL === filename || sourceURL === cachedSourceURL) {

entry = value;

}

}

}

const entry = getModuleSourceMapCache().get(sourceURL) ?? generatedSourceMapCache.get(sourceURL);

if (entry === undefined) {

return undefined;

}