Struct SourceMap

pub struct SourceMap { /* private fields */ }

Available on crate feature __base only.

Represents a sourcemap in memory

This is always represents a regular “non-indexed” sourcemap. Particularly in case the from_reader method is used an index sourcemap will be rejected with an error on reading.

Implementations

impl SourceMap

pub fn from_reader<R>(rdr: R) -> Result<SourceMap, Error>

where R: Read,

Creates a sourcemap from a reader over a JSON stream in UTF-8 format. Optionally a “garbage header” as defined by the sourcemap draft specification is supported. In case an indexed sourcemap is encountered an error is returned.

use sourcemap::SourceMap;
let input: &[_] = b"{
    \"version\":3,
    \"sources\":[\"coolstuff.js\"],
    \"names\":[\"x\",\"alert\"],
    \"mappings\":\"AAAA,GAAIA,GAAI,EACR,IAAIA,GAAK,EAAG,CACVC,MAAM\"
}";
let sm = SourceMap::from_reader(input).unwrap();

While sourcemaps objects permit some modifications, it’s generally not possible to modify tokens after they have been added. For creating sourcemaps from scratch or for general operations for modifying a sourcemap have a look at the SourceMapBuilder.

pub fn to_writer<W>(&self, w: W) -> Result<(), Error>

where W: Write,

Writes a sourcemap into a writer.

Note that this operation will generate an equivalent sourcemap to the one that was generated on load however there might be small differences in the generated JSON and layout. For instance sourceRoot will not be set as upon parsing of the sourcemap the sources will already be expanded.

let sm = SourceMap::from_reader(input).unwrap();
let mut output : Vec<u8> = vec![];
sm.to_writer(&mut output).unwrap();

pub fn to_data_url(&self) -> Result<String, Error>

Encode a sourcemap into a data url.

let sm = SourceMap::from_reader(input).unwrap();
sm.to_data_url().unwrap();

pub fn from_slice(slice: &[u8]) -> Result<SourceMap, Error>

Creates a sourcemap from a reader over a JSON byte slice in UTF-8 format. Optionally a “garbage header” as defined by the sourcemap draft specification is supported. In case an indexed sourcemap is encountered an error is returned.

use sourcemap::SourceMap;
let input: &[_] = b"{
    \"version\":3,
    \"sources\":[\"coolstuff.js\"],
    \"names\":[\"x\",\"alert\"],
    \"mappings\":\"AAAA,GAAIA,GAAI,EACR,IAAIA,GAAK,EAAG,CACVC,MAAM\"
}";
let sm = SourceMap::from_slice(input).unwrap();

pub fn new( file: Option<Arc<str>>, tokens: Vec<RawToken>, names: Vec<Arc<str>>, sources: Vec<Arc<str>>, sources_content: Option<Vec<Option<Arc<str>>>>, ) -> SourceMap

Constructs a new sourcemap from raw components.

• file: an optional filename of the sourcemap
• tokens: a list of raw tokens
• names: a vector of names
• sources a vector of source filenames
• sources_content optional source contents

pub fn get_debug_id(&self) -> Option<DebugId>

Returns the embedded debug id.

pub fn set_debug_id(&mut self, debug_id: Option<DebugId>)

Sets a new value for the debug id.

pub fn get_file(&self) -> Option<&str>

Returns the embedded filename in case there is one.

pub fn set_file<T>(&mut self, value: Option<T>)

where T: Into<Arc<str>>,

Sets a new value for the file.

pub fn get_source_root(&self) -> Option<&str>

Returns the embedded source_root in case there is one.

pub fn set_source_root<T>(&mut self, value: Option<T>)

where T: Into<Arc<str>>,

Sets a new value for the source_root.

pub fn get_token(&self, idx: usize) -> Option<Token<'_>>

Looks up a token by its index.

pub fn get_token_count(&self) -> u32

Returns the number of tokens in the sourcemap.

pub fn tokens(&self) -> TokenIter<'_>

Returns an iterator over the tokens.

pub fn lookup_token(&self, line: u32, col: u32) -> Option<Token<'_>>

Looks up the closest token to a given 0-indexed line and column.

pub fn get_original_function_name( &self, line: u32, col: u32, minified_name: &str, sv: &SourceView, ) -> Option<&str>

Given a location, name and minified source file resolve a minified name to an original function name.

This invokes some guesswork and requires access to the original minified source. This will not yield proper results for anonymous functions or functions that do not have clear function names. (For instance it’s recommended that dotted function names are not passed to this function).

pub fn get_source_count(&self) -> u32

Returns the number of sources in the sourcemap.

pub fn get_source(&self, idx: u32) -> Option<&str>

Looks up a source for a specific index.

pub fn set_source(&mut self, idx: u32, value: &str)

Sets a new source value for an index. This cannot add new sources.

This panics if a source is set that does not exist.

pub fn sources(&self) -> SourceIter<'_>

Iterates over all sources

pub fn get_source_view(&self, idx: u32) -> Option<&SourceView>

Returns the sources content as source view.

pub fn get_source_contents(&self, idx: u32) -> Option<&str>

Looks up the content for a source.

pub fn set_source_contents(&mut self, idx: u32, value: Option<&str>)

Sets source contents for a source.

pub fn source_contents(&self) -> SourceContentsIter<'_>

Iterates over all source contents

pub fn names(&self) -> NameIter<'_>

Returns an iterator over the names.

pub fn get_name_count(&self) -> u32

Returns the number of names in the sourcemap.

pub fn has_names(&self) -> bool

Returns true if there are any names in the map.

pub fn get_name(&self, idx: u32) -> Option<&str>

Looks up a name for a specific index.

pub fn remove_names(&mut self)

Removes all names from the sourcemap.

pub fn rewrite(self, options: &RewriteOptions<'_>) -> Result<SourceMap, Error>

This rewrites the sourcemap according to the provided rewrite options.

The default behavior is to just deduplicate the sourcemap, something that automatically takes place. This for instance can be used to slightly compress sourcemaps if certain data is not wanted.

use sourcemap::{SourceMap, RewriteOptions};
let sm = SourceMap::from_slice(input).unwrap();
let new_sm = sm.rewrite(&RewriteOptions {
    with_names: false,
    ..Default::default()
});

pub fn adjust_mappings(&mut self, adjustment: &SourceMap)

Adjusts the mappings in self using the mappings in adjustment.

Here is the intended use case for this function:

• You have a source file (for example, minified JS) foo.js and a corresponding sourcemap foo.js.map.
• You modify foo.js in some way and generate a sourcemap transform.js.map representing this modification. This can be done using magic-string, for example.
• You want a sourcemap that is “like” foo.js.map, but takes the changes you made to foo.js into account.

Then foo.js.map.adjust_mappings(transform.js.map) is the desired sourcemap.

This function assumes that adjustment contains no relevant information except for mappings. All information about sources and names is copied from self.

Note that the resulting sourcemap will be at most as fine-grained as self..

Trait Implementations

impl Clone for SourceMap

fn clone(&self) -> SourceMap

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for SourceMap

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.