swc_ecma_minifier 48.0.0

EcmaScript code minifier.
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

use std::{borrow::Cow, sync::Arc};

use rustc_hash::FxHashSet;
use swc_atoms::Atom;
use swc_common::Mark;
use swc_ecma_ast::*;
use swc_ecma_transforms_base::rename::{renamer, RenameMap, Renamer};
use swc_ecma_visit::VisitMutWith;

pub(crate) use self::preserver::idents_to_preserve;
use crate::{
    option::{MangleCache, MangleOptions},
    util::base54::Base54Chars,
};

mod mangler;
mod preserver;

pub(crate) fn mangle_names(
    program: &mut Program,
    options: &MangleOptions,
    preserved: FxHashSet<Id>,
    chars: Base54Chars,
    top_level_mark: Mark,
    mangle_name_cache: Option<Arc<dyn MangleCache>>,
) {
    // Use hook-based mangler for combined label and private name mangling
    // in a single AST traversal
    self::mangler::visit_with_mangler(program, options.keep_private_props, chars);

    let mut cache = None;

    if let Some(mangle_cache) = &mangle_name_cache {
        let mut c = RenameMap::default();
        mangle_cache.vars_cache(&mut |v| c.extend(v.iter().map(|(k, v)| (k.clone(), v.clone()))));
        cache = Some(c);
    }

    program.visit_mut_with(&mut renamer(
        swc_ecma_transforms_base::hygiene::Config {
            keep_class_names: options.keep_class_names,
            top_level_mark,
            ignore_eval: options.eval,
        },
        ManglingRenamer {
            chars,
            preserved: &preserved,
            cache,
            mangle_name_cache,
            reserved: &options.reserved,
        },
    ));
}

struct ManglingRenamer<'a> {
    chars: Base54Chars,
    preserved: &'a FxHashSet<Id>,
    cache: Option<RenameMap>,
    mangle_name_cache: Option<Arc<dyn MangleCache>>,
    reserved: &'a Vec<Atom>,
}

impl<'a> Renamer for ManglingRenamer<'a> {
    type Target = Atom;

    const MANGLE: bool = true;
    const RESET_N: bool = false;

    fn new_name_for(&self, _: &Id, n: &mut usize) -> Atom {
        self.chars.encode(n, true)
    }

    fn get_cached(&self) -> Option<Cow<RenameMap>> {
        self.cache.as_ref().map(Cow::Borrowed)
    }

    fn store_cache(&mut self, update: &RenameMap) {
        if let Some(cacher) = &self.mangle_name_cache {
            cacher.update_vars_cache(update);
        }
    }

    fn unresolved_symbols(&self) -> Vec<Atom> {
        self.reserved
            .iter()
            .cloned()
            .chain(self.preserved.iter().map(|id| id.0.clone()))
            .collect()
    }

    fn preserve_name(&self, orig: &Id) -> bool {
        self.preserved.contains(orig)
    }
}