`
Usage:
sorcery-map [options]

Resolve a chain of sourcemaps back to the original source.

Options:
-h, --help Show help message
-v, --version Show version
-i, --input Input file (option will override default provided value)
-o, --output Output file (if absent, will overwrite input)
-d, --datauri Append map as a data URI, rather than separate file
-x, --excludeContent Do not populate the sourcesContent array

Examples:

# overwrite sourcemap in place (will write map to
# some/generated/code.min.js.map, and update
# sourceMappingURL comment if necessary
sorcery-map -i some/generated/code.min.js

# append flattened sourcemap as an inline data URI
# (will delete existing .map file, if applicable)
sorcery-map -d -i some/generated/code.min.js

# write to a new file (will create newfile.js and
# newfile.js.map)
sorcery-map -i some/generated/code.min.js -o newfile.js
`

$3

`js
interface SourceMap {
version: 3;
file: string;
sources: string[];
sourcesContent: string[];
names: string[];
mappings: string;
sourceRoot: string;
toString(): string;
toUrl(): string;
}

interface Chain {
apply ( apply_options: Options ): SourceMap | null;
trace ( oneBasedLineIndex: number, zeroBasedColumnIndex: number, trace_options: Options ): Trace;

write ( write_options?: Options ): Promise;
write ( dest: string, write_options?: Options ): Promise;
writeSync ( write_options?: Options ): void;
writeSync ( dest: string, write_options?: Options ): void;
}

function load(file: string, options: Options): Promise;
function loadSync(file: string, options: Options): Chain | null;
`

`js
var sorcery_map = require( 'sorcery-map' );

sorcery_map.load( 'some/generated/code.min.js' ).then( function ( chain ) {
// generate a flattened sourcemap
var map = chain.apply(); // { version: 3, file: 'code.min.js', ... }

// get a JSON representation of the sourcemap
map.toString(); // '{"version":3,"file":"code.min.js",...}'

// get a data URI representation
map.toUrl(); // 'data:application/json;charset=utf-8;base64,eyJ2ZXJ...'

// write to a new file - this will create output.js and
// output.js.map, and will preserve relative paths. It
// returns a Promise
chain.write( 'output.js' );

// write to a new file but use an absolute path for the
// sourceMappingURL
chain.write( 'output.js', { absolutePath: true });

// write to a new file, but append the flattened sourcemap as a data URI
chain.write( 'output.js', { inline: true });

// overwrite the existing file
chain.write();
chain.write({ inline: true });

// find the origin of line x, column y. Returns an object with
// source, line, column and (if applicable) name properties.
// Note - for consistency with other tools, line numbers are always
// one-based, column numbers are always zero-based. It's daft, I know.
var loc = chain.trace( x, y );
});

// You can also use sorcery-map synchronously:
var chain = sorcery_map.loadSync( 'some/generated/code.min.js' );
var map = chain.apply();
var loc = chain.trace( x, y );
chain.writeSync();
`

You can pass an optional second argument to sorcery.load() and sorcery.loadSync(), with zero or more of the following properties:
content - a map of filename: contents pairs. filename will be resolved against the current working directory if needs be
sourcemaps - a map of filename: sourcemap pairs, where filename is the name of the file the sourcemap is related to. This will override any sourceMappingURL comments in the file itself.
`js
sorcery_map.load( 'some/generated/code.min.js', {
content: {
'some/minified/code.min.js': '...',
'some/transpiled/code.js': '...',
'some/original/code.js': '...'
},
sourcemaps: {
'some/minified/code.min.js': {...},
'some/transpiled/code.js': {...}
},
existingContentOnly: false
}).then( chain => {
/ ... /
});
`
Any files not found will be read from the filesystem as normal.

Sorcery-exorcist

browserify main.js --debug | sorcery-exorcist bundle.js.map > bundle.js
`

$3

`js
function transform(mapFileOrStream: string | Writable, options?: Options): Transform;
`

`js
const basedir = process.cwd();
const browserify_options = {
debug: true,
basedir,
...options
};

browserify(inputFile, browserify_options)
.bundle()
.pipe(exorcist(mapFile, undefined, undefined, path.dirname(inputFile)))
.pipe(fse.createWriteStream(bundleFile));
`
by such code
`js
.pipe(sorcery_map.transform(mapFile, { flatten: false, sourcePathBase: path.dirname(inputFile) }))]
.pipe(fse.createWriteStream(bundleFile));
`

you can flatten the map at the same time
`js
.pipe(sorcery_map.transform(mapFile, {
flatten: 'existing',
sourcePathBase: path.dirname(inputFile),
excludeContent: true
}))]
.pipe(fse.createWriteStream(bundleFile));
`

Webpack >= 5.x

$3

`js
module.exports = {
...
module: {
rules: [
{
test: /\.js$/,
use: [
{ loader : 'sorcery-map/loader',
options: {
excludeContent: true
}
},
// { loader : "source-map-loader" },
]
},
]
`

$3

Here, webpack will generated map files using absolute paths, our plugin will normalize paths and flattern them.
`js
const SorceryMapperPlugin = require('sorcery-map/plugin');

module.exports = {
...
module: {
devtool: "source-map",
plugins: [new SorceryMapperPlugin( { excludeContent: true } )],

output: {
sourceMapFilename: [file].map,
devtoolModuleFilenameTemplate: "[absolute-resource-path]",
devtoolFallbackModuleFilenameTemplate: "[absolute-resource-path]?[hash]
},

``

License

MIT