From 2cdf0cb352ab6a2d0f8cb25120e4ebc92c5316e3 Mon Sep 17 00:00:00 2001 From: littleblack111 Date: Sun, 5 Nov 2023 17:23:37 +0800 Subject: removed autoprefix hover as it will have a high chance of making hover stopped working --- node_modules/terser/lib/scope.js | 1066 -------------------------------------- 1 file changed, 1066 deletions(-) delete mode 100644 node_modules/terser/lib/scope.js (limited to 'node_modules/terser/lib/scope.js') diff --git a/node_modules/terser/lib/scope.js b/node_modules/terser/lib/scope.js deleted file mode 100644 index f8a22a52..00000000 --- a/node_modules/terser/lib/scope.js +++ /dev/null @@ -1,1066 +0,0 @@ -/*********************************************************************** - - A JavaScript tokenizer / parser / beautifier / compressor. - https://github.com/mishoo/UglifyJS2 - - -------------------------------- (C) --------------------------------- - - Author: Mihai Bazon - - http://mihai.bazon.net/blog - - Distributed under the BSD license: - - Copyright 2012 (c) Mihai Bazon - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions - are met: - - * Redistributions of source code must retain the above - copyright notice, this list of conditions and the following - disclaimer. - - * Redistributions in binary form must reproduce the above - copyright notice, this list of conditions and the following - disclaimer in the documentation and/or other materials - provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER “AS IS” AND ANY - EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR - PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE - LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, - OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, - PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR - PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR - TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF - THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF - SUCH DAMAGE. - - ***********************************************************************/ - -"use strict"; - -import { - defaults, - keep_name, - mergeSort, - push_uniq, - make_node, - return_false, - return_this, - return_true, - string_template, -} from "./utils/index.js"; -import { - AST_Arrow, - AST_Block, - AST_Call, - AST_Class, - AST_Conditional, - AST_DefClass, - AST_Defun, - AST_Destructuring, - AST_Dot, - AST_DotHash, - AST_Export, - AST_For, - AST_ForIn, - AST_ForOf, - AST_Function, - AST_Import, - AST_IterationStatement, - AST_Label, - AST_LabeledStatement, - AST_LabelRef, - AST_Lambda, - AST_LoopControl, - AST_NameMapping, - AST_Node, - AST_Scope, - AST_Sequence, - AST_String, - AST_Sub, - AST_Switch, - AST_SwitchBranch, - AST_Symbol, - AST_SymbolBlockDeclaration, - AST_SymbolCatch, - AST_SymbolClass, - AST_SymbolConst, - AST_SymbolDefClass, - AST_SymbolDefun, - AST_SymbolExport, - AST_SymbolFunarg, - AST_SymbolImport, - AST_SymbolLambda, - AST_SymbolLet, - AST_SymbolMethod, - AST_SymbolRef, - AST_SymbolVar, - AST_Toplevel, - AST_VarDef, - AST_With, - TreeWalker, - walk, - walk_abort -} from "./ast.js"; -import { - ALL_RESERVED_WORDS, - js_error, -} from "./parse.js"; - -const MASK_EXPORT_DONT_MANGLE = 1 << 0; -const MASK_EXPORT_WANT_MANGLE = 1 << 1; - -let function_defs = null; -let unmangleable_names = null; -/** - * When defined, there is a function declaration somewhere that's inside of a block. - * See https://tc39.es/ecma262/multipage/additional-ecmascript-features-for-web-browsers.html#sec-block-level-function-declarations-web-legacy-compatibility-semantics -*/ -let scopes_with_block_defuns = null; - -class SymbolDef { - constructor(scope, orig, init) { - this.name = orig.name; - this.orig = [ orig ]; - this.init = init; - this.eliminated = 0; - this.assignments = 0; - this.scope = scope; - this.replaced = 0; - this.global = false; - this.export = 0; - this.mangled_name = null; - this.undeclared = false; - this.id = SymbolDef.next_id++; - this.chained = false; - this.direct_access = false; - this.escaped = 0; - this.recursive_refs = 0; - this.references = []; - this.should_replace = undefined; - this.single_use = false; - this.fixed = false; - Object.seal(this); - } - fixed_value() { - if (!this.fixed || this.fixed instanceof AST_Node) return this.fixed; - return this.fixed(); - } - unmangleable(options) { - if (!options) options = {}; - - if ( - function_defs && - function_defs.has(this.id) && - keep_name(options.keep_fnames, this.orig[0].name) - ) return true; - - return this.global && !options.toplevel - || (this.export & MASK_EXPORT_DONT_MANGLE) - || this.undeclared - || !options.eval && this.scope.pinned() - || (this.orig[0] instanceof AST_SymbolLambda - || this.orig[0] instanceof AST_SymbolDefun) && keep_name(options.keep_fnames, this.orig[0].name) - || this.orig[0] instanceof AST_SymbolMethod - || (this.orig[0] instanceof AST_SymbolClass - || this.orig[0] instanceof AST_SymbolDefClass) && keep_name(options.keep_classnames, this.orig[0].name); - } - mangle(options) { - const cache = options.cache && options.cache.props; - if (this.global && cache && cache.has(this.name)) { - this.mangled_name = cache.get(this.name); - } else if (!this.mangled_name && !this.unmangleable(options)) { - var s = this.scope; - var sym = this.orig[0]; - if (options.ie8 && sym instanceof AST_SymbolLambda) - s = s.parent_scope; - const redefinition = redefined_catch_def(this); - this.mangled_name = redefinition - ? redefinition.mangled_name || redefinition.name - : s.next_mangled(options, this); - if (this.global && cache) { - cache.set(this.name, this.mangled_name); - } - } - } -} - -SymbolDef.next_id = 1; - -function redefined_catch_def(def) { - if (def.orig[0] instanceof AST_SymbolCatch - && def.scope.is_block_scope() - ) { - return def.scope.get_defun_scope().variables.get(def.name); - } -} - -AST_Scope.DEFMETHOD("figure_out_scope", function(options, { parent_scope = null, toplevel = this } = {}) { - options = defaults(options, { - cache: null, - ie8: false, - safari10: false, - module: false, - }); - - if (!(toplevel instanceof AST_Toplevel)) { - throw new Error("Invalid toplevel scope"); - } - - // pass 1: setup scope chaining and handle definitions - var scope = this.parent_scope = parent_scope; - var labels = new Map(); - var defun = null; - var in_destructuring = null; - var for_scopes = []; - var tw = new TreeWalker((node, descend) => { - if (node.is_block_scope()) { - const save_scope = scope; - node.block_scope = scope = new AST_Scope(node); - scope._block_scope = true; - scope.init_scope_vars(save_scope); - scope.uses_with = save_scope.uses_with; - scope.uses_eval = save_scope.uses_eval; - - if (options.safari10) { - if (node instanceof AST_For || node instanceof AST_ForIn || node instanceof AST_ForOf) { - for_scopes.push(scope); - } - } - - if (node instanceof AST_Switch) { - // XXX: HACK! Ensure the switch expression gets the correct scope (the parent scope) and the body gets the contained scope - // AST_Switch has a scope within the body, but it itself "is a block scope" - // This means the switched expression has to belong to the outer scope - // while the body inside belongs to the switch itself. - // This is pretty nasty and warrants an AST change - const the_block_scope = scope; - scope = save_scope; - node.expression.walk(tw); - scope = the_block_scope; - for (let i = 0; i < node.body.length; i++) { - node.body[i].walk(tw); - } - } else { - descend(); - } - scope = save_scope; - return true; - } - if (node instanceof AST_Destructuring) { - const save_destructuring = in_destructuring; - in_destructuring = node; - descend(); - in_destructuring = save_destructuring; - return true; - } - if (node instanceof AST_Scope) { - node.init_scope_vars(scope); - var save_scope = scope; - var save_defun = defun; - var save_labels = labels; - defun = scope = node; - labels = new Map(); - descend(); - scope = save_scope; - defun = save_defun; - labels = save_labels; - return true; // don't descend again in TreeWalker - } - if (node instanceof AST_LabeledStatement) { - var l = node.label; - if (labels.has(l.name)) { - throw new Error(string_template("Label {name} defined twice", l)); - } - labels.set(l.name, l); - descend(); - labels.delete(l.name); - return true; // no descend again - } - if (node instanceof AST_With) { - for (var s = scope; s; s = s.parent_scope) - s.uses_with = true; - return; - } - if (node instanceof AST_Symbol) { - node.scope = scope; - } - if (node instanceof AST_Label) { - node.thedef = node; - node.references = []; - } - if (node instanceof AST_SymbolLambda) { - defun.def_function(node, node.name == "arguments" ? undefined : defun); - } else if (node instanceof AST_SymbolDefun) { - // Careful here, the scope where this should be defined is - // the parent scope. The reason is that we enter a new - // scope when we encounter the AST_Defun node (which is - // instanceof AST_Scope) but we get to the symbol a bit - // later. - const closest_scope = defun.parent_scope; - - // In strict mode, function definitions are block-scoped - node.scope = tw.directives["use strict"] - ? closest_scope - : closest_scope.get_defun_scope(); - - mark_export(node.scope.def_function(node, defun), 1); - } else if (node instanceof AST_SymbolClass) { - mark_export(defun.def_variable(node, defun), 1); - } else if (node instanceof AST_SymbolImport) { - scope.def_variable(node); - } else if (node instanceof AST_SymbolDefClass) { - // This deals with the name of the class being available - // inside the class. - mark_export((node.scope = defun.parent_scope).def_function(node, defun), 1); - } else if ( - node instanceof AST_SymbolVar - || node instanceof AST_SymbolLet - || node instanceof AST_SymbolConst - || node instanceof AST_SymbolCatch - ) { - var def; - if (node instanceof AST_SymbolBlockDeclaration) { - def = scope.def_variable(node, null); - } else { - def = defun.def_variable(node, node.TYPE == "SymbolVar" ? null : undefined); - } - if (!def.orig.every((sym) => { - if (sym === node) return true; - if (node instanceof AST_SymbolBlockDeclaration) { - return sym instanceof AST_SymbolLambda; - } - return !(sym instanceof AST_SymbolLet || sym instanceof AST_SymbolConst); - })) { - js_error( - `"${node.name}" is redeclared`, - node.start.file, - node.start.line, - node.start.col, - node.start.pos - ); - } - if (!(node instanceof AST_SymbolFunarg)) mark_export(def, 2); - if (defun !== scope) { - node.mark_enclosed(); - var def = scope.find_variable(node); - if (node.thedef !== def) { - node.thedef = def; - node.reference(); - } - } - } else if (node instanceof AST_LabelRef) { - var sym = labels.get(node.name); - if (!sym) throw new Error(string_template("Undefined label {name} [{line},{col}]", { - name: node.name, - line: node.start.line, - col: node.start.col - })); - node.thedef = sym; - } - if (!(scope instanceof AST_Toplevel) && (node instanceof AST_Export || node instanceof AST_Import)) { - js_error( - `"${node.TYPE}" statement may only appear at the top level`, - node.start.file, - node.start.line, - node.start.col, - node.start.pos - ); - } - }); - - if (options.module) { - tw.directives["use strict"] = true; - } - - this.walk(tw); - - function mark_export(def, level) { - if (in_destructuring) { - var i = 0; - do { - level++; - } while (tw.parent(i++) !== in_destructuring); - } - var node = tw.parent(level); - if (def.export = node instanceof AST_Export ? MASK_EXPORT_DONT_MANGLE : 0) { - var exported = node.exported_definition; - if ((exported instanceof AST_Defun || exported instanceof AST_DefClass) && node.is_default) { - def.export = MASK_EXPORT_WANT_MANGLE; - } - } - } - - // pass 2: find back references and eval - const is_toplevel = this instanceof AST_Toplevel; - if (is_toplevel) { - this.globals = new Map(); - } - - var tw = new TreeWalker(node => { - if (node instanceof AST_LoopControl && node.label) { - node.label.thedef.references.push(node); - return true; - } - if (node instanceof AST_SymbolRef) { - var name = node.name; - if (name == "eval" && tw.parent() instanceof AST_Call) { - for (var s = node.scope; s && !s.uses_eval; s = s.parent_scope) { - s.uses_eval = true; - } - } - var sym; - if (tw.parent() instanceof AST_NameMapping && tw.parent(1).module_name - || !(sym = node.scope.find_variable(name))) { - - sym = toplevel.def_global(node); - if (node instanceof AST_SymbolExport) sym.export = MASK_EXPORT_DONT_MANGLE; - } else if (sym.scope instanceof AST_Lambda && name == "arguments") { - sym.scope.get_defun_scope().uses_arguments = true; - } - node.thedef = sym; - node.reference(); - if (node.scope.is_block_scope() - && !(sym.orig[0] instanceof AST_SymbolBlockDeclaration)) { - node.scope = node.scope.get_defun_scope(); - } - return true; - } - // ensure mangling works if catch reuses a scope variable - var def; - if (node instanceof AST_SymbolCatch && (def = redefined_catch_def(node.definition()))) { - var s = node.scope; - while (s) { - push_uniq(s.enclosed, def); - if (s === def.scope) break; - s = s.parent_scope; - } - } - }); - this.walk(tw); - - // pass 3: work around IE8 and Safari catch scope bugs - if (options.ie8 || options.safari10) { - walk(this, node => { - if (node instanceof AST_SymbolCatch) { - var name = node.name; - var refs = node.thedef.references; - var scope = node.scope.get_defun_scope(); - var def = scope.find_variable(name) - || toplevel.globals.get(name) - || scope.def_variable(node); - refs.forEach(function(ref) { - ref.thedef = def; - ref.reference(); - }); - node.thedef = def; - node.reference(); - return true; - } - }); - } - - // pass 4: add symbol definitions to loop scopes - // Safari/Webkit bug workaround - loop init let variable shadowing argument. - // https://github.com/mishoo/UglifyJS2/issues/1753 - // https://bugs.webkit.org/show_bug.cgi?id=171041 - if (options.safari10) { - for (const scope of for_scopes) { - scope.parent_scope.variables.forEach(function(def) { - push_uniq(scope.enclosed, def); - }); - } - } -}); - -AST_Toplevel.DEFMETHOD("def_global", function(node) { - var globals = this.globals, name = node.name; - if (globals.has(name)) { - return globals.get(name); - } else { - var g = new SymbolDef(this, node); - g.undeclared = true; - g.global = true; - globals.set(name, g); - return g; - } -}); - -AST_Scope.DEFMETHOD("init_scope_vars", function(parent_scope) { - this.variables = new Map(); // map name to AST_SymbolVar (variables defined in this scope; includes functions) - this.uses_with = false; // will be set to true if this or some nested scope uses the `with` statement - this.uses_eval = false; // will be set to true if this or nested scope uses the global `eval` - this.parent_scope = parent_scope; // the parent scope - this.enclosed = []; // a list of variables from this or outer scope(s) that are referenced from this or inner scopes - this.cname = -1; // the current index for mangling functions/variables -}); - -AST_Scope.DEFMETHOD("conflicting_def", function (name) { - return ( - this.enclosed.find(def => def.name === name) - || this.variables.has(name) - || (this.parent_scope && this.parent_scope.conflicting_def(name)) - ); -}); - -AST_Scope.DEFMETHOD("conflicting_def_shallow", function (name) { - return ( - this.enclosed.find(def => def.name === name) - || this.variables.has(name) - ); -}); - -AST_Scope.DEFMETHOD("add_child_scope", function (scope) { - // `scope` is going to be moved into `this` right now. - // Update the required scopes' information - - if (scope.parent_scope === this) return; - - scope.parent_scope = this; - - // Propagate to this.uses_arguments from arrow functions - if ((scope instanceof AST_Arrow) && !this.uses_arguments) { - this.uses_arguments = walk(scope, node => { - if ( - node instanceof AST_SymbolRef - && node.scope instanceof AST_Lambda - && node.name === "arguments" - ) { - return walk_abort; - } - - if (node instanceof AST_Lambda && !(node instanceof AST_Arrow)) { - return true; - } - }); - } - - this.uses_with = this.uses_with || scope.uses_with; - this.uses_eval = this.uses_eval || scope.uses_eval; - - const scope_ancestry = (() => { - const ancestry = []; - let cur = this; - do { - ancestry.push(cur); - } while ((cur = cur.parent_scope)); - ancestry.reverse(); - return ancestry; - })(); - - const new_scope_enclosed_set = new Set(scope.enclosed); - const to_enclose = []; - for (const scope_topdown of scope_ancestry) { - to_enclose.forEach(e => push_uniq(scope_topdown.enclosed, e)); - for (const def of scope_topdown.variables.values()) { - if (new_scope_enclosed_set.has(def)) { - push_uniq(to_enclose, def); - push_uniq(scope_topdown.enclosed, def); - } - } - } -}); - -function find_scopes_visible_from(scopes) { - const found_scopes = new Set(); - - for (const scope of new Set(scopes)) { - (function bubble_up(scope) { - if (scope == null || found_scopes.has(scope)) return; - - found_scopes.add(scope); - - bubble_up(scope.parent_scope); - })(scope); - } - - return [...found_scopes]; -} - -// Creates a symbol during compression -AST_Scope.DEFMETHOD("create_symbol", function(SymClass, { - source, - tentative_name, - scope, - conflict_scopes = [scope], - init = null -} = {}) { - let symbol_name; - - conflict_scopes = find_scopes_visible_from(conflict_scopes); - - if (tentative_name) { - // Implement hygiene (no new names are conflicting with existing names) - tentative_name = - symbol_name = - tentative_name.replace(/(?:^[^a-z_$]|[^a-z0-9_$])/ig, "_"); - - let i = 0; - while (conflict_scopes.find(s => s.conflicting_def_shallow(symbol_name))) { - symbol_name = tentative_name + "$" + i++; - } - } - - if (!symbol_name) { - throw new Error("No symbol name could be generated in create_symbol()"); - } - - const symbol = make_node(SymClass, source, { - name: symbol_name, - scope - }); - - this.def_variable(symbol, init || null); - - symbol.mark_enclosed(); - - return symbol; -}); - - -AST_Node.DEFMETHOD("is_block_scope", return_false); -AST_Class.DEFMETHOD("is_block_scope", return_false); -AST_Lambda.DEFMETHOD("is_block_scope", return_false); -AST_Toplevel.DEFMETHOD("is_block_scope", return_false); -AST_SwitchBranch.DEFMETHOD("is_block_scope", return_false); -AST_Block.DEFMETHOD("is_block_scope", return_true); -AST_Scope.DEFMETHOD("is_block_scope", function () { - return this._block_scope || false; -}); -AST_IterationStatement.DEFMETHOD("is_block_scope", return_true); - -AST_Lambda.DEFMETHOD("init_scope_vars", function() { - AST_Scope.prototype.init_scope_vars.apply(this, arguments); - this.uses_arguments = false; - this.def_variable(new AST_SymbolFunarg({ - name: "arguments", - start: this.start, - end: this.end - })); -}); - -AST_Arrow.DEFMETHOD("init_scope_vars", function() { - AST_Scope.prototype.init_scope_vars.apply(this, arguments); - this.uses_arguments = false; -}); - -AST_Symbol.DEFMETHOD("mark_enclosed", function() { - var def = this.definition(); - var s = this.scope; - while (s) { - push_uniq(s.enclosed, def); - if (s === def.scope) break; - s = s.parent_scope; - } -}); - -AST_Symbol.DEFMETHOD("reference", function() { - this.definition().references.push(this); - this.mark_enclosed(); -}); - -AST_Scope.DEFMETHOD("find_variable", function(name) { - if (name instanceof AST_Symbol) name = name.name; - return this.variables.get(name) - || (this.parent_scope && this.parent_scope.find_variable(name)); -}); - -AST_Scope.DEFMETHOD("def_function", function(symbol, init) { - var def = this.def_variable(symbol, init); - if (!def.init || def.init instanceof AST_Defun) def.init = init; - return def; -}); - -AST_Scope.DEFMETHOD("def_variable", function(symbol, init) { - var def = this.variables.get(symbol.name); - if (def) { - def.orig.push(symbol); - if (def.init && (def.scope !== symbol.scope || def.init instanceof AST_Function)) { - def.init = init; - } - } else { - def = new SymbolDef(this, symbol, init); - this.variables.set(symbol.name, def); - def.global = !this.parent_scope; - } - return symbol.thedef = def; -}); - -function next_mangled(scope, options) { - let defun_scope; - if ( - scopes_with_block_defuns - && (defun_scope = scope.get_defun_scope()) - && scopes_with_block_defuns.has(defun_scope) - ) { - scope = defun_scope; - } - - var ext = scope.enclosed; - var nth_identifier = options.nth_identifier; - out: while (true) { - var m = nth_identifier.get(++scope.cname); - if (ALL_RESERVED_WORDS.has(m)) continue; // skip over "do" - - // https://github.com/mishoo/UglifyJS2/issues/242 -- do not - // shadow a name reserved from mangling. - if (options.reserved.has(m)) continue; - - // Functions with short names might collide with base54 output - // and therefore cause collisions when keep_fnames is true. - if (unmangleable_names && unmangleable_names.has(m)) continue out; - - // we must ensure that the mangled name does not shadow a name - // from some parent scope that is referenced in this or in - // inner scopes. - for (let i = ext.length; --i >= 0;) { - const def = ext[i]; - const name = def.mangled_name || (def.unmangleable(options) && def.name); - if (m == name) continue out; - } - return m; - } -} - -AST_Scope.DEFMETHOD("next_mangled", function(options) { - return next_mangled(this, options); -}); - -AST_Toplevel.DEFMETHOD("next_mangled", function(options) { - let name; - const mangled_names = this.mangled_names; - do { - name = next_mangled(this, options); - } while (mangled_names.has(name)); - return name; -}); - -AST_Function.DEFMETHOD("next_mangled", function(options, def) { - // #179, #326 - // in Safari strict mode, something like (function x(x){...}) is a syntax error; - // a function expression's argument cannot shadow the function expression's name - - var tricky_def = def.orig[0] instanceof AST_SymbolFunarg && this.name && this.name.definition(); - - // the function's mangled_name is null when keep_fnames is true - var tricky_name = tricky_def ? tricky_def.mangled_name || tricky_def.name : null; - - while (true) { - var name = next_mangled(this, options); - if (!tricky_name || tricky_name != name) - return name; - } -}); - -AST_Symbol.DEFMETHOD("unmangleable", function(options) { - var def = this.definition(); - return !def || def.unmangleable(options); -}); - -// labels are always mangleable -AST_Label.DEFMETHOD("unmangleable", return_false); - -AST_Symbol.DEFMETHOD("unreferenced", function() { - return !this.definition().references.length && !this.scope.pinned(); -}); - -AST_Symbol.DEFMETHOD("definition", function() { - return this.thedef; -}); - -AST_Symbol.DEFMETHOD("global", function() { - return this.thedef.global; -}); - -/** - * Format the mangler options (if any) into their appropriate types - */ -export function format_mangler_options(options) { - options = defaults(options, { - eval : false, - nth_identifier : base54, - ie8 : false, - keep_classnames: false, - keep_fnames : false, - module : false, - reserved : [], - toplevel : false, - }); - if (options.module) options.toplevel = true; - if (!Array.isArray(options.reserved) - && !(options.reserved instanceof Set) - ) { - options.reserved = []; - } - options.reserved = new Set(options.reserved); - // Never mangle arguments - options.reserved.add("arguments"); - return options; -} - -AST_Toplevel.DEFMETHOD("mangle_names", function(options) { - options = format_mangler_options(options); - var nth_identifier = options.nth_identifier; - - // We only need to mangle declaration nodes. Special logic wired - // into the code generator will display the mangled name if it's - // present (and for AST_SymbolRef-s it'll use the mangled name of - // the AST_SymbolDeclaration that it points to). - var lname = -1; - var to_mangle = []; - - if (options.keep_fnames) { - function_defs = new Set(); - } - - const mangled_names = this.mangled_names = new Set(); - unmangleable_names = new Set(); - - if (options.cache) { - this.globals.forEach(collect); - if (options.cache.props) { - options.cache.props.forEach(function(mangled_name) { - mangled_names.add(mangled_name); - }); - } - } - - var tw = new TreeWalker(function(node, descend) { - if (node instanceof AST_LabeledStatement) { - // lname is incremented when we get to the AST_Label - var save_nesting = lname; - descend(); - lname = save_nesting; - return true; // don't descend again in TreeWalker - } - if ( - node instanceof AST_Defun - && !(tw.parent() instanceof AST_Scope) - ) { - scopes_with_block_defuns = scopes_with_block_defuns || new Set(); - scopes_with_block_defuns.add(node.parent_scope.get_defun_scope()); - } - if (node instanceof AST_Scope) { - node.variables.forEach(collect); - return; - } - if (node.is_block_scope()) { - node.block_scope.variables.forEach(collect); - return; - } - if ( - function_defs - && node instanceof AST_VarDef - && node.value instanceof AST_Lambda - && !node.value.name - && keep_name(options.keep_fnames, node.name.name) - ) { - function_defs.add(node.name.definition().id); - return; - } - if (node instanceof AST_Label) { - let name; - do { - name = nth_identifier.get(++lname); - } while (ALL_RESERVED_WORDS.has(name)); - node.mangled_name = name; - return true; - } - if (!(options.ie8 || options.safari10) && node instanceof AST_SymbolCatch) { - to_mangle.push(node.definition()); - return; - } - }); - - this.walk(tw); - - if (options.keep_fnames || options.keep_classnames) { - // Collect a set of short names which are unmangleable, - // for use in avoiding collisions in next_mangled. - to_mangle.forEach(def => { - if (def.name.length < 6 && def.unmangleable(options)) { - unmangleable_names.add(def.name); - } - }); - } - - to_mangle.forEach(def => { def.mangle(options); }); - - function_defs = null; - unmangleable_names = null; - scopes_with_block_defuns = null; - - function collect(symbol) { - if (symbol.export & MASK_EXPORT_DONT_MANGLE) { - unmangleable_names.add(symbol.name); - } else if (!options.reserved.has(symbol.name)) { - to_mangle.push(symbol); - } - } -}); - -AST_Toplevel.DEFMETHOD("find_colliding_names", function(options) { - const cache = options.cache && options.cache.props; - const avoid = new Set(); - options.reserved.forEach(to_avoid); - this.globals.forEach(add_def); - this.walk(new TreeWalker(function(node) { - if (node instanceof AST_Scope) node.variables.forEach(add_def); - if (node instanceof AST_SymbolCatch) add_def(node.definition()); - })); - return avoid; - - function to_avoid(name) { - avoid.add(name); - } - - function add_def(def) { - var name = def.name; - if (def.global && cache && cache.has(name)) name = cache.get(name); - else if (!def.unmangleable(options)) return; - to_avoid(name); - } -}); - -AST_Toplevel.DEFMETHOD("expand_names", function(options) { - options = format_mangler_options(options); - var nth_identifier = options.nth_identifier; - if (nth_identifier.reset && nth_identifier.sort) { - nth_identifier.reset(); - nth_identifier.sort(); - } - var avoid = this.find_colliding_names(options); - var cname = 0; - this.globals.forEach(rename); - this.walk(new TreeWalker(function(node) { - if (node instanceof AST_Scope) node.variables.forEach(rename); - if (node instanceof AST_SymbolCatch) rename(node.definition()); - })); - - function next_name() { - var name; - do { - name = nth_identifier.get(cname++); - } while (avoid.has(name) || ALL_RESERVED_WORDS.has(name)); - return name; - } - - function rename(def) { - if (def.global && options.cache) return; - if (def.unmangleable(options)) return; - if (options.reserved.has(def.name)) return; - const redefinition = redefined_catch_def(def); - const name = def.name = redefinition ? redefinition.name : next_name(); - def.orig.forEach(function(sym) { - sym.name = name; - }); - def.references.forEach(function(sym) { - sym.name = name; - }); - } -}); - -AST_Node.DEFMETHOD("tail_node", return_this); -AST_Sequence.DEFMETHOD("tail_node", function() { - return this.expressions[this.expressions.length - 1]; -}); - -AST_Toplevel.DEFMETHOD("compute_char_frequency", function(options) { - options = format_mangler_options(options); - var nth_identifier = options.nth_identifier; - if (!nth_identifier.reset || !nth_identifier.consider || !nth_identifier.sort) { - // If the identifier mangler is invariant, skip computing character frequency. - return; - } - nth_identifier.reset(); - - try { - AST_Node.prototype.print = function(stream, force_parens) { - this._print(stream, force_parens); - if (this instanceof AST_Symbol && !this.unmangleable(options)) { - nth_identifier.consider(this.name, -1); - } else if (options.properties) { - if (this instanceof AST_DotHash) { - nth_identifier.consider("#" + this.property, -1); - } else if (this instanceof AST_Dot) { - nth_identifier.consider(this.property, -1); - } else if (this instanceof AST_Sub) { - skip_string(this.property); - } - } - }; - nth_identifier.consider(this.print_to_string(), 1); - } finally { - AST_Node.prototype.print = AST_Node.prototype._print; - } - nth_identifier.sort(); - - function skip_string(node) { - if (node instanceof AST_String) { - nth_identifier.consider(node.value, -1); - } else if (node instanceof AST_Conditional) { - skip_string(node.consequent); - skip_string(node.alternative); - } else if (node instanceof AST_Sequence) { - skip_string(node.tail_node()); - } - } -}); - -const base54 = (() => { - const leading = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_".split(""); - const digits = "0123456789".split(""); - let chars; - let frequency; - function reset() { - frequency = new Map(); - leading.forEach(function(ch) { - frequency.set(ch, 0); - }); - digits.forEach(function(ch) { - frequency.set(ch, 0); - }); - } - function consider(str, delta) { - for (var i = str.length; --i >= 0;) { - frequency.set(str[i], frequency.get(str[i]) + delta); - } - } - function compare(a, b) { - return frequency.get(b) - frequency.get(a); - } - function sort() { - chars = mergeSort(leading, compare).concat(mergeSort(digits, compare)); - } - // Ensure this is in a usable initial state. - reset(); - sort(); - function base54(num) { - var ret = "", base = 54; - num++; - do { - num--; - ret += chars[num % base]; - num = Math.floor(num / base); - base = 64; - } while (num > 0); - return ret; - } - - return { - get: base54, - consider, - reset, - sort - }; -})(); - -export { - base54, - SymbolDef, -}; -- cgit v1.2.3