SWC Ecma Parser

https://rustdoc.swc.rs
Admin
An EcmaScript/TypeScript parser for the Rust programming language, featuring heavy testing, robust...
Tokens:10,841,647
Snippets:70,933
Trust Score:9.1
Update:3 months ago
Show doc for...
Tokens:
Raw
### Trim Start Matches Example

Source: https://rustdoc.swc.rs/hstr/struct.Atom.html

Demonstrates trimming characters from the start of a string slice using a slice of characters as a pattern.

```rust
let x: &[_] = &['1', '2'];
assert_eq!("12foo1bar12".trim_start_matches(x), "foo1bar12");
```

--------------------------------

### Lexer Setup and Usage Example

Source: https://rustdoc.swc.rs/src/swc_ecma_lexer/lib.rs.html

Demonstrates how to initialize and use the Lexer with a string input. This is useful for tokenizing code snippets or small files.

```rust
use swc_common::input::StringInput;
use swc_ecma_lexer::Lexer;

fn main() {
    let src = "fn main() { println!(\"Hello, world!\"); }\n";
    let mut lexer = Lexer::new(StringInput::new(src, "test.rs"), None);

    loop {
        let token_and_span = lexer.next_token();
        match token_and_span {
            Err(_) => break,
            Ok(tok) => {
                println!("{:?}", tok.0);
            }
        }
    }
}
```

--------------------------------

### Get Start Position

Source: https://rustdoc.swc.rs/src/swc_common/input.rs.html

Returns the starting byte position of the input.

```rust
pub fn start_pos(&self) -> BytePos {
        self.orig_start
    }
```

--------------------------------

### Setup Plugin Environment and Exports

Source: https://rustdoc.swc.rs/src/swc_plugin_runner/transform_executor.rs.html

Prepares the plugin environment by compiling the module, setting up host environments for various contexts (metadata, transform results, comments, source maps, diagnostics), and initializing the plugin instance with environment variables.

```rust
fn setup_plugin_env_exports(&mut self) -> Result<PluginTransformState, Error> {
        // First, compile plugin module bytes into wasmer::Module and get the
        // corresponding store
        let module_name = self.module_bytes.get_module_name();
        let module = self.module_bytes.compile_module(&*self.runtime);

        let context_key_buffer = Arc::new(Mutex::new(Vec::new()));
        let metadata_env = Arc::new(MetadataContextHostEnvironment::new(
            &self.metadata_context,
            &self.plugin_config,
            &context_key_buffer,
        ));

        let transform_result: Arc<Mutex<Vec<u8>>> = Arc::new(Mutex::new(Vec::new()));
        let transform_env = Arc::new(TransformResultHostEnvironment::new(&transform_result));

        let base_env = Arc::new(BaseHostEnvironment::new());

        let comment_buffer = Arc::new(Mutex::new(Vec::new()));
        let comments_env = Arc::new(CommentHostEnvironment::new(&comment_buffer));

        let source_map_buffer = Arc::new(Mutex::new(Vec::new()));
        let source_map = Arc::new(Mutex::new(self.source_map.clone()));
        let source_map_host_env = Arc::new(SourceMapHostEnvironment::new(
            &source_map,
            &source_map_buffer,
        ));

        let diagnostics_buffer: Arc<Mutex<Vec<u8>>> = Arc::new(Mutex::new(Vec::new()));
        let diagnostics_env = Arc::new(DiagnosticContextHostEnvironment::new(&diagnostics_buffer));

        let import_object = build_import_object(
            metadata_env,
            transform_env,
            base_env,
            comments_env,
            source_map_host_env,
            diagnostics_env,
        );
        let envs = self
            .plugin_env_vars
            .iter()
            .flat_map(|list| list.iter())
            .filter_map(|name| {
                std::env::var(name.as_str())
                    .ok()
                    .map(|value| (name.as_str().into(), value))
            })
            .collect::<Vec<_>>();
        let instance = self
            .runtime
            .init(module_name, import_object, envs, module)?;

        let diag_result: PluginCorePkgDiagnostics =
            PluginSerializedBytes::from_slice(&(&(*diagnostics_buffer.lock()))[..])
                .deserialize()?
                .into_inner();

        Ok(PluginTransformState {
            instance,
            transform_result,
            plugin_core_diag: diag_result,
        })
    }
```

--------------------------------

### Get the start position of a Span

Source: https://rustdoc.swc.rs/swc_common/struct.Span.html

Returns the starting byte position (`lo`) of the span.

```rust
pub fn lo(self) -> BytePos
```

--------------------------------

### StringInput::start_pos - Get the starting byte position

Source: https://rustdoc.swc.rs/swc_common/input/type.SourceFileInput.html

Returns the starting byte position of the input.

```rust
pub fn start_pos(&self) -> BytePos
```

--------------------------------

### HTML AST Crate Setup

Source: https://rustdoc.swc.rs/src/swc_html_ast/lib.rs.html

Initializes the HTML AST crate with linting and configuration. Re-exports base and token modules.

```rust
#![deny(clippy::all)]
#![allow(clippy::large_enum_variant)]

//! AST definitions for HTML.
pub use self::{base::*, token::*};

mod base;
mod token;

```

--------------------------------

### Basic Parser Usage

Source: https://rustdoc.swc.rs/swc_ecma_parser

Shows a complete example of initializing the parser, lexing, and parsing a JavaScript module. It includes error handling and demonstrates how to create a SourceMap and Handler.

```rust
#[macro_use]
extern crate swc_common;
extern crate swc_ecma_parser;
use swc_common::sync::Lrc;
use swc_common::{
    errors::{ColorConfig, Handler},
    FileName, FilePathMapping, SourceMap,
};
use swc_ecma_parser::{lexer::Lexer, Parser, StringInput, Syntax};

fn main() {
    let cm: Lrc<SourceMap> = Default::default();
    let handler = 
        Handler::with_tty_emitter(ColorConfig::Auto, true, false,
        Some(cm.clone()));

    // Real usage
    // let fm = cm
    //     .load_file(Path::new("test.js"))
    //     .expect("failed to load test.js");
    let fm = cm.new_source_file(
        FileName::Custom("test.js".into()).into(),
        "function foo() {}",
    );
    let lexer = Lexer::new(
        // We want to parse ecmascript
        Syntax::Es(Default::default()),
        // EsVersion defaults to es5
        Default::default(),
        StringInput::from(&*fm),
        None,
    );

    let mut parser = Parser::new_from(lexer);

    for e in parser.take_errors() {
        e.into_diagnostic(&handler).emit();
    }

    let _module = parser
        .parse_module()
        .map_err(|mut e| {
            // Unrecoverable fatal error occurred
            e.into_diagnostic(&handler).emit()
        })
        .expect("failed to parser module");
}

```

--------------------------------

### Vec len Example

Source: https://rustdoc.swc.rs/swc_common/pass/struct.AstKindPathGuard.html

Demonstrates how to get the number of elements currently in the vector.

```rust
let a = vec![1, 2, 3];
assert_eq!(a.len(), 3);
```

--------------------------------

### Bundler::new

Source: https://rustdoc.swc.rs/src/swc_bundler/bundler/mod.rs.html

Initializes a new Bundler instance with the provided configuration and dependencies. It sets up necessary context and marks for the bundling process.

```APIDOC
## `Bundler::new`

### Description
Initializes a new `Bundler` instance with the provided configuration and dependencies. It sets up necessary context and marks for the bundling process.

### Signature
```rust
pub fn new(
    globals: &'a Globals,
    cm: Lrc<SourceMap>,
    loader: L,
    resolver: R,
    config: Config,
    hook: Box<dyn 'a + Hook>,
) -> Self
```

### Parameters
* `globals`: A reference to the global environment.
* `cm`: A reference-counted `SourceMap` for managing source code.
* `loader`: An object implementing the `Load` trait for loading modules.
* `resolver`: An object implementing the `Resolve` trait for resolving module paths.
* `config`: The `Config` struct containing bundling options.
* `hook`: A boxed trait object implementing the `Hook` trait for custom hooks.
```

--------------------------------

### Lexer Handler for 'G' Keywords

Source: https://rustdoc.swc.rs/src/swc_ecma_parser/lexer/table.rs.html

Handles keywords starting with 'g', such as 'get'.

```rust
const L_G: ByteHandler = |lexer| {
    lexer.read_keyword_with(&|s| match s {
        "get" => Some(Token::Get),
        _ => None,
    })
};

```

--------------------------------

### Basic String Splitting Examples

Source: https://rustdoc.swc.rs/swc_config/regex/struct.CachedRegex.html

Demonstrates basic usage of the `split` method with different regex patterns and haystacks, including empty strings and multiple delimiters.

```rust
use regex::Regex;

let re = Regex::new(r" ").unwrap();
let hay = "Mary had a little lamb";
let got: Vec<&str> = re.split(hay).collect();
assert_eq!(got, vec!["Mary", "had", "a", "little", "lamb"]);
```

```rust
use regex::Regex;

let re = Regex::new(r"X").unwrap();
let hay = "";
let got: Vec<&str> = re.split(hay).collect();
assert_eq!(got, vec![""]);
```

```rust
use regex::Regex;

let re = Regex::new(r"X").unwrap();
let hay = "lionXXtigerXleopard";
let got: Vec<&str> = re.split(hay).collect();
assert_eq!(got, vec!["lion", "", "tiger", "leopard"]);
```

```rust
use regex::Regex;

let re = Regex::new(r"::").unwrap();
let hay = "lion::tiger::leopard";
let got: Vec<&str> = re.split(hay).collect();
assert_eq!(got, vec!["lion", "tiger", "leopard"]);
```

--------------------------------

### Check if token starts a left-hand side expression

Source: https://rustdoc.swc.rs/src/swc_ecma_lexer/common/parser/expr.rs.html

Determines if the current token can be the start of a left-hand side expression. This is used to guide the parser's decision-making process.

```rust
pub(super) fn is_start_of_left_hand_side_expr<'a>(p: &mut impl Parser<'a>) -> bool {
    let cur = p.input().cur();
    cur.is_this() 
        || cur.is_null() 
        || cur.is_super() 
        || cur.is_true() 
        || cur.is_false() 
        || cur.is_num() 
        || cur.is_bigint() 
        || cur.is_str() 
        || cur.is_no_substitution_template_literal() 
        || cur.is_template_head() 
        || cur.is_lparen() 
        || cur.is_lbrace() 
        || cur.is_lbracket() 
        || cur.is_function() 
        || cur.is_class() 
        || cur.is_new() 
        || cur.is_regexp() 
        || cur.is_import() 
        || cur.is_ident_ref(p.ctx()) 
        || cur.is_backquote() && {
            peek!(p).is_some_and(|peek| peek.is_lparen() || peek.is_less() || peek.is_dot())
        }
}
```

--------------------------------

### Define Entry Point Configuration

Source: https://rustdoc.swc.rs/src/swc_node_bundler/v1/mod.rs.html

Defines how entry points for bundling can be specified, supporting a single file, multiple files, or a map of named files to paths.

```rust
#[derive(Debug, Clone, Deserialize)]
#[serde(untagged, rename = "Entry")]
pub enum EntryConfig {
    File(String),
    Multiple(Vec<String>),
    Files(FxHashMap<String, PathBuf>),
}
```

--------------------------------

### Box::new_uninit Example

Source: https://rustdoc.swc.rs/swc_core/ecma/transforms/testing/babel_like/type.PassFactory.html

Shows how to create a `Box` with uninitialized contents and defer initialization. This requires careful use of `unsafe`.

```rust
let mut five = Box::<u32>::new_uninit();
// Deferred initialization:
five.write(5);
let five = unsafe { five.assume_init() };

assert_eq!(*five, 5)
```

--------------------------------

### Get line boundaries

Source: https://rustdoc.swc.rs/swc_common/source_map/struct.SourceFile.html

Returns the start and end BytePos for a given line index.

```rust
pub fn line_bounds(&self, line_index: usize) -> (BytePos, BytePos)

```

--------------------------------

### Get Span

Source: https://rustdoc.swc.rs/swc_ecma_parser/struct.Parser.html

Calculates the span of source code from a starting byte position to the current position.

```rust
pub fn span(&self, start: BytePos) -> Span
```

--------------------------------

### Main Application Entry Point

Source: https://rustdoc.swc.rs/src/dbg_swc/main.rs.html

The main function initializes logging and then parses command-line arguments to execute the appropriate SWC command. It uses `try_with_handler` to manage errors and SWC's global context.

```rust
fn main() -> Result<(), Error> {
    init()?;

    let cm = Arc::new(SourceMap::default());

    if let Ok(mode) = env::var(CREDUCE_MODE_ENV_VAR) {
        return try_with_handler(
            cm.clone(),
            HandlerOpts {
                color: ColorConfig::Always,
                skip_filename: false,
            },
            |handler| {
                GLOBALS.set(&Globals::default(), || {
                    HANDLER.set(handler, || {
                        //
                        let input = PathBuf::from(
                            env::var(CREDUCE_INPUT_ENV_VAR)
                                .expect("creduce is invoked without the name of input file"),
                        );

                        if mode == "SIZE" {
                            let m = get_minified(cm.clone(), &input, true, true)?;

                            let swc_output = print_js(cm.clone(), &m.module, true)?;

                            let terser_output = get_terser_output(&input, true, true)?;
                            if swc_output.trim().len() > terser_output.trim().len() {
                                // It's interesting, as our output is larger than terser's.
                                return Ok(())
                            }

                            bail!("We don't care about this file")
                        } else if mode == "SEMANTICS" {
                            let m = get_minified(cm.clone(), &input, true, false)?;

                            let swc_output = print_js(cm.clone(), &m.module, true)?;

                            let terser_output = get_terser_output(&input, true, false)?;

                            if swc_output.trim() == terser_output.trim() {
                                bail!("We don't care about this file")
                            }

                            // It's interesting, as our output may have a bug

                            Ok(())
                        } else {
                            unreachable!("Unknown mode `{}`", mode)
                        }
                    })
                })
            },
        )
        .map_err(|e| e.to_pretty_error());
    }

    let args = AppArgs::parse();

    try_with_handler(
        cm.clone(),
        HandlerOpts {
            color: ColorConfig::Always,
            skip_filename: false,
        },
        |handler| {
            GLOBALS.set(&Globals::default(), || {
                HANDLER.set(handler, || match args.cmd {
                    Cmd::Es(cmd) => cmd.run(cm.clone()),
                })
            })
        },
    )
    .map_err(|e| e.to_pretty_error())
}
```

--------------------------------

### TokensInput Position and Flags

Source: https://rustdoc.swc.rs/swc_ecma_lexer/input/struct.TokensInput.html

Methods for getting the start and end positions, and updating token flags.

```APIDOC
## fn start_pos(&self) -> BytePos

### Description
Returns the starting byte position of the tokens.

### Returns
The starting byte position.
```

```APIDOC
## fn end_pos(&self) -> BytePos

### Description
Returns the ending byte position of the tokens.

### Returns
The ending byte position.
```

```APIDOC
## fn update_token_flags(&mut self, _: impl FnOnce(&mut TokenFlags))

### Description
Updates the token flags using a provided closure.

### Parameters
- A closure that takes a mutable reference to `TokenFlags` and modifies it.
```

```APIDOC
## fn token_flags(&self) -> TokenFlags

### Description
Returns the current token flags.

### Returns
The token flags.
```

--------------------------------

### Box::new Example

Source: https://rustdoc.swc.rs/swc_core/ecma/transforms/testing/babel_like/type.PassFactory.html

Demonstrates the basic usage of `Box::new` to allocate a value on the heap.

```rust
let five = Box::new(5);
```

--------------------------------

### JavaScript Examples for CJS Dynamic Import

Source: https://rustdoc.swc.rs/src/swc_ecma_transforms_module/common_js.rs.html

Shows how dynamic imports are handled for both general arguments and literal paths.

```javascript
Promise.resolve(args).then(p => require(p))
```

```javascript
// for literial dynamic import:
Promise.resolve().then(() => require(args))
```

--------------------------------

### Get Start Point of Span

Source: https://rustdoc.swc.rs/swc_common/source_map/struct.SourceMap.html

Returns a new span representing just the start-point of the given span.

```rust
pub fn start_point(&self, sp: Span) -> Span
```

--------------------------------

### Box::try_new_uninit Example (Nightly)

Source: https://rustdoc.swc.rs/swc_core/ecma/transforms/testing/babel_like/type.PassFactory.html

Shows how to attempt creating a `Box` with uninitialized contents, returning an error on allocation failure. This requires `unsafe` for deferred initialization.

```rust
#![feature(allocator_api)]

let mut five = Box::<u32>::try_new_uninit()?;
// Deferred initialization:
five.write(5);
let five = unsafe { five.assume_init() };

assert_eq!(*five, 5);
```

--------------------------------

### Lexer ByteHandler for 'g' keywords

Source: https://rustdoc.swc.rs/src/swc_ecma_lexer/lexer/table.rs.html

Handles keywords starting with 'g' like 'global' and 'get'.

```rust
const L_G: ByteHandler = Some(|lexer| {
    lexer.read_keyword_with(&|s| match s {
        "global" => Some(Token::Word(Word::Ident(IdentLike::Known(
            KnownIdent::Global,
        )))),
        "get" => Some(Token::Word(Word::Ident(IdentLike::Known(KnownIdent::Get)))),
        _ => None,
    })
});
```

--------------------------------

### Bundle JavaScript Entry Point with Deno

Source: https://rustdoc.swc.rs/src/dbg_swc/bundle.rs.html

This function invokes the `deno bundle` command to create a single JavaScript module from a given entry URL. It handles command execution, error checking, and parsing the output into a `ModuleRecord`. Ensure `deno` is installed and accessible in your PATH.

```rust
use std::{
    process::{Command,
        Stdio},
    sync::Arc,
};

use anyhow::{bail,
    Context,
    Result};
use swc_common::{FileName,
    SourceMap};
use swc_timer::timer;

use crate::util::{parse_js,
    wrap_task,
    ModuleRecord};

pub fn bundle(cm: Arc<SourceMap>, entry_url: &str) -> Result<ModuleRecord> {
    wrap_task(|| {
        let _timer = timer!("bundle");

        let mut cmd = Command::new("deno");
        cmd.arg("bundle");
        cmd.arg(entry_url);

        cmd.stderr(Stdio::inherit());

        let output = cmd.output().context("failed to invoke `deno bundle`")?;

        if !output.status.success() {
            bail!("`deno bundle` failed with status code {}", output.status);
        }

        let code =
            String::from_utf8(output.stdout).context("deno bundle emitted non-utf8 output")?;

        let fm = cm.new_source_file(FileName::Anon.into(), code);
        parse_js(fm).context("failed to parse js filed emitted by `deno bundle`")
    })
    .with_context(|| format!("failed to bundle `{entry_url}`"))
}
```

--------------------------------

### Safe Get Disjoint Mut Example (RangeInclusive)

Source: https://rustdoc.swc.rs/swc_common/pass/struct.AstKindPath.html

Demonstrates using `get_disjoint_mut` with an array of `RangeInclusive`s to safely get mutable references to slices. This method checks for bounds and overlaps, returning a `Result`.

```rust
let v = &mut [1, 2, 3];
if let Ok([a, b]) = v.get_disjoint_mut([1..=2, 0..=0]) {
    a[0] = 11;
    a[1] = 111;
    b[0] = 1;
}
assert_eq!(v, &[1, 11, 111]);
```

--------------------------------

### Timer macro basic example

Source: https://rustdoc.swc.rs/src/swc_timer/lib.rs.html

A basic example of using the timer! macro. It creates a timer with an empty description. Ensure tracing is set up for this to function correctly.

```rust
use swc_timer::timer;
# let _logger = testing::init();
let _timer = timer!("");
```

--------------------------------

### Safe Get Disjoint Mut Example (Range)

Source: https://rustdoc.swc.rs/swc_common/pass/struct.AstKindPath.html

Demonstrates using `get_disjoint_mut` with an array of `Range`s to safely get mutable references to slices. This method checks for bounds and overlaps, returning a `Result`.

```rust
let v = &mut [1, 2, 3];
if let Ok([a, b]) = v.get_disjoint_mut([0..1, 1..3]) {
    a[0] = 8;
    b[0] = 88;
    b[1] = 888;
}
assert_eq!(v, &[8, 88, 888]);
```

--------------------------------

### Get Start Position of Parser Input

Source: https://rustdoc.swc.rs/src/swc_css_parser/parser/input.rs.html

Returns the starting byte position of the parser's input. This method is implemented for the `ParserInput` trait and works for both token lists and component value lists.

```rust
fn start_pos(&mut self) -> BytePos {
        match self.input {
            InputType::Tokens(input) => input.span.lo,
            InputType::ListOfComponentValues(input) => input.span.lo,
        }
    }
```

--------------------------------

### Dummy Method for CustomMediaQuery

Source: https://rustdoc.swc.rs/swc_core/common/util/take/trait.Take.html

Example of a `dummy` method implementation for `CustomMediaQuery`.

```rust
fn dummy() -> CustomMediaQuery
```

--------------------------------

### Unsafe Get Disjoint Unchecked Mut Example (RangeInclusive)

Source: https://rustdoc.swc.rs/swc_common/pass/struct.AstKindPath.html

Demonstrates using `get_disjoint_unchecked_mut` with an array of `RangeInclusive`s to get mutable references to slices. This method performs no bounds or overlap checks and requires `unsafe`.

```rust
let x = &mut [1, 2, 4];

unsafe {
    let [a, b] = x.get_disjoint_unchecked_mut([1..=2, 0..=0]);
    a[0] = 11;
    a[1] = 111;
    b[0] = 1;
}
assert_eq!(x, &[1, 11, 111]);
```

--------------------------------

### Initialize UsageVisitor

Source: https://rustdoc.swc.rs/src/swc_ecma_preset_env/corejs3/usage.rs.html

Creates a new `UsageVisitor` instance. It initializes tracking for shipped proposals, target environment, and core-js version, and prepares a set to store required polyfills.

```rust
pub(crate) struct UsageVisitor {
    shipped_proposals: bool,
    is_any_target: bool,
    target: Arc<Versions>,
    corejs_version: Version,
    pub required: IndexSet<&'static str, FxBuildHasher>,
}

impl UsageVisitor {
    pub fn new(target: Arc<Versions>, shipped_proposals: bool, corejs_version: Version) -> Self {
        //        let mut v = Self { required: Vec::new() };
        //
        //
        //        let is_web_target = target
        //            .iter()
        //            .any(|(name, version)| name != "node" &&
        // version.is_some());
        //
        //        println!(
        //            "is_any_target={:?}\nis_web_target={:?}",
        //            is_any_target, is_web_target
        //        );
        //
        //        // Web default
        //        if is_any_target || is_web_target {
        //            v.add(&["web.timers", "web.immediate",
        // "web.dom.iterable"]);        }
        //        v
        //
        Self {
            shipped_proposals,
            is_any_target: target.is_any_target(),
            target,
            corejs_version,
            required: Default::default(),
        }
    }

```

--------------------------------

### Unsafe Get Disjoint Unchecked Mut Example (Range)

Source: https://rustdoc.swc.rs/swc_common/pass/struct.AstKindPath.html

Demonstrates using `get_disjoint_unchecked_mut` with an array of `Range`s to get mutable references to slices. This method performs no bounds or overlap checks and requires `unsafe`.

```rust
let x = &mut [1, 2, 4];

unsafe {
    let [a, b] = x.get_disjoint_unchecked_mut([0..1, 1..3]);
    a[0] = 8;
    b[0] = 88;
    b[1] = 888;
}
assert_eq!(x, &[8, 88, 888]);
```

--------------------------------

### Spanned Implementation for SeqExpr

Source: https://rustdoc.swc.rs/swc_core/ecma/visit/swc_ecma_ast/struct.SeqExpr.html

Provides methods to get the span information (start and end positions) of a SeqExpr.

```APIDOC
### impl Spanned for SeqExpr

#### fn span(&self) -> Span
Get span of `self`.

#### fn span_lo(&self) -> BytePos

#### fn span_hi(&self) -> BytePos
```

--------------------------------

### Initialize Compiler with Config

Source: https://rustdoc.swc.rs/src/swc_ecma_compiler/lib.rs.html

Creates a new Compiler instance with the provided configuration.

```rust
pub fn new(config: Config) -> Self {
        Self { config }
    }
```

--------------------------------

### Initialize FileSystemCache

Source: https://rustdoc.swc.rs/src/swc_plugin_runner/cache.rs.html

Creates a new FileSystemCache instance, setting up the cache directory based on OS, architecture, and package version.

```rust
let mut path = root_path?;
path.push("plugins");
path.push(format!(
    "{}_{}_{}",
    std::env::consts::OS,
    std::env::consts::ARCH,
    option_env!("CARGO_PKG_VERSION").unwrap_or("plugin_runner_unknown")
));

std::fs::create_dir_all(&path).ok()?;
Some(FileSystemCache { path })
```

--------------------------------

### ClassMember Spanning Information

Source: https://rustdoc.swc.rs/swc_core/ecma/visit/swc_ecma_ast/enum.ClassMember.html

Provides methods to get the span information (start and end positions) of a ClassMember.

```APIDOC
## fn span(&self) -> Span

### Description
Get the span of `self`.

### Returns
The `Span` of the ClassMember.
```

```APIDOC
## fn span_lo(&self) -> BytePos

### Description
Get the starting byte position of the ClassMember's span.

### Returns
The starting `BytePos`.
```

```APIDOC
## fn span_hi(&self) -> BytePos

### Description
Get the ending byte position of the ClassMember's span.

### Returns
The ending `BytePos`.
```

--------------------------------

### Spanned Implementation for VarDeclarator

Source: https://rustdoc.swc.rs/swc_core/ecma/utils/swc_ecma_ast/struct.VarDeclarator.html

Provides methods to get the span information (start and end positions) of a VarDeclarator.

```APIDOC
### impl Spanned for VarDeclarator

#### fn span(&self) -> Span
Get span of `self`.

#### fn span_lo(&self) -> BytePos

#### fn span_hi(&self) -> BytePos

```

--------------------------------

### Box::try_new Example (Nightly)

Source: https://rustdoc.swc.rs/swc_core/ecma/transforms/testing/babel_like/type.PassFactory.html

Demonstrates attempting to allocate a `Box` on the heap, returning an error if the allocation fails. This is an experimental API.

```rust
#![feature(allocator_api)]

let five = Box::try_new(5)?;
```

--------------------------------

### Create New Plugin Project

Source: https://rustdoc.swc.rs/src/swc_cli_impl/commands/plugin.rs.html

Use the `new` subcommand to generate a new plugin project with basic scaffolding. This command requires `PluginScaffoldOptions` to configure the new project.

```rust
/// Set of subcommands for the plugin subcommand.
#[derive(Subcommand)]
pub enum PluginSubcommand {
    /// Create a new plugin project with minimal scaffolding template.
    New(PluginScaffoldOptions),
}
```

--------------------------------

### Spanned Implementation for AwaitExpr

Source: https://rustdoc.swc.rs/swc_core/ecma/utils/swc_ecma_ast/struct.AwaitExpr.html

Provides methods to get the span information (start and end positions) of an AwaitExpr.

```APIDOC
### impl Spanned for AwaitExpr

#### fn span(&self) -> Span
Get span of `self`.

#### fn span_lo(&self) -> BytePos

#### fn span_hi(&self) -> BytePos
```

--------------------------------

### Initialize UsageVisitor

Source: https://rustdoc.swc.rs/src/swc_ecma_preset_env/corejs2/mod.rs.html

Creates a new UsageVisitor with the specified target versions. It initializes the visitor's state, including whether any target is specified and the required features set.

```rust
pub fn new(target: Arc<Versions>) -> Self {
    //        let mut v = Self { required: Vec::new() };
    //
    //
    //        let is_web_target = target
    //            .iter()
    //            .any(|(name, version)| name != "node" &&
    // version.is_some());
    //
    //        println!(
    //            "is_any_target={:?}\nis_web_target={:?}",
    //            is_any_target, is_web_target
    //        );
    //
    //        // Web default
    //        if is_any_target || is_web_target {
    //            v.add(&["web.timers", "web.immediate",
    // "web.dom.iterable"]);        }
    //        v
    //
    //        //if target.is_any_target() || target.node.is_none() {
    //        //    v.add(&["web.timers", "web.immediate", "web.dom.iterable"]);
    //        //}
    //
    //        Self {
    //            is_any_target: target.is_any_target(),
    //            target,
    //            required: Default::default(),
    //        }
    //    }

    Self {
        is_any_target: target.is_any_target(),
        target,
        required: Default::default(),
    }
}
```

--------------------------------

### Spanned Implementation for TsQualifiedName

Source: https://rustdoc.swc.rs/swc_core/ecma/ast/struct.TsQualifiedName.html

Provides methods to get the span information (start and end positions) of a TsQualifiedName.

```APIDOC
### impl Spanned for TsQualifiedName

#### fn span(&self) -> Span
Get span of `self`.

#### fn span_lo(&self) -> BytePos

#### fn span_hi(&self) -> BytePos
```

--------------------------------

### Spanned Implementation for TsEnumDecl

Source: https://rustdoc.swc.rs/swc_core/ecma/ast/struct.TsEnumDecl.html

Provides methods to get the span information (start and end positions) of a TsEnumDecl.

```APIDOC
### impl Spanned for TsEnumDecl

#### fn span(&self) -> Span
Get span of `self`.

#### fn span_lo(&self) -> BytePos

#### fn span_hi(&self) -> BytePos
```

--------------------------------

### SourceFile::new

Source: https://rustdoc.swc.rs/swc_core/common/source_map/struct.SourceFile.html

Constructs a new SourceFile instance.

```APIDOC
## fn new( name: Arc<FileName>, name_was_remapped: bool, unmapped_path: Arc<FileName>, src: BytesStr, start_pos: BytePos, ) -> SourceFile

### Description
Constructs a new `SourceFile` instance.

`src` should not have UTF8 BOM

### Parameters
- **name** (Arc<FileName>) - The name of the file.
- **name_was_remapped** (bool) - Whether the name was remapped.
- **unmapped_path** (Arc<FileName>) - The original, unmapped path of the file.
- **src** (BytesStr) - The source code content.
- **start_pos** (BytePos) - The starting position of the source in the `SourceMap`.

### Returns
A new `SourceFile` instance.
```

--------------------------------

### Dummy Method for MediaQuery

Source: https://rustdoc.swc.rs/swc_core/common/util/take/trait.Take.html

Example of a `dummy` method implementation for `MediaQuery`.

```rust
fn dummy() -> MediaQuery
```

--------------------------------

### Spanned Implementation for ForStmt

Source: https://rustdoc.swc.rs/swc_core/ecma/ast/struct.ForStmt.html

Provides methods to get the span information (start and end positions) of a ForStmt.

```APIDOC
### impl Spanned for ForStmt

#### fn span(&self) -> Span
Get span of `self`.

#### fn span_lo(&self) -> BytePos

#### fn span_hi(&self) -> BytePos

```

--------------------------------

### Initialize CSS Compressor

Source: https://rustdoc.swc.rs/src/swc_css_minifier/compressor/mod.rs.html

Returns a new instance of the CSS compressor. This is the entry point for applying compression to a CSS AST.

```rust
pub fn compressor() -> impl VisitMut {
    Compressor::default()
}
```

--------------------------------

### ExportDecl - Spanned Trait

Source: https://rustdoc.swc.rs/swc_core/ecma/ast/struct.ExportDecl.html

Provides methods to get the span information (start and end positions) of an ExportDecl.

```APIDOC
### impl Spanned for ExportDecl

#### fn span(&self) -> Span
Get span of `self`.

#### fn span_lo(&self) -> BytePos

#### fn span_hi(&self) -> BytePos
```

--------------------------------

### Get the beginning of a line

Source: https://rustdoc.swc.rs/swc_common/source_map/struct.SourceFile.html

Calculates and returns the BytePos corresponding to the start of the line containing the given position.

```rust
pub fn line_begin_pos(&self, pos: BytePos) -> BytePos

```

--------------------------------

### run()

Source: https://rustdoc.swc.rs/swc_cli_impl/fn.run.html

The `run` function is the primary function to execute the SWC build process. It takes no arguments and returns a `Result<()>`, indicating success or failure.

```APIDOC
## run()

### Description

This function serves as the main entry point for the SWC command-line interface. It orchestrates the build process based on the configured settings.

### Signature

```rust
pub fn run() -> Result<()>
```

### Returns

- `Result<()>`: Returns `Ok(())` on successful completion of the build process, or an `Err` containing details about any errors encountered during execution.
```

--------------------------------

### JavaScript ES2015 Method Shorthand Example

Source: https://rustdoc.swc.rs/src/swc_ecma_compat_es2015/shorthand_property.rs.html

Demonstrates the input syntax for ES2015 method shorthand properties.

```javascript
var cat = {
  getName() {
    return name;
  }
};
```

--------------------------------

### Safe Get Disjoint Mut Example (usize)

Source: https://rustdoc.swc.rs/swc_common/pass/struct.AstKindPath.html

Demonstrates using `get_disjoint_mut` with an array of `usize` indices to safely get mutable references to individual elements. This method checks for bounds and overlaps, returning a `Result`.

```rust
let v = &mut [1, 2, 3];
if let Ok([a, b]) = v.get_disjoint_mut([0, 2]) {
    *a = 413;
    *b = 612;
}
assert_eq!(v, &[413, 2, 612]);
```

--------------------------------

### Initialize Compiler

Source: https://rustdoc.swc.rs/swc_core/base/struct.Compiler.html

Creates a new Compiler instance with the provided SourceMap.

```rust
pub fn new(cm: Arc<SourceMap>) -> Compiler
```

--------------------------------

### Spanned Trait Implementation for TsImportCallOptions

Source: https://rustdoc.swc.rs/swc_ecma_ast/struct.TsImportCallOptions.html

Provides methods to get the span information (start and end positions) of TsImportCallOptions.

```rust
impl Spanned for TsImportCallOptions {
    fn span(&self) -> Span {
        // ... implementation details ...
    }

    fn span_lo(&self) -> BytePos {
        // ... implementation details ...
    }

    fn span_hi(&self) -> BytePos {
        // ... implementation details ...
    }
}
```

--------------------------------

### Spanned Trait Implementation for CallExpr

Source: https://rustdoc.swc.rs/swc_ecma_ast/struct.CallExpr.html

Provides methods to get the span information (start, end, and position) of a CallExpr.

```rust
impl Spanned for CallExpr
Source
#### fn span(&self) -> Span
Get span of `self`.
Source
#### fn span_lo(&self) -> BytePos
Source
#### fn span_hi(&self) -> BytePos
Source
```

--------------------------------

### New Expression Example

Source: https://rustdoc.swc.rs/swc_core/ecma/utils/swc_ecma_ast/enum.Expr.html

Demonstrates the syntax for creating a new object instance using the `new` keyword.

```rust
`new Cat()`
```

--------------------------------

### JavaScript Example for Import Meta URL

Source: https://rustdoc.swc.rs/src/swc_ecma_transforms_module/common_js.rs.html

Demonstrates the runtime behavior of accessing `import.meta.url` in a CommonJS environment.

```javascript
require('url').pathToFileURL(__filename).toString()
```

--------------------------------

### Get Stream Position of Arc<File>

Source: https://rustdoc.swc.rs/swc_core/ecma/utils/swc_common/sync/struct.Lrc.html

Returns the current seek position from the start of the stream for an Arc<File>.

```rust
use std::fs::File;
use std::io::{Seek, Error};
use std::sync::Arc;

// Assuming 'file' is an Arc<File>
// let mut file: Arc<File> = ...;
// let position: Result<u64, Error> = file.stream_position();
```

--------------------------------

### Init

Source: https://rustdoc.swc.rs/swc/config/struct.JsMinifyOptions.html

The type for initializers.

```APIDOC
#### type Init = T

### Description
The type for initializers.
```

--------------------------------

### Spanned Implementation for TsTplLitType

Source: https://rustdoc.swc.rs/swc_core/ecma/ast/struct.TsTplLitType.html

Provides methods to get the span information (start and end positions) of a TsTplLitType node.

```APIDOC
### impl Spanned for TsTplLitType

#### fn span(&self) -> Span
Get span of `self`.

#### fn span_lo(&self) -> BytePos

#### fn span_hi(&self) -> BytePos
```

--------------------------------

### Spanned Implementation for EmptyStmt

Source: https://rustdoc.swc.rs/swc_core/ecma/ast/struct.EmptyStmt.html

Provides methods to get the span information (start and end positions) of an EmptyStmt node.

```APIDOC
### impl Spanned for EmptyStmt

#### fn span(&self) -> Span
Get span of `self`.

#### fn span_lo(&self) -> BytePos

#### fn span_hi(&self) -> BytePos
```

--------------------------------

### Create New Parser Instance

Source: https://rustdoc.swc.rs/swc_core/css/parser/parser/struct.Parser.html

Initializes a new `Parser` instance with the provided input and configuration. This is the entry point for parsing CSS.

```rust
pub fn new(input: I, config: ParserConfig) -> Parser<I>

```

--------------------------------

### Get the beginning BytePos of a line

Source: https://rustdoc.swc.rs/swc_core/common/source_map/struct.SourceFile.html

Calculates and returns the BytePos corresponding to the start of the current line for a given position.

```rust
pub fn line_begin_pos(&self, pos: BytePos) -> BytePos
```

--------------------------------

### Initialize Plugin Instance Method

Source: https://rustdoc.swc.rs/swc_plugin_runner/runtime/trait.Runtime.html

Initializes a plugin instance with its name, environment variables, and imports. Runtimes should call `__get_transform_plugin_core_pkg_diag` after instantiation to verify completion.

```rust
fn init(
        &self,
        name: &str,
        imports: Vec<(String, Func)>,
        envs: Vec<(String, String)>,
        module: Module,
    ) -> Result<Box<dyn Instance>>
```

--------------------------------

### Compiler::new

Source: https://rustdoc.swc.rs/swc_core/css/compat/compiler/struct.Compiler.html

Constructs a new Compiler instance with the provided configuration.

```APIDOC
## Compiler::new

### Description
Constructs a new `Compiler` instance with the provided configuration.

### Signature
```rust
pub fn new(config: Config) -> Compiler
```

### Parameters
* `config` (Config) - The configuration object for the compiler.
```

--------------------------------

### Unsafe Get Disjoint Unchecked Mut Example (usize)

Source: https://rustdoc.swc.rs/swc_common/pass/struct.AstKindPath.html

Demonstrates using `get_disjoint_unchecked_mut` with an array of `usize` indices to get mutable references to individual elements. This method performs no bounds or overlap checks and requires `unsafe`.

```rust
let x = &mut [1, 2, 4];

unsafe {
    let [a, b] = x.get_disjoint_unchecked_mut([0, 2]);
    *a *= 10;
    *b *= 100;
}
assert_eq!(x, &[10, 2, 400]);
```

--------------------------------

### bundle

Source: https://rustdoc.swc.rs/src/dbg_swc/bundle.rs.html

Bundles a JavaScript entry point using `deno bundle`. This function takes a SourceMap and an entry URL, spawns a `deno bundle` process, captures its output, parses it as JavaScript, and returns a ModuleRecord.

```APIDOC
## bundle

### Description
Bundles a JavaScript entry point using `deno bundle`. This function takes a SourceMap and an entry URL, spawns a `deno bundle` process, captures its output, parses it as JavaScript, and returns a ModuleRecord.

### Function Signature
`pub fn bundle(cm: Arc<SourceMap>, entry_url: &str) -> Result<ModuleRecord>`

### Parameters
- **cm** (Arc<SourceMap>) - The SourceMap for creating new source files.
- **entry_url** (&str) - The URL of the entry point file to bundle.

### Returns
- Result<ModuleRecord> - A Result containing the ModuleRecord if successful, or an error if the bundling process fails.
```

--------------------------------

### Get Span of Token Sequence

Source: https://rustdoc.swc.rs/swc_ecma_lexer/struct.Parser.html

Calculates the `Span` covering the tokens from a given `start` byte position to the current position.

```rust
fn span(&self, start: BytePos) -> Span
```

--------------------------------

### SpanExt Implementation

Source: https://rustdoc.swc.rs/swc_ecma_ast/struct.TsTypeQuery.html

Extends Span with methods for checking if a span is synthesized or starts on a new line, and for getting comment ranges.

```APIDOC
## is_synthesized

### Description
Checks if the span is synthesized.

### Signature
`fn is_synthesized(&self) -> bool`

## starts_on_new_line

### Description
Checks if the span starts on a new line, considering list formatting.

### Signature
`fn starts_on_new_line(&self, format: ListFormat) -> bool`

## comment_range

### Description
Gets a custom text range to use when emitting comments.

### Signature
`fn comment_range(&self) -> Span`
```

--------------------------------

### build_as_input

Source: https://rustdoc.swc.rs/swc/config/struct.Options.html

Builds an input program with specified configurations and passes.

```APIDOC
## build_as_input

### Description
Constructs a `BuiltInput` which represents a program ready for compilation, incorporating provided configurations, parsing logic, and custom transformation passes.

### Method
`build_as_input<'a, P>(
    cm: &Arc<SourceMap>,
    base: &FileName,
    parse: impl FnOnce(Syntax, EsVersion, IsModule) -> Result<Program, Error>,
    output_path: Option<&Path>,
    source_root: Option<String>,
    source_file_name: Option<String>,
    source_map_ignore_list: Option<FilePattern>,
    handler: &Handler,
    config: Option<Config>,
    comments: Option<&'a SingleThreadedComments>,
    custom_before_pass: impl FnOnce(&Program) -> P,
) -> Result<BuiltInput<Box<dyn Pass + 'a>>, Error>

### Parameters

- `cm`: `&Arc<SourceMap>` - The source map manager.
- `base`: `&FileName` - The base file name.
- `parse`: `impl FnOnce(Syntax, EsVersion, IsModule) -> Result<Program, Error>` - A closure to parse the program.
- `output_path`: `Option<&Path>` - Optional output path.
- `source_root`: `Option<String>` - Optional source root directory.
- `source_file_name`: `Option<String>` - Optional source file name.
- `source_map_ignore_list`: `Option<FilePattern>` - Optional file pattern for ignoring source maps.
- `handler`: `&Handler` - The error handler.
- `config`: `Option<Config>` - Optional configuration.
- `comments`: `Option<&'a SingleThreadedComments>` - Optional comments.
- `custom_before_pass`: `impl FnOnce(&Program) -> P` - A closure to apply a custom pass before other transformations.

### Type Parameters

- `'a`: Lifetime parameter.
- `P`: Type parameter for the custom pass, must implement `Pass` and have the lifetime `'a`.

### Returns
- `Result<BuiltInput<Box<dyn Pass + 'a>>, Error>` - A `BuiltInput` ready for compilation, or an `Error` if the process fails.
```

--------------------------------

### Implement Clone for TutorialTag

Source: https://rustdoc.swc.rs/jsdoc/ast/struct.TutorialTag.html

Provides functionality to create a copy of a TutorialTag instance. This is useful for scenarios where you need to duplicate tag information.

```rust
impl Clone for TutorialTag
fn clone(&self) -> TutorialTag
```

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

--------------------------------

### impl<T> SpanExt for T

Source: https://rustdoc.swc.rs/swc_core/ecma/ast/enum.Callee.html

Provides extended functionality for types that have a span, such as checking if they start on a new line or getting their comment range.

```APIDOC
## impl<T> SpanExt for T

### Description
Provides extended functionality for types that have a span, such as checking if they start on a new line or getting their comment range.

### Methods

#### `is_synthesized(&self) -> bool`

- **Description**: Checks if the span is synthesized.

#### `starts_on_new_line(&self, format: ListFormat) -> bool`

- **Description**: Checks if the span starts on a new line according to the specified list format.

#### `comment_range(&self) -> Span`

- **Description**: Gets a custom text range to use when emitting comments.
```

--------------------------------

### Lexer Initialization with Syntax and Input

Source: https://rustdoc.swc.rs/src/swc_ecma_parser/lexer/mod.rs.html

Constructs a new Lexer instance with specified syntax, ECMAScript version, input source, and optional comments.

```rust
pub fn new(
        syntax: Syntax,
        target: EsVersion,
        input: StringInput<'a>,
        comments: Option<&'a dyn Comments>,
    ) -> Self {
        let start_pos = input.last_pos();

        Lexer {
            comments,
            comments_buffer: comments.is_some().then(CommentsBuffer::new),
            ctx: Default::default(),
            input,
            start_pos,
            state: State::new(start_pos),
            syntax: syntax.into_flags(),
            target,
            errors: Default::default(),
            module_errors: Default::default(),
            atoms: Default::default(),
            token_flags: TokenFlags::empty(),
        }
    }
```

--------------------------------

### Get the byte bounds of a specific line

Source: https://rustdoc.swc.rs/swc_core/common/source_map/struct.SourceFile.html

Returns a tuple containing the start and end BytePos for a given line index.

```rust
pub fn line_bounds(&self, line_index: usize) -> (BytePos, BytePos)
```

--------------------------------

### Take Implementation for Module

Source: https://rustdoc.swc.rs/swc_ecma_ast/struct.Module.html

Provides methods for taking ownership or creating dummy instances of a Module.

```rust
impl Take for Module
Source§
#### fn dummy() -> Self
Create a dummy value of this type.
Source§
#### fn take(&mut self) -> Self
Source§
#### fn map_with_mut<F>(&mut self, op: F)
where F: FnOnce(Self) -> Self,
Mutate `self` using `op`, which accepts owned data.
Source
```

--------------------------------

### Iterating Over a Slice

Source: https://rustdoc.swc.rs/swc_common/pass/struct.AstKindPathGuard.html

Use `iter()` to get an immutable iterator over the elements of a slice. The iterator yields elements from start to end.

```rust
let x = &[1, 2, 4];
let mut iterator = x.iter();

assert_eq!(iterator.next(), Some(&1));
assert_eq!(iterator.next(), Some(&2));
assert_eq!(iterator.next(), Some(&4));
assert_eq!(iterator.next(), None);
```

--------------------------------

### Visit Media And

Source: https://rustdoc.swc.rs/swc_css_visit/trait.Visit.html

Visitor method for a `MediaAnd` node.

```rust
fn visit_media_and(&mut self, node: &MediaAnd) { ... }
```

--------------------------------

### Get Span Between Positions

Source: https://rustdoc.swc.rs/src/swc_ecma_parser/parser/mod.rs.html

Creates a Span object representing the range between a starting byte position and the current end position.

```rust
pub fn span(&self, start: BytePos) -> Span {
    let end = self.last_pos();
    debug_assert!(
        start <= end,
        "assertion failed: (span.start <= span.end). start = {start:?}, end = {end:?}",
    );
    Span::new_with_checked(start, end)
}
```

--------------------------------

### Create an empty SyntaxFlags value

Source: https://rustdoc.swc.rs/swc_ecma_lexer/common/syntax/struct.SyntaxFlags.html

Get a `SyntaxFlags` value with all configuration bits unset. This is useful for starting with a default, minimal configuration.

```rust
pub const fn empty() -> SyntaxFlags
```

--------------------------------

### JavaScript Exponentiation Example (In)

Source: https://rustdoc.swc.rs/src/swc_ecma_compat_es2016/exponentiation.rs.html

Demonstrates the input syntax for the exponentiation operator `**` and the compound assignment `**=`.

```JavaScript
let x = 10 ** 2;

x **= 3;
```

--------------------------------

### IndexMap Example: Insertion and Access

Source: https://rustdoc.swc.rs/swc/config/type.Paths.html

Demonstrates basic insertion into an IndexMap and accessing elements. Note that direct index access with assignment can panic if the index is out of bounds.

```rust
let mut map = IndexMap::new();
map.insert("foo", 1);
map[10] = 1; // panics!
```
Tokens:
Raw