Deployed the page to Github Pages.
This commit is contained in:
parent
1d79754e93
commit
2c89899458
SSH key fingerprint:
SHA256:kEsnuHX+qbwhxSAXPUQ4ox535wFHu/hIRaa53FzxRpo
62797 changed files with 6551425 additions and 15279 deletions
3357
node_modules/terser/lib/ast.js
generated
vendored
Normal file
3357
node_modules/terser/lib/ast.js
generated
vendored
Normal file
File diff suppressed because it is too large
Load diff
481
node_modules/terser/lib/cli.js
generated
vendored
Normal file
481
node_modules/terser/lib/cli.js
generated
vendored
Normal file
|
|
@ -0,0 +1,481 @@
|
|||
import { minify, _default_options } from "../main.js";
|
||||
import { parse } from "./parse.js";
|
||||
import {
|
||||
AST_Assign,
|
||||
AST_Array,
|
||||
AST_Constant,
|
||||
AST_Node,
|
||||
AST_PropAccess,
|
||||
AST_RegExp,
|
||||
AST_Sequence,
|
||||
AST_Symbol,
|
||||
AST_Token,
|
||||
walk
|
||||
} from "./ast.js";
|
||||
import { OutputStream } from "./output.js";
|
||||
|
||||
export async function run_cli({ program, packageJson, fs, path }) {
|
||||
const skip_keys = new Set([ "cname", "parent_scope", "scope", "uses_eval", "uses_with" ]);
|
||||
var files = {};
|
||||
var options = {
|
||||
compress: false,
|
||||
mangle: false
|
||||
};
|
||||
const default_options = await _default_options();
|
||||
program.version(packageJson.name + " " + packageJson.version);
|
||||
program.parseArgv = program.parse;
|
||||
program.parse = undefined;
|
||||
|
||||
if (process.argv.includes("ast")) program.helpInformation = describe_ast;
|
||||
else if (process.argv.includes("options")) program.helpInformation = function() {
|
||||
var text = [];
|
||||
for (var option in default_options) {
|
||||
text.push("--" + (option === "sourceMap" ? "source-map" : option) + " options:");
|
||||
text.push(format_object(default_options[option]));
|
||||
text.push("");
|
||||
}
|
||||
return text.join("\n");
|
||||
};
|
||||
|
||||
program.option("-p, --parse <options>", "Specify parser options.", parse_js());
|
||||
program.option("-c, --compress [options]", "Enable compressor/specify compressor options.", parse_js());
|
||||
program.option("-m, --mangle [options]", "Mangle names/specify mangler options.", parse_js());
|
||||
program.option("--mangle-props [options]", "Mangle properties/specify mangler options.", parse_js());
|
||||
program.option("-f, --format [options]", "Format options.", parse_js());
|
||||
program.option("-b, --beautify [options]", "Alias for --format.", parse_js());
|
||||
program.option("-o, --output <file>", "Output file (default STDOUT).");
|
||||
program.option("--comments [filter]", "Preserve copyright comments in the output.");
|
||||
program.option("--config-file <file>", "Read minify() options from JSON file.");
|
||||
program.option("-d, --define <expr>[=value]", "Global definitions.", parse_js("define"));
|
||||
program.option("--ecma <version>", "Specify ECMAScript release: 5, 2015, 2016 or 2017...");
|
||||
program.option("-e, --enclose [arg[,...][:value[,...]]]", "Embed output in a big function with configurable arguments and values.");
|
||||
program.option("--ie8", "Support non-standard Internet Explorer 8.");
|
||||
program.option("--keep-classnames", "Do not mangle/drop class names.");
|
||||
program.option("--keep-fnames", "Do not mangle/drop function names. Useful for code relying on Function.prototype.name.");
|
||||
program.option("--module", "Input is an ES6 module");
|
||||
program.option("--name-cache <file>", "File to hold mangled name mappings.");
|
||||
program.option("--rename", "Force symbol expansion.");
|
||||
program.option("--no-rename", "Disable symbol expansion.");
|
||||
program.option("--safari10", "Support non-standard Safari 10.");
|
||||
program.option("--source-map [options]", "Enable source map/specify source map options.", parse_js());
|
||||
program.option("--timings", "Display operations run time on STDERR.");
|
||||
program.option("--toplevel", "Compress and/or mangle variables in toplevel scope.");
|
||||
program.option("--wrap <name>", "Embed everything as a function with “exports” corresponding to “name” globally.");
|
||||
program.arguments("[files...]").parseArgv(process.argv);
|
||||
if (program.configFile) {
|
||||
options = JSON.parse(read_file(program.configFile));
|
||||
}
|
||||
if (!program.output && program.sourceMap && program.sourceMap.url != "inline") {
|
||||
fatal("ERROR: cannot write source map to STDOUT");
|
||||
}
|
||||
|
||||
[
|
||||
"compress",
|
||||
"enclose",
|
||||
"ie8",
|
||||
"mangle",
|
||||
"module",
|
||||
"safari10",
|
||||
"sourceMap",
|
||||
"toplevel",
|
||||
"wrap"
|
||||
].forEach(function(name) {
|
||||
if (name in program) {
|
||||
options[name] = program[name];
|
||||
}
|
||||
});
|
||||
|
||||
if ("ecma" in program) {
|
||||
if (program.ecma != (program.ecma | 0)) fatal("ERROR: ecma must be an integer");
|
||||
const ecma = program.ecma | 0;
|
||||
if (ecma > 5 && ecma < 2015)
|
||||
options.ecma = ecma + 2009;
|
||||
else
|
||||
options.ecma = ecma;
|
||||
}
|
||||
if (program.format || program.beautify) {
|
||||
const chosenOption = program.format || program.beautify;
|
||||
options.format = typeof chosenOption === "object" ? chosenOption : {};
|
||||
}
|
||||
if (program.comments) {
|
||||
if (typeof options.format != "object") options.format = {};
|
||||
options.format.comments = typeof program.comments == "string" ? (program.comments == "false" ? false : program.comments) : "some";
|
||||
}
|
||||
if (program.define) {
|
||||
if (typeof options.compress != "object") options.compress = {};
|
||||
if (typeof options.compress.global_defs != "object") options.compress.global_defs = {};
|
||||
for (var expr in program.define) {
|
||||
options.compress.global_defs[expr] = program.define[expr];
|
||||
}
|
||||
}
|
||||
if (program.keepClassnames) {
|
||||
options.keep_classnames = true;
|
||||
}
|
||||
if (program.keepFnames) {
|
||||
options.keep_fnames = true;
|
||||
}
|
||||
if (program.mangleProps) {
|
||||
if (program.mangleProps.domprops) {
|
||||
delete program.mangleProps.domprops;
|
||||
} else {
|
||||
if (typeof program.mangleProps != "object") program.mangleProps = {};
|
||||
if (!Array.isArray(program.mangleProps.reserved)) program.mangleProps.reserved = [];
|
||||
}
|
||||
if (typeof options.mangle != "object") options.mangle = {};
|
||||
options.mangle.properties = program.mangleProps;
|
||||
}
|
||||
if (program.nameCache) {
|
||||
options.nameCache = JSON.parse(read_file(program.nameCache, "{}"));
|
||||
}
|
||||
if (program.output == "ast") {
|
||||
options.format = {
|
||||
ast: true,
|
||||
code: false
|
||||
};
|
||||
}
|
||||
if (program.parse) {
|
||||
if (!program.parse.acorn && !program.parse.spidermonkey) {
|
||||
options.parse = program.parse;
|
||||
} else if (program.sourceMap && program.sourceMap.content == "inline") {
|
||||
fatal("ERROR: inline source map only works with built-in parser");
|
||||
}
|
||||
}
|
||||
if (~program.rawArgs.indexOf("--rename")) {
|
||||
options.rename = true;
|
||||
} else if (!program.rename) {
|
||||
options.rename = false;
|
||||
}
|
||||
|
||||
let convert_path = name => name;
|
||||
if (typeof program.sourceMap == "object" && "base" in program.sourceMap) {
|
||||
convert_path = function() {
|
||||
var base = program.sourceMap.base;
|
||||
delete options.sourceMap.base;
|
||||
return function(name) {
|
||||
return path.relative(base, name);
|
||||
};
|
||||
}();
|
||||
}
|
||||
|
||||
let filesList;
|
||||
if (options.files && options.files.length) {
|
||||
filesList = options.files;
|
||||
|
||||
delete options.files;
|
||||
} else if (program.args.length) {
|
||||
filesList = program.args;
|
||||
}
|
||||
|
||||
if (filesList) {
|
||||
simple_glob(filesList).forEach(function(name) {
|
||||
files[convert_path(name)] = read_file(name);
|
||||
});
|
||||
} else {
|
||||
await new Promise((resolve) => {
|
||||
var chunks = [];
|
||||
process.stdin.setEncoding("utf8");
|
||||
process.stdin.on("data", function(chunk) {
|
||||
chunks.push(chunk);
|
||||
}).on("end", function() {
|
||||
files = [ chunks.join("") ];
|
||||
resolve();
|
||||
});
|
||||
process.stdin.resume();
|
||||
});
|
||||
}
|
||||
|
||||
await run_cli();
|
||||
|
||||
function convert_ast(fn) {
|
||||
return AST_Node.from_mozilla_ast(Object.keys(files).reduce(fn, null));
|
||||
}
|
||||
|
||||
async function run_cli() {
|
||||
var content = program.sourceMap && program.sourceMap.content;
|
||||
if (content && content !== "inline") {
|
||||
options.sourceMap.content = read_file(content, content);
|
||||
}
|
||||
if (program.timings) options.timings = true;
|
||||
|
||||
try {
|
||||
if (program.parse) {
|
||||
if (program.parse.acorn) {
|
||||
files = convert_ast(function(toplevel, name) {
|
||||
return require("acorn").parse(files[name], {
|
||||
ecmaVersion: 2018,
|
||||
locations: true,
|
||||
program: toplevel,
|
||||
sourceFile: name,
|
||||
sourceType: options.module || program.parse.module ? "module" : "script"
|
||||
});
|
||||
});
|
||||
} else if (program.parse.spidermonkey) {
|
||||
files = convert_ast(function(toplevel, name) {
|
||||
var obj = JSON.parse(files[name]);
|
||||
if (!toplevel) return obj;
|
||||
toplevel.body = toplevel.body.concat(obj.body);
|
||||
return toplevel;
|
||||
});
|
||||
}
|
||||
}
|
||||
} catch (ex) {
|
||||
fatal(ex);
|
||||
}
|
||||
|
||||
let result;
|
||||
try {
|
||||
result = await minify(files, options, fs);
|
||||
} catch (ex) {
|
||||
if (ex.name == "SyntaxError") {
|
||||
print_error("Parse error at " + ex.filename + ":" + ex.line + "," + ex.col);
|
||||
var col = ex.col;
|
||||
var lines = files[ex.filename].split(/\r?\n/);
|
||||
var line = lines[ex.line - 1];
|
||||
if (!line && !col) {
|
||||
line = lines[ex.line - 2];
|
||||
col = line.length;
|
||||
}
|
||||
if (line) {
|
||||
var limit = 70;
|
||||
if (col > limit) {
|
||||
line = line.slice(col - limit);
|
||||
col = limit;
|
||||
}
|
||||
print_error(line.slice(0, 80));
|
||||
print_error(line.slice(0, col).replace(/\S/g, " ") + "^");
|
||||
}
|
||||
}
|
||||
if (ex.defs) {
|
||||
print_error("Supported options:");
|
||||
print_error(format_object(ex.defs));
|
||||
}
|
||||
fatal(ex);
|
||||
return;
|
||||
}
|
||||
|
||||
if (program.output == "ast") {
|
||||
if (!options.compress && !options.mangle) {
|
||||
result.ast.figure_out_scope({});
|
||||
}
|
||||
console.log(JSON.stringify(result.ast, function(key, value) {
|
||||
if (value) switch (key) {
|
||||
case "thedef":
|
||||
return symdef(value);
|
||||
case "enclosed":
|
||||
return value.length ? value.map(symdef) : undefined;
|
||||
case "variables":
|
||||
case "globals":
|
||||
return value.size ? collect_from_map(value, symdef) : undefined;
|
||||
}
|
||||
if (skip_keys.has(key)) return;
|
||||
if (value instanceof AST_Token) return;
|
||||
if (value instanceof Map) return;
|
||||
if (value instanceof AST_Node) {
|
||||
var result = {
|
||||
_class: "AST_" + value.TYPE
|
||||
};
|
||||
if (value.block_scope) {
|
||||
result.variables = value.block_scope.variables;
|
||||
result.enclosed = value.block_scope.enclosed;
|
||||
}
|
||||
value.CTOR.PROPS.forEach(function(prop) {
|
||||
if (prop !== "block_scope") {
|
||||
result[prop] = value[prop];
|
||||
}
|
||||
});
|
||||
return result;
|
||||
}
|
||||
return value;
|
||||
}, 2));
|
||||
} else if (program.output == "spidermonkey") {
|
||||
try {
|
||||
const minified = await minify(
|
||||
result.code,
|
||||
{
|
||||
compress: false,
|
||||
mangle: false,
|
||||
format: {
|
||||
ast: true,
|
||||
code: false
|
||||
}
|
||||
},
|
||||
fs
|
||||
);
|
||||
console.log(JSON.stringify(minified.ast.to_mozilla_ast(), null, 2));
|
||||
} catch (ex) {
|
||||
fatal(ex);
|
||||
return;
|
||||
}
|
||||
} else if (program.output) {
|
||||
fs.writeFileSync(program.output, result.code);
|
||||
if (options.sourceMap && options.sourceMap.url !== "inline" && result.map) {
|
||||
fs.writeFileSync(program.output + ".map", result.map);
|
||||
}
|
||||
} else {
|
||||
console.log(result.code);
|
||||
}
|
||||
if (program.nameCache) {
|
||||
fs.writeFileSync(program.nameCache, JSON.stringify(options.nameCache));
|
||||
}
|
||||
if (result.timings) for (var phase in result.timings) {
|
||||
print_error("- " + phase + ": " + result.timings[phase].toFixed(3) + "s");
|
||||
}
|
||||
}
|
||||
|
||||
function fatal(message) {
|
||||
if (message instanceof Error) message = message.stack.replace(/^\S*?Error:/, "ERROR:");
|
||||
print_error(message);
|
||||
process.exit(1);
|
||||
}
|
||||
|
||||
// A file glob function that only supports "*" and "?" wildcards in the basename.
|
||||
// Example: "foo/bar/*baz??.*.js"
|
||||
// Argument `glob` may be a string or an array of strings.
|
||||
// Returns an array of strings. Garbage in, garbage out.
|
||||
function simple_glob(glob) {
|
||||
if (Array.isArray(glob)) {
|
||||
return [].concat.apply([], glob.map(simple_glob));
|
||||
}
|
||||
if (glob && glob.match(/[*?]/)) {
|
||||
var dir = path.dirname(glob);
|
||||
try {
|
||||
var entries = fs.readdirSync(dir);
|
||||
} catch (ex) {}
|
||||
if (entries) {
|
||||
var pattern = "^" + path.basename(glob)
|
||||
.replace(/[.+^$[\]\\(){}]/g, "\\$&")
|
||||
.replace(/\*/g, "[^/\\\\]*")
|
||||
.replace(/\?/g, "[^/\\\\]") + "$";
|
||||
var mod = process.platform === "win32" ? "i" : "";
|
||||
var rx = new RegExp(pattern, mod);
|
||||
var results = entries.filter(function(name) {
|
||||
return rx.test(name);
|
||||
}).map(function(name) {
|
||||
return path.join(dir, name);
|
||||
});
|
||||
if (results.length) return results;
|
||||
}
|
||||
}
|
||||
return [ glob ];
|
||||
}
|
||||
|
||||
function read_file(path, default_value) {
|
||||
try {
|
||||
return fs.readFileSync(path, "utf8");
|
||||
} catch (ex) {
|
||||
if ((ex.code == "ENOENT" || ex.code == "ENAMETOOLONG") && default_value != null) return default_value;
|
||||
fatal(ex);
|
||||
}
|
||||
}
|
||||
|
||||
function parse_js(flag) {
|
||||
return function(value, options) {
|
||||
options = options || {};
|
||||
try {
|
||||
walk(parse(value, { expression: true }), node => {
|
||||
if (node instanceof AST_Assign) {
|
||||
var name = node.left.print_to_string();
|
||||
var value = node.right;
|
||||
if (flag) {
|
||||
options[name] = value;
|
||||
} else if (value instanceof AST_Array) {
|
||||
options[name] = value.elements.map(to_string);
|
||||
} else if (value instanceof AST_RegExp) {
|
||||
value = value.value;
|
||||
options[name] = new RegExp(value.source, value.flags);
|
||||
} else {
|
||||
options[name] = to_string(value);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
if (node instanceof AST_Symbol || node instanceof AST_PropAccess) {
|
||||
var name = node.print_to_string();
|
||||
options[name] = true;
|
||||
return true;
|
||||
}
|
||||
if (!(node instanceof AST_Sequence)) throw node;
|
||||
|
||||
function to_string(value) {
|
||||
return value instanceof AST_Constant ? value.getValue() : value.print_to_string({
|
||||
quote_keys: true
|
||||
});
|
||||
}
|
||||
});
|
||||
} catch(ex) {
|
||||
if (flag) {
|
||||
fatal("Error parsing arguments for '" + flag + "': " + value);
|
||||
} else {
|
||||
options[value] = null;
|
||||
}
|
||||
}
|
||||
return options;
|
||||
};
|
||||
}
|
||||
|
||||
function symdef(def) {
|
||||
var ret = (1e6 + def.id) + " " + def.name;
|
||||
if (def.mangled_name) ret += " " + def.mangled_name;
|
||||
return ret;
|
||||
}
|
||||
|
||||
function collect_from_map(map, callback) {
|
||||
var result = [];
|
||||
map.forEach(function (def) {
|
||||
result.push(callback(def));
|
||||
});
|
||||
return result;
|
||||
}
|
||||
|
||||
function format_object(obj) {
|
||||
var lines = [];
|
||||
var padding = "";
|
||||
Object.keys(obj).map(function(name) {
|
||||
if (padding.length < name.length) padding = Array(name.length + 1).join(" ");
|
||||
return [ name, JSON.stringify(obj[name]) ];
|
||||
}).forEach(function(tokens) {
|
||||
lines.push(" " + tokens[0] + padding.slice(tokens[0].length - 2) + tokens[1]);
|
||||
});
|
||||
return lines.join("\n");
|
||||
}
|
||||
|
||||
function print_error(msg) {
|
||||
process.stderr.write(msg);
|
||||
process.stderr.write("\n");
|
||||
}
|
||||
|
||||
function describe_ast() {
|
||||
var out = OutputStream({ beautify: true });
|
||||
function doitem(ctor) {
|
||||
out.print("AST_" + ctor.TYPE);
|
||||
const props = ctor.SELF_PROPS.filter(prop => !/^\$/.test(prop));
|
||||
|
||||
if (props.length > 0) {
|
||||
out.space();
|
||||
out.with_parens(function() {
|
||||
props.forEach(function(prop, i) {
|
||||
if (i) out.space();
|
||||
out.print(prop);
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
if (ctor.documentation) {
|
||||
out.space();
|
||||
out.print_string(ctor.documentation);
|
||||
}
|
||||
|
||||
if (ctor.SUBCLASSES.length > 0) {
|
||||
out.space();
|
||||
out.with_block(function() {
|
||||
ctor.SUBCLASSES.forEach(function(ctor) {
|
||||
out.indent();
|
||||
doitem(ctor);
|
||||
out.newline();
|
||||
});
|
||||
});
|
||||
}
|
||||
}
|
||||
doitem(AST_Node);
|
||||
return out + "\n";
|
||||
}
|
||||
}
|
||||
4068
node_modules/terser/lib/compress/index.js
generated
vendored
Normal file
4068
node_modules/terser/lib/compress/index.js
generated
vendored
Normal file
File diff suppressed because it is too large
Load diff
287
node_modules/terser/lib/equivalent-to.js
generated
vendored
Normal file
287
node_modules/terser/lib/equivalent-to.js
generated
vendored
Normal file
|
|
@ -0,0 +1,287 @@
|
|||
import {
|
||||
AST_Array,
|
||||
AST_Atom,
|
||||
AST_Await,
|
||||
AST_BigInt,
|
||||
AST_Binary,
|
||||
AST_Block,
|
||||
AST_Call,
|
||||
AST_Catch,
|
||||
AST_Chain,
|
||||
AST_Class,
|
||||
AST_ClassProperty,
|
||||
AST_ConciseMethod,
|
||||
AST_Conditional,
|
||||
AST_Debugger,
|
||||
AST_Definitions,
|
||||
AST_Destructuring,
|
||||
AST_Directive,
|
||||
AST_Do,
|
||||
AST_Dot,
|
||||
AST_DotHash,
|
||||
AST_EmptyStatement,
|
||||
AST_Expansion,
|
||||
AST_Export,
|
||||
AST_Finally,
|
||||
AST_For,
|
||||
AST_ForIn,
|
||||
AST_ForOf,
|
||||
AST_If,
|
||||
AST_Import,
|
||||
AST_ImportMeta,
|
||||
AST_Jump,
|
||||
AST_LabeledStatement,
|
||||
AST_Lambda,
|
||||
AST_LoopControl,
|
||||
AST_NameMapping,
|
||||
AST_NewTarget,
|
||||
AST_Node,
|
||||
AST_Number,
|
||||
AST_Object,
|
||||
AST_ObjectGetter,
|
||||
AST_ObjectKeyVal,
|
||||
AST_ObjectProperty,
|
||||
AST_ObjectSetter,
|
||||
AST_PrefixedTemplateString,
|
||||
AST_PropAccess,
|
||||
AST_RegExp,
|
||||
AST_Sequence,
|
||||
AST_SimpleStatement,
|
||||
AST_String,
|
||||
AST_Super,
|
||||
AST_Switch,
|
||||
AST_SwitchBranch,
|
||||
AST_Symbol,
|
||||
AST_TemplateSegment,
|
||||
AST_TemplateString,
|
||||
AST_This,
|
||||
AST_Toplevel,
|
||||
AST_Try,
|
||||
AST_Unary,
|
||||
AST_VarDef,
|
||||
AST_While,
|
||||
AST_With,
|
||||
AST_Yield
|
||||
} from "./ast.js";
|
||||
|
||||
const shallow_cmp = (node1, node2) => {
|
||||
return (
|
||||
node1 === null && node2 === null
|
||||
|| node1.TYPE === node2.TYPE && node1.shallow_cmp(node2)
|
||||
);
|
||||
};
|
||||
|
||||
export const equivalent_to = (tree1, tree2) => {
|
||||
if (!shallow_cmp(tree1, tree2)) return false;
|
||||
const walk_1_state = [tree1];
|
||||
const walk_2_state = [tree2];
|
||||
|
||||
const walk_1_push = walk_1_state.push.bind(walk_1_state);
|
||||
const walk_2_push = walk_2_state.push.bind(walk_2_state);
|
||||
|
||||
while (walk_1_state.length && walk_2_state.length) {
|
||||
const node_1 = walk_1_state.pop();
|
||||
const node_2 = walk_2_state.pop();
|
||||
|
||||
if (!shallow_cmp(node_1, node_2)) return false;
|
||||
|
||||
node_1._children_backwards(walk_1_push);
|
||||
node_2._children_backwards(walk_2_push);
|
||||
|
||||
if (walk_1_state.length !== walk_2_state.length) {
|
||||
// Different number of children
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
return walk_1_state.length == 0 && walk_2_state.length == 0;
|
||||
};
|
||||
|
||||
const pass_through = () => true;
|
||||
|
||||
AST_Node.prototype.shallow_cmp = function () {
|
||||
throw new Error("did not find a shallow_cmp function for " + this.constructor.name);
|
||||
};
|
||||
|
||||
AST_Debugger.prototype.shallow_cmp = pass_through;
|
||||
|
||||
AST_Directive.prototype.shallow_cmp = function(other) {
|
||||
return this.value === other.value;
|
||||
};
|
||||
|
||||
AST_SimpleStatement.prototype.shallow_cmp = pass_through;
|
||||
|
||||
AST_Block.prototype.shallow_cmp = pass_through;
|
||||
|
||||
AST_EmptyStatement.prototype.shallow_cmp = pass_through;
|
||||
|
||||
AST_LabeledStatement.prototype.shallow_cmp = function(other) {
|
||||
return this.label.name === other.label.name;
|
||||
};
|
||||
|
||||
AST_Do.prototype.shallow_cmp = pass_through;
|
||||
|
||||
AST_While.prototype.shallow_cmp = pass_through;
|
||||
|
||||
AST_For.prototype.shallow_cmp = function(other) {
|
||||
return (this.init == null ? other.init == null : this.init === other.init) && (this.condition == null ? other.condition == null : this.condition === other.condition) && (this.step == null ? other.step == null : this.step === other.step);
|
||||
};
|
||||
|
||||
AST_ForIn.prototype.shallow_cmp = pass_through;
|
||||
|
||||
AST_ForOf.prototype.shallow_cmp = pass_through;
|
||||
|
||||
AST_With.prototype.shallow_cmp = pass_through;
|
||||
|
||||
AST_Toplevel.prototype.shallow_cmp = pass_through;
|
||||
|
||||
AST_Expansion.prototype.shallow_cmp = pass_through;
|
||||
|
||||
AST_Lambda.prototype.shallow_cmp = function(other) {
|
||||
return this.is_generator === other.is_generator && this.async === other.async;
|
||||
};
|
||||
|
||||
AST_Destructuring.prototype.shallow_cmp = function(other) {
|
||||
return this.is_array === other.is_array;
|
||||
};
|
||||
|
||||
AST_PrefixedTemplateString.prototype.shallow_cmp = pass_through;
|
||||
|
||||
AST_TemplateString.prototype.shallow_cmp = pass_through;
|
||||
|
||||
AST_TemplateSegment.prototype.shallow_cmp = function(other) {
|
||||
return this.value === other.value;
|
||||
};
|
||||
|
||||
AST_Jump.prototype.shallow_cmp = pass_through;
|
||||
|
||||
AST_LoopControl.prototype.shallow_cmp = pass_through;
|
||||
|
||||
AST_Await.prototype.shallow_cmp = pass_through;
|
||||
|
||||
AST_Yield.prototype.shallow_cmp = function(other) {
|
||||
return this.is_star === other.is_star;
|
||||
};
|
||||
|
||||
AST_If.prototype.shallow_cmp = function(other) {
|
||||
return this.alternative == null ? other.alternative == null : this.alternative === other.alternative;
|
||||
};
|
||||
|
||||
AST_Switch.prototype.shallow_cmp = pass_through;
|
||||
|
||||
AST_SwitchBranch.prototype.shallow_cmp = pass_through;
|
||||
|
||||
AST_Try.prototype.shallow_cmp = function(other) {
|
||||
return (this.body === other.body) && (this.bcatch == null ? other.bcatch == null : this.bcatch === other.bcatch) && (this.bfinally == null ? other.bfinally == null : this.bfinally === other.bfinally);
|
||||
};
|
||||
|
||||
AST_Catch.prototype.shallow_cmp = function(other) {
|
||||
return this.argname == null ? other.argname == null : this.argname === other.argname;
|
||||
};
|
||||
|
||||
AST_Finally.prototype.shallow_cmp = pass_through;
|
||||
|
||||
AST_Definitions.prototype.shallow_cmp = pass_through;
|
||||
|
||||
AST_VarDef.prototype.shallow_cmp = function(other) {
|
||||
return this.value == null ? other.value == null : this.value === other.value;
|
||||
};
|
||||
|
||||
AST_NameMapping.prototype.shallow_cmp = pass_through;
|
||||
|
||||
AST_Import.prototype.shallow_cmp = function(other) {
|
||||
return (this.imported_name == null ? other.imported_name == null : this.imported_name === other.imported_name) && (this.imported_names == null ? other.imported_names == null : this.imported_names === other.imported_names);
|
||||
};
|
||||
|
||||
AST_ImportMeta.prototype.shallow_cmp = pass_through;
|
||||
|
||||
AST_Export.prototype.shallow_cmp = function(other) {
|
||||
return (this.exported_definition == null ? other.exported_definition == null : this.exported_definition === other.exported_definition) && (this.exported_value == null ? other.exported_value == null : this.exported_value === other.exported_value) && (this.exported_names == null ? other.exported_names == null : this.exported_names === other.exported_names) && this.module_name === other.module_name && this.is_default === other.is_default;
|
||||
};
|
||||
|
||||
AST_Call.prototype.shallow_cmp = pass_through;
|
||||
|
||||
AST_Sequence.prototype.shallow_cmp = pass_through;
|
||||
|
||||
AST_PropAccess.prototype.shallow_cmp = pass_through;
|
||||
|
||||
AST_Chain.prototype.shallow_cmp = pass_through;
|
||||
|
||||
AST_Dot.prototype.shallow_cmp = function(other) {
|
||||
return this.property === other.property;
|
||||
};
|
||||
|
||||
AST_DotHash.prototype.shallow_cmp = function(other) {
|
||||
return this.property === other.property;
|
||||
};
|
||||
|
||||
AST_Unary.prototype.shallow_cmp = function(other) {
|
||||
return this.operator === other.operator;
|
||||
};
|
||||
|
||||
AST_Binary.prototype.shallow_cmp = function(other) {
|
||||
return this.operator === other.operator;
|
||||
};
|
||||
|
||||
AST_Conditional.prototype.shallow_cmp = pass_through;
|
||||
|
||||
AST_Array.prototype.shallow_cmp = pass_through;
|
||||
|
||||
AST_Object.prototype.shallow_cmp = pass_through;
|
||||
|
||||
AST_ObjectProperty.prototype.shallow_cmp = pass_through;
|
||||
|
||||
AST_ObjectKeyVal.prototype.shallow_cmp = function(other) {
|
||||
return this.key === other.key;
|
||||
};
|
||||
|
||||
AST_ObjectSetter.prototype.shallow_cmp = function(other) {
|
||||
return this.static === other.static;
|
||||
};
|
||||
|
||||
AST_ObjectGetter.prototype.shallow_cmp = function(other) {
|
||||
return this.static === other.static;
|
||||
};
|
||||
|
||||
AST_ConciseMethod.prototype.shallow_cmp = function(other) {
|
||||
return this.static === other.static && this.is_generator === other.is_generator && this.async === other.async;
|
||||
};
|
||||
|
||||
AST_Class.prototype.shallow_cmp = function(other) {
|
||||
return (this.name == null ? other.name == null : this.name === other.name) && (this.extends == null ? other.extends == null : this.extends === other.extends);
|
||||
};
|
||||
|
||||
AST_ClassProperty.prototype.shallow_cmp = function(other) {
|
||||
return this.static === other.static;
|
||||
};
|
||||
|
||||
AST_Symbol.prototype.shallow_cmp = function(other) {
|
||||
return this.name === other.name;
|
||||
};
|
||||
|
||||
AST_NewTarget.prototype.shallow_cmp = pass_through;
|
||||
|
||||
AST_This.prototype.shallow_cmp = pass_through;
|
||||
|
||||
AST_Super.prototype.shallow_cmp = pass_through;
|
||||
|
||||
AST_String.prototype.shallow_cmp = function(other) {
|
||||
return this.value === other.value;
|
||||
};
|
||||
|
||||
AST_Number.prototype.shallow_cmp = function(other) {
|
||||
return this.value === other.value;
|
||||
};
|
||||
|
||||
AST_BigInt.prototype.shallow_cmp = function(other) {
|
||||
return this.value === other.value;
|
||||
};
|
||||
|
||||
AST_RegExp.prototype.shallow_cmp = function (other) {
|
||||
return (
|
||||
this.value.flags === other.value.flags
|
||||
&& this.value.source === other.value.source
|
||||
);
|
||||
};
|
||||
|
||||
AST_Atom.prototype.shallow_cmp = pass_through;
|
||||
412
node_modules/terser/lib/minify.js
generated
vendored
Normal file
412
node_modules/terser/lib/minify.js
generated
vendored
Normal file
|
|
@ -0,0 +1,412 @@
|
|||
"use strict";
|
||||
/* eslint-env browser, es6, node */
|
||||
|
||||
import {
|
||||
defaults,
|
||||
map_from_object,
|
||||
map_to_object,
|
||||
HOP,
|
||||
} from "./utils/index.js";
|
||||
import { AST_Toplevel, AST_Node, walk, AST_Scope } from "./ast.js";
|
||||
import { parse } from "./parse.js";
|
||||
import { OutputStream } from "./output.js";
|
||||
import { Compressor } from "./compress/index.js";
|
||||
import { base54 } from "./scope.js";
|
||||
import { SourceMap } from "./sourcemap.js";
|
||||
import {
|
||||
mangle_properties,
|
||||
mangle_private_properties,
|
||||
reserve_quoted_keys,
|
||||
find_annotated_props,
|
||||
} from "./propmangle.js";
|
||||
|
||||
// to/from base64 functions
|
||||
// Prefer built-in Buffer, if available, then use hack
|
||||
// https://developer.mozilla.org/en-US/docs/Glossary/Base64#The_Unicode_Problem
|
||||
var to_ascii = typeof Buffer !== "undefined"
|
||||
? (b64) => Buffer.from(b64, "base64").toString()
|
||||
: (b64) => decodeURIComponent(escape(atob(b64)));
|
||||
var to_base64 = typeof Buffer !== "undefined"
|
||||
? (str) => Buffer.from(str).toString("base64")
|
||||
: (str) => btoa(unescape(encodeURIComponent(str)));
|
||||
|
||||
function read_source_map(code) {
|
||||
var match = /(?:^|[^.])\/\/# sourceMappingURL=data:application\/json(;[\w=-]*)?;base64,([+/0-9A-Za-z]*=*)\s*$/.exec(code);
|
||||
if (!match) {
|
||||
console.warn("inline source map not found");
|
||||
return null;
|
||||
}
|
||||
return to_ascii(match[2]);
|
||||
}
|
||||
|
||||
function set_shorthand(name, options, keys) {
|
||||
if (options[name]) {
|
||||
keys.forEach(function(key) {
|
||||
if (options[key]) {
|
||||
if (typeof options[key] != "object") options[key] = {};
|
||||
if (!(name in options[key])) options[key][name] = options[name];
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
function init_cache(cache) {
|
||||
if (!cache) return;
|
||||
if (!("props" in cache)) {
|
||||
cache.props = new Map();
|
||||
} else if (!(cache.props instanceof Map)) {
|
||||
cache.props = map_from_object(cache.props);
|
||||
}
|
||||
}
|
||||
|
||||
function cache_to_json(cache) {
|
||||
return {
|
||||
props: map_to_object(cache.props)
|
||||
};
|
||||
}
|
||||
|
||||
function log_input(files, options, fs, debug_folder) {
|
||||
if (!(fs && fs.writeFileSync && fs.mkdirSync)) {
|
||||
return;
|
||||
}
|
||||
|
||||
try {
|
||||
fs.mkdirSync(debug_folder);
|
||||
} catch (e) {
|
||||
if (e.code !== "EEXIST") throw e;
|
||||
}
|
||||
|
||||
const log_path = `${debug_folder}/terser-debug-${(Math.random() * 9999999) | 0}.log`;
|
||||
|
||||
options = options || {};
|
||||
|
||||
const options_str = JSON.stringify(options, (_key, thing) => {
|
||||
if (typeof thing === "function") return "[Function " + thing.toString() + "]";
|
||||
if (thing instanceof RegExp) return "[RegExp " + thing.toString() + "]";
|
||||
return thing;
|
||||
}, 4);
|
||||
|
||||
const files_str = (file) => {
|
||||
if (typeof file === "object" && options.parse && options.parse.spidermonkey) {
|
||||
return JSON.stringify(file, null, 2);
|
||||
} else if (typeof file === "object") {
|
||||
return Object.keys(file)
|
||||
.map((key) => key + ": " + files_str(file[key]))
|
||||
.join("\n\n");
|
||||
} else if (typeof file === "string") {
|
||||
return "```\n" + file + "\n```";
|
||||
} else {
|
||||
return file; // What do?
|
||||
}
|
||||
};
|
||||
|
||||
fs.writeFileSync(log_path, "Options: \n" + options_str + "\n\nInput files:\n\n" + files_str(files) + "\n");
|
||||
}
|
||||
|
||||
function* minify_sync_or_async(files, options, _fs_module) {
|
||||
if (
|
||||
_fs_module
|
||||
&& typeof process === "object"
|
||||
&& process.env
|
||||
&& typeof process.env.TERSER_DEBUG_DIR === "string"
|
||||
) {
|
||||
log_input(files, options, _fs_module, process.env.TERSER_DEBUG_DIR);
|
||||
}
|
||||
|
||||
options = defaults(options, {
|
||||
compress: {},
|
||||
ecma: undefined,
|
||||
enclose: false,
|
||||
ie8: false,
|
||||
keep_classnames: undefined,
|
||||
keep_fnames: false,
|
||||
mangle: {},
|
||||
module: false,
|
||||
nameCache: null,
|
||||
output: null,
|
||||
format: null,
|
||||
parse: {},
|
||||
rename: undefined,
|
||||
safari10: false,
|
||||
sourceMap: false,
|
||||
spidermonkey: false,
|
||||
timings: false,
|
||||
toplevel: false,
|
||||
warnings: false,
|
||||
wrap: false,
|
||||
}, true);
|
||||
|
||||
var timings = options.timings && {
|
||||
start: Date.now()
|
||||
};
|
||||
if (options.keep_classnames === undefined) {
|
||||
options.keep_classnames = options.keep_fnames;
|
||||
}
|
||||
if (options.rename === undefined) {
|
||||
options.rename = options.compress && options.mangle;
|
||||
}
|
||||
if (options.output && options.format) {
|
||||
throw new Error("Please only specify either output or format option, preferrably format.");
|
||||
}
|
||||
options.format = options.format || options.output || {};
|
||||
set_shorthand("ecma", options, [ "parse", "compress", "format" ]);
|
||||
set_shorthand("ie8", options, [ "compress", "mangle", "format" ]);
|
||||
set_shorthand("keep_classnames", options, [ "compress", "mangle" ]);
|
||||
set_shorthand("keep_fnames", options, [ "compress", "mangle" ]);
|
||||
set_shorthand("module", options, [ "parse", "compress", "mangle" ]);
|
||||
set_shorthand("safari10", options, [ "mangle", "format" ]);
|
||||
set_shorthand("toplevel", options, [ "compress", "mangle" ]);
|
||||
set_shorthand("warnings", options, [ "compress" ]); // legacy
|
||||
var quoted_props;
|
||||
if (options.mangle) {
|
||||
options.mangle = defaults(options.mangle, {
|
||||
cache: options.nameCache && (options.nameCache.vars || {}),
|
||||
eval: false,
|
||||
ie8: false,
|
||||
keep_classnames: false,
|
||||
keep_fnames: false,
|
||||
module: false,
|
||||
nth_identifier: base54,
|
||||
properties: false,
|
||||
reserved: [],
|
||||
safari10: false,
|
||||
toplevel: false,
|
||||
}, true);
|
||||
if (options.mangle.properties) {
|
||||
if (typeof options.mangle.properties != "object") {
|
||||
options.mangle.properties = {};
|
||||
}
|
||||
if (options.mangle.properties.keep_quoted) {
|
||||
quoted_props = options.mangle.properties.reserved;
|
||||
if (!Array.isArray(quoted_props)) quoted_props = [];
|
||||
options.mangle.properties.reserved = quoted_props;
|
||||
}
|
||||
if (options.nameCache && !("cache" in options.mangle.properties)) {
|
||||
options.mangle.properties.cache = options.nameCache.props || {};
|
||||
}
|
||||
}
|
||||
init_cache(options.mangle.cache);
|
||||
init_cache(options.mangle.properties.cache);
|
||||
}
|
||||
if (options.sourceMap) {
|
||||
options.sourceMap = defaults(options.sourceMap, {
|
||||
asObject: false,
|
||||
content: null,
|
||||
filename: null,
|
||||
includeSources: false,
|
||||
root: null,
|
||||
url: null,
|
||||
}, true);
|
||||
}
|
||||
|
||||
// -- Parse phase --
|
||||
if (timings) timings.parse = Date.now();
|
||||
var toplevel;
|
||||
if (files instanceof AST_Toplevel) {
|
||||
toplevel = files;
|
||||
} else {
|
||||
if (typeof files == "string" || (options.parse.spidermonkey && !Array.isArray(files))) {
|
||||
files = [ files ];
|
||||
}
|
||||
options.parse = options.parse || {};
|
||||
options.parse.toplevel = null;
|
||||
|
||||
if (options.parse.spidermonkey) {
|
||||
options.parse.toplevel = AST_Node.from_mozilla_ast(Object.keys(files).reduce(function(toplevel, name) {
|
||||
if (!toplevel) return files[name];
|
||||
toplevel.body = toplevel.body.concat(files[name].body);
|
||||
return toplevel;
|
||||
}, null));
|
||||
} else {
|
||||
delete options.parse.spidermonkey;
|
||||
|
||||
for (var name in files) if (HOP(files, name)) {
|
||||
options.parse.filename = name;
|
||||
options.parse.toplevel = parse(files[name], options.parse);
|
||||
if (options.sourceMap && options.sourceMap.content == "inline") {
|
||||
if (Object.keys(files).length > 1)
|
||||
throw new Error("inline source map only works with singular input");
|
||||
options.sourceMap.content = read_source_map(files[name]);
|
||||
}
|
||||
}
|
||||
}
|
||||
if (options.parse.toplevel === null) {
|
||||
throw new Error("no source file given");
|
||||
}
|
||||
|
||||
toplevel = options.parse.toplevel;
|
||||
}
|
||||
if (quoted_props && options.mangle.properties.keep_quoted !== "strict") {
|
||||
reserve_quoted_keys(toplevel, quoted_props);
|
||||
}
|
||||
var annotated_props;
|
||||
if (options.mangle && options.mangle.properties) {
|
||||
annotated_props = find_annotated_props(toplevel);
|
||||
}
|
||||
if (options.wrap) {
|
||||
toplevel = toplevel.wrap_commonjs(options.wrap);
|
||||
}
|
||||
if (options.enclose) {
|
||||
toplevel = toplevel.wrap_enclose(options.enclose);
|
||||
}
|
||||
if (timings) timings.rename = Date.now();
|
||||
// disable rename on harmony due to expand_names bug in for-of loops
|
||||
// https://github.com/mishoo/UglifyJS2/issues/2794
|
||||
if (0 && options.rename) {
|
||||
toplevel.figure_out_scope(options.mangle);
|
||||
toplevel.expand_names(options.mangle);
|
||||
}
|
||||
|
||||
// -- Compress phase --
|
||||
if (timings) timings.compress = Date.now();
|
||||
if (options.compress) {
|
||||
toplevel = new Compressor(options.compress, {
|
||||
mangle_options: options.mangle
|
||||
}).compress(toplevel);
|
||||
}
|
||||
|
||||
// -- Mangle phase --
|
||||
if (timings) timings.scope = Date.now();
|
||||
if (options.mangle) toplevel.figure_out_scope(options.mangle);
|
||||
if (timings) timings.mangle = Date.now();
|
||||
if (options.mangle) {
|
||||
toplevel.compute_char_frequency(options.mangle);
|
||||
toplevel.mangle_names(options.mangle);
|
||||
toplevel = mangle_private_properties(toplevel, options.mangle);
|
||||
}
|
||||
if (timings) timings.properties = Date.now();
|
||||
if (options.mangle && options.mangle.properties) {
|
||||
toplevel = mangle_properties(toplevel, options.mangle.properties, annotated_props);
|
||||
}
|
||||
|
||||
// Format phase
|
||||
if (timings) timings.format = Date.now();
|
||||
var result = {};
|
||||
if (options.format.ast) {
|
||||
result.ast = toplevel;
|
||||
}
|
||||
if (options.format.spidermonkey) {
|
||||
result.ast = toplevel.to_mozilla_ast();
|
||||
}
|
||||
let format_options;
|
||||
if (!HOP(options.format, "code") || options.format.code) {
|
||||
// Make a shallow copy so that we can modify without mutating the user's input.
|
||||
format_options = {...options.format};
|
||||
if (!format_options.ast) {
|
||||
// Destroy stuff to save RAM. (unless the deprecated `ast` option is on)
|
||||
format_options._destroy_ast = true;
|
||||
|
||||
walk(toplevel, node => {
|
||||
if (node instanceof AST_Scope) {
|
||||
node.variables = undefined;
|
||||
node.enclosed = undefined;
|
||||
node.parent_scope = undefined;
|
||||
}
|
||||
if (node.block_scope) {
|
||||
node.block_scope.variables = undefined;
|
||||
node.block_scope.enclosed = undefined;
|
||||
node.parent_scope = undefined;
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
if (options.sourceMap) {
|
||||
if (options.sourceMap.includeSources && files instanceof AST_Toplevel) {
|
||||
throw new Error("original source content unavailable");
|
||||
}
|
||||
format_options.source_map = yield* SourceMap({
|
||||
file: options.sourceMap.filename,
|
||||
orig: options.sourceMap.content,
|
||||
root: options.sourceMap.root,
|
||||
files: options.sourceMap.includeSources ? files : null,
|
||||
});
|
||||
}
|
||||
delete format_options.ast;
|
||||
delete format_options.code;
|
||||
delete format_options.spidermonkey;
|
||||
var stream = OutputStream(format_options);
|
||||
toplevel.print(stream);
|
||||
result.code = stream.get();
|
||||
if (options.sourceMap) {
|
||||
Object.defineProperty(result, "map", {
|
||||
configurable: true,
|
||||
enumerable: true,
|
||||
get() {
|
||||
const map = format_options.source_map.getEncoded();
|
||||
return (result.map = options.sourceMap.asObject ? map : JSON.stringify(map));
|
||||
},
|
||||
set(value) {
|
||||
Object.defineProperty(result, "map", {
|
||||
value,
|
||||
writable: true,
|
||||
});
|
||||
}
|
||||
});
|
||||
result.decoded_map = format_options.source_map.getDecoded();
|
||||
if (options.sourceMap.url == "inline") {
|
||||
var sourceMap = typeof result.map === "object" ? JSON.stringify(result.map) : result.map;
|
||||
result.code += "\n//# sourceMappingURL=data:application/json;charset=utf-8;base64," + to_base64(sourceMap);
|
||||
} else if (options.sourceMap.url) {
|
||||
result.code += "\n//# sourceMappingURL=" + options.sourceMap.url;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (options.nameCache && options.mangle) {
|
||||
if (options.mangle.cache) options.nameCache.vars = cache_to_json(options.mangle.cache);
|
||||
if (options.mangle.properties && options.mangle.properties.cache) {
|
||||
options.nameCache.props = cache_to_json(options.mangle.properties.cache);
|
||||
}
|
||||
}
|
||||
if (format_options && format_options.source_map) {
|
||||
format_options.source_map.destroy();
|
||||
}
|
||||
if (timings) {
|
||||
timings.end = Date.now();
|
||||
result.timings = {
|
||||
parse: 1e-3 * (timings.rename - timings.parse),
|
||||
rename: 1e-3 * (timings.compress - timings.rename),
|
||||
compress: 1e-3 * (timings.scope - timings.compress),
|
||||
scope: 1e-3 * (timings.mangle - timings.scope),
|
||||
mangle: 1e-3 * (timings.properties - timings.mangle),
|
||||
properties: 1e-3 * (timings.format - timings.properties),
|
||||
format: 1e-3 * (timings.end - timings.format),
|
||||
total: 1e-3 * (timings.end - timings.start)
|
||||
};
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
async function minify(files, options, _fs_module) {
|
||||
const gen = minify_sync_or_async(files, options, _fs_module);
|
||||
|
||||
let yielded;
|
||||
let val;
|
||||
do {
|
||||
val = gen.next(await yielded);
|
||||
yielded = val.value;
|
||||
} while (!val.done);
|
||||
|
||||
return val.value;
|
||||
}
|
||||
|
||||
function minify_sync(files, options, _fs_module) {
|
||||
const gen = minify_sync_or_async(files, options, _fs_module);
|
||||
|
||||
let yielded;
|
||||
let val;
|
||||
do {
|
||||
if (yielded && typeof yielded.then === "function") {
|
||||
throw new Error("minify_sync cannot be used with the legacy source-map module");
|
||||
}
|
||||
val = gen.next(yielded);
|
||||
yielded = val.value;
|
||||
} while (!val.done);
|
||||
|
||||
return val.value;
|
||||
}
|
||||
|
||||
export {
|
||||
minify,
|
||||
minify_sync,
|
||||
to_ascii,
|
||||
};
|
||||
1884
node_modules/terser/lib/mozilla-ast.js
generated
vendored
Normal file
1884
node_modules/terser/lib/mozilla-ast.js
generated
vendored
Normal file
File diff suppressed because it is too large
Load diff
2528
node_modules/terser/lib/output.js
generated
vendored
Normal file
2528
node_modules/terser/lib/output.js
generated
vendored
Normal file
File diff suppressed because it is too large
Load diff
3493
node_modules/terser/lib/parse.js
generated
vendored
Normal file
3493
node_modules/terser/lib/parse.js
generated
vendored
Normal file
File diff suppressed because one or more lines are too long
432
node_modules/terser/lib/propmangle.js
generated
vendored
Normal file
432
node_modules/terser/lib/propmangle.js
generated
vendored
Normal file
|
|
@ -0,0 +1,432 @@
|
|||
/***********************************************************************
|
||||
|
||||
A JavaScript tokenizer / parser / beautifier / compressor.
|
||||
https://github.com/mishoo/UglifyJS2
|
||||
|
||||
-------------------------------- (C) ---------------------------------
|
||||
|
||||
Author: Mihai Bazon
|
||||
<mihai.bazon@gmail.com>
|
||||
http://mihai.bazon.net/blog
|
||||
|
||||
Distributed under the BSD license:
|
||||
|
||||
Copyright 2012 (c) Mihai Bazon <mihai.bazon@gmail.com>
|
||||
|
||||
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";
|
||||
/* global global, self */
|
||||
|
||||
import {
|
||||
defaults,
|
||||
push_uniq,
|
||||
has_annotation,
|
||||
clear_annotation,
|
||||
} from "./utils/index.js";
|
||||
import { base54 } from "./scope.js";
|
||||
import {
|
||||
AST_Binary,
|
||||
AST_Call,
|
||||
AST_ClassPrivateProperty,
|
||||
AST_Conditional,
|
||||
AST_Dot,
|
||||
AST_DotHash,
|
||||
AST_ObjectKeyVal,
|
||||
AST_ObjectProperty,
|
||||
AST_PrivateMethod,
|
||||
AST_PrivateGetter,
|
||||
AST_PrivateSetter,
|
||||
AST_PrivateIn,
|
||||
AST_Sequence,
|
||||
AST_String,
|
||||
AST_Sub,
|
||||
TreeTransformer,
|
||||
TreeWalker,
|
||||
_KEY,
|
||||
_MANGLEPROP,
|
||||
|
||||
walk,
|
||||
} from "./ast.js";
|
||||
import { domprops } from "../tools/domprops.js";
|
||||
|
||||
function find_builtins(reserved) {
|
||||
domprops.forEach(add);
|
||||
|
||||
// Compatibility fix for some standard defined globals not defined on every js environment
|
||||
var new_globals = ["Symbol", "Map", "Promise", "Proxy", "Reflect", "Set", "WeakMap", "WeakSet"];
|
||||
var objects = {};
|
||||
var global_ref = typeof global === "object" ? global : self;
|
||||
|
||||
new_globals.forEach(function (new_global) {
|
||||
objects[new_global] = global_ref[new_global] || function() {};
|
||||
});
|
||||
|
||||
[
|
||||
"null",
|
||||
"true",
|
||||
"false",
|
||||
"NaN",
|
||||
"Infinity",
|
||||
"-Infinity",
|
||||
"undefined",
|
||||
].forEach(add);
|
||||
[ Object, Array, Function, Number,
|
||||
String, Boolean, Error, Math,
|
||||
Date, RegExp, objects.Symbol, ArrayBuffer,
|
||||
DataView, decodeURI, decodeURIComponent,
|
||||
encodeURI, encodeURIComponent, eval, EvalError,
|
||||
Float32Array, Float64Array, Int8Array, Int16Array,
|
||||
Int32Array, isFinite, isNaN, JSON, objects.Map, parseFloat,
|
||||
parseInt, objects.Promise, objects.Proxy, RangeError, ReferenceError,
|
||||
objects.Reflect, objects.Set, SyntaxError, TypeError, Uint8Array,
|
||||
Uint8ClampedArray, Uint16Array, Uint32Array, URIError,
|
||||
objects.WeakMap, objects.WeakSet
|
||||
].forEach(function(ctor) {
|
||||
Object.getOwnPropertyNames(ctor).map(add);
|
||||
if (ctor.prototype) {
|
||||
Object.getOwnPropertyNames(ctor.prototype).map(add);
|
||||
}
|
||||
});
|
||||
function add(name) {
|
||||
reserved.add(name);
|
||||
}
|
||||
}
|
||||
|
||||
function reserve_quoted_keys(ast, reserved) {
|
||||
function add(name) {
|
||||
push_uniq(reserved, name);
|
||||
}
|
||||
|
||||
ast.walk(new TreeWalker(function(node) {
|
||||
if (node instanceof AST_ObjectKeyVal && node.quote) {
|
||||
add(node.key);
|
||||
} else if (node instanceof AST_ObjectProperty && node.quote) {
|
||||
add(node.key.name);
|
||||
} else if (node instanceof AST_Sub) {
|
||||
addStrings(node.property, add);
|
||||
}
|
||||
}));
|
||||
}
|
||||
|
||||
function addStrings(node, add) {
|
||||
node.walk(new TreeWalker(function(node) {
|
||||
if (node instanceof AST_Sequence) {
|
||||
addStrings(node.tail_node(), add);
|
||||
} else if (node instanceof AST_String) {
|
||||
add(node.value);
|
||||
} else if (node instanceof AST_Conditional) {
|
||||
addStrings(node.consequent, add);
|
||||
addStrings(node.alternative, add);
|
||||
}
|
||||
return true;
|
||||
}));
|
||||
}
|
||||
|
||||
function mangle_private_properties(ast, options) {
|
||||
var cprivate = -1;
|
||||
var private_cache = new Map();
|
||||
var nth_identifier = options.nth_identifier || base54;
|
||||
|
||||
ast = ast.transform(new TreeTransformer(function(node) {
|
||||
if (
|
||||
node instanceof AST_ClassPrivateProperty
|
||||
|| node instanceof AST_PrivateMethod
|
||||
|| node instanceof AST_PrivateGetter
|
||||
|| node instanceof AST_PrivateSetter
|
||||
|| node instanceof AST_PrivateIn
|
||||
) {
|
||||
node.key.name = mangle_private(node.key.name);
|
||||
} else if (node instanceof AST_DotHash) {
|
||||
node.property = mangle_private(node.property);
|
||||
}
|
||||
}));
|
||||
return ast;
|
||||
|
||||
function mangle_private(name) {
|
||||
let mangled = private_cache.get(name);
|
||||
if (!mangled) {
|
||||
mangled = nth_identifier.get(++cprivate);
|
||||
private_cache.set(name, mangled);
|
||||
}
|
||||
|
||||
return mangled;
|
||||
}
|
||||
}
|
||||
|
||||
function find_annotated_props(ast) {
|
||||
var annotated_props = new Set();
|
||||
walk(ast, node => {
|
||||
if (
|
||||
node instanceof AST_ClassPrivateProperty
|
||||
|| node instanceof AST_PrivateMethod
|
||||
|| node instanceof AST_PrivateGetter
|
||||
|| node instanceof AST_PrivateSetter
|
||||
|| node instanceof AST_DotHash
|
||||
) {
|
||||
// handled by mangle_private_properties
|
||||
} else if (node instanceof AST_ObjectKeyVal) {
|
||||
if (typeof node.key == "string" && has_annotation(node, _MANGLEPROP)) {
|
||||
annotated_props.add(node.key);
|
||||
}
|
||||
} else if (node instanceof AST_ObjectProperty) {
|
||||
// setter or getter, since KeyVal is handled above
|
||||
if (has_annotation(node, _MANGLEPROP)) {
|
||||
annotated_props.add(node.key.name);
|
||||
}
|
||||
} else if (node instanceof AST_Dot) {
|
||||
if (has_annotation(node, _MANGLEPROP)) {
|
||||
annotated_props.add(node.property);
|
||||
}
|
||||
} else if (node instanceof AST_Sub) {
|
||||
if (node.property instanceof AST_String && has_annotation(node, _MANGLEPROP)) {
|
||||
annotated_props.add(node.property.value);
|
||||
}
|
||||
}
|
||||
});
|
||||
return annotated_props;
|
||||
}
|
||||
|
||||
function mangle_properties(ast, options, annotated_props = find_annotated_props(ast)) {
|
||||
options = defaults(options, {
|
||||
builtins: false,
|
||||
cache: null,
|
||||
debug: false,
|
||||
keep_quoted: false,
|
||||
nth_identifier: base54,
|
||||
only_cache: false,
|
||||
regex: null,
|
||||
reserved: null,
|
||||
undeclared: false,
|
||||
only_annotated: false,
|
||||
}, true);
|
||||
|
||||
var nth_identifier = options.nth_identifier;
|
||||
|
||||
var reserved_option = options.reserved;
|
||||
if (!Array.isArray(reserved_option)) reserved_option = [reserved_option];
|
||||
var reserved = new Set(reserved_option);
|
||||
if (!options.builtins) find_builtins(reserved);
|
||||
|
||||
var cname = -1;
|
||||
|
||||
var cache;
|
||||
if (options.cache) {
|
||||
cache = options.cache.props;
|
||||
} else {
|
||||
cache = new Map();
|
||||
}
|
||||
|
||||
var only_annotated = options.only_annotated;
|
||||
var regex = options.regex && new RegExp(options.regex);
|
||||
|
||||
// note debug is either false (disabled), or a string of the debug suffix to use (enabled).
|
||||
// note debug may be enabled as an empty string, which is falsey. Also treat passing 'true'
|
||||
// the same as passing an empty string.
|
||||
var debug = options.debug !== false;
|
||||
var debug_name_suffix;
|
||||
if (debug) {
|
||||
debug_name_suffix = (options.debug === true ? "" : options.debug);
|
||||
}
|
||||
|
||||
var names_to_mangle = new Set();
|
||||
var unmangleable = new Set();
|
||||
// Track each already-mangled name to prevent nth_identifier from generating
|
||||
// the same name.
|
||||
cache.forEach((mangled_name) => unmangleable.add(mangled_name));
|
||||
|
||||
var keep_quoted = !!options.keep_quoted;
|
||||
|
||||
// step 1: find candidates to mangle
|
||||
ast.walk(new TreeWalker(function(node) {
|
||||
if (
|
||||
node instanceof AST_ClassPrivateProperty
|
||||
|| node instanceof AST_PrivateMethod
|
||||
|| node instanceof AST_PrivateGetter
|
||||
|| node instanceof AST_PrivateSetter
|
||||
|| node instanceof AST_DotHash
|
||||
) {
|
||||
// handled by mangle_private_properties
|
||||
} else if (node instanceof AST_ObjectKeyVal) {
|
||||
if (typeof node.key == "string" && (!keep_quoted || !node.quote)) {
|
||||
add(node.key);
|
||||
}
|
||||
} else if (node instanceof AST_ObjectProperty) {
|
||||
// setter or getter, since KeyVal is handled above
|
||||
if (!keep_quoted || !node.quote) {
|
||||
add(node.key.name);
|
||||
}
|
||||
} else if (node instanceof AST_Dot) {
|
||||
var declared = !!options.undeclared;
|
||||
if (!declared) {
|
||||
var root = node;
|
||||
while (root.expression) {
|
||||
root = root.expression;
|
||||
}
|
||||
declared = !(root.thedef && root.thedef.undeclared);
|
||||
}
|
||||
if (declared &&
|
||||
(!keep_quoted || !node.quote)) {
|
||||
add(node.property);
|
||||
}
|
||||
} else if (node instanceof AST_Sub) {
|
||||
if (!keep_quoted) {
|
||||
addStrings(node.property, add);
|
||||
}
|
||||
} else if (node instanceof AST_Call
|
||||
&& node.expression.print_to_string() == "Object.defineProperty") {
|
||||
addStrings(node.args[1], add);
|
||||
} else if (node instanceof AST_Binary && node.operator === "in") {
|
||||
addStrings(node.left, add);
|
||||
} else if (node instanceof AST_String && has_annotation(node, _KEY)) {
|
||||
add(node.value);
|
||||
}
|
||||
}));
|
||||
|
||||
// step 2: transform the tree, renaming properties
|
||||
return ast.transform(new TreeTransformer(function(node) {
|
||||
if (
|
||||
node instanceof AST_ClassPrivateProperty
|
||||
|| node instanceof AST_PrivateMethod
|
||||
|| node instanceof AST_PrivateGetter
|
||||
|| node instanceof AST_PrivateSetter
|
||||
|| node instanceof AST_DotHash
|
||||
) {
|
||||
// handled by mangle_private_properties
|
||||
} else if (node instanceof AST_ObjectKeyVal) {
|
||||
if (typeof node.key == "string" && (!keep_quoted || !node.quote)) {
|
||||
node.key = mangle(node.key);
|
||||
}
|
||||
} else if (node instanceof AST_ObjectProperty) {
|
||||
// setter, getter, method or class field
|
||||
if (!keep_quoted || !node.quote) {
|
||||
node.key.name = mangle(node.key.name);
|
||||
}
|
||||
} else if (node instanceof AST_Dot) {
|
||||
if (!keep_quoted || !node.quote) {
|
||||
node.property = mangle(node.property);
|
||||
}
|
||||
} else if (!keep_quoted && node instanceof AST_Sub) {
|
||||
node.property = mangleStrings(node.property);
|
||||
} else if (node instanceof AST_Call
|
||||
&& node.expression.print_to_string() == "Object.defineProperty") {
|
||||
node.args[1] = mangleStrings(node.args[1]);
|
||||
} else if (node instanceof AST_Binary && node.operator === "in") {
|
||||
node.left = mangleStrings(node.left);
|
||||
} else if (node instanceof AST_String && has_annotation(node, _KEY)) {
|
||||
// Clear _KEY annotation to prevent double mangling
|
||||
clear_annotation(node, _KEY);
|
||||
node.value = mangle(node.value);
|
||||
}
|
||||
}));
|
||||
|
||||
// only function declarations after this line
|
||||
|
||||
function can_mangle(name) {
|
||||
if (unmangleable.has(name)) return false;
|
||||
if (reserved.has(name)) return false;
|
||||
if (options.only_cache) {
|
||||
return cache.has(name);
|
||||
}
|
||||
if (/^-?[0-9]+(\.[0-9]+)?(e[+-][0-9]+)?$/.test(name)) return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
function should_mangle(name) {
|
||||
if (only_annotated && !annotated_props.has(name)) return false;
|
||||
if (regex && !regex.test(name)) {
|
||||
return annotated_props.has(name);
|
||||
}
|
||||
if (reserved.has(name)) return false;
|
||||
return cache.has(name)
|
||||
|| names_to_mangle.has(name);
|
||||
}
|
||||
|
||||
function add(name) {
|
||||
if (can_mangle(name)) {
|
||||
names_to_mangle.add(name);
|
||||
}
|
||||
|
||||
if (!should_mangle(name)) {
|
||||
unmangleable.add(name);
|
||||
}
|
||||
}
|
||||
|
||||
function mangle(name) {
|
||||
if (!should_mangle(name)) {
|
||||
return name;
|
||||
}
|
||||
|
||||
var mangled = cache.get(name);
|
||||
if (!mangled) {
|
||||
if (debug) {
|
||||
// debug mode: use a prefix and suffix to preserve readability, e.g. o.foo -> o._$foo$NNN_.
|
||||
var debug_mangled = "_$" + name + "$" + debug_name_suffix + "_";
|
||||
|
||||
if (can_mangle(debug_mangled)) {
|
||||
mangled = debug_mangled;
|
||||
}
|
||||
}
|
||||
|
||||
// either debug mode is off, or it is on and we could not use the mangled name
|
||||
if (!mangled) {
|
||||
do {
|
||||
mangled = nth_identifier.get(++cname);
|
||||
} while (!can_mangle(mangled));
|
||||
}
|
||||
|
||||
cache.set(name, mangled);
|
||||
}
|
||||
return mangled;
|
||||
}
|
||||
|
||||
function mangleStrings(node) {
|
||||
return node.transform(new TreeTransformer(function(node) {
|
||||
if (node instanceof AST_Sequence) {
|
||||
var last = node.expressions.length - 1;
|
||||
node.expressions[last] = mangleStrings(node.expressions[last]);
|
||||
} else if (node instanceof AST_String) {
|
||||
// Clear _KEY annotation to prevent double mangling
|
||||
clear_annotation(node, _KEY);
|
||||
node.value = mangle(node.value);
|
||||
} else if (node instanceof AST_Conditional) {
|
||||
node.consequent = mangleStrings(node.consequent);
|
||||
node.alternative = mangleStrings(node.alternative);
|
||||
}
|
||||
return node;
|
||||
}));
|
||||
}
|
||||
}
|
||||
|
||||
export {
|
||||
reserve_quoted_keys,
|
||||
mangle_properties,
|
||||
mangle_private_properties,
|
||||
find_annotated_props,
|
||||
};
|
||||
1066
node_modules/terser/lib/scope.js
generated
vendored
Normal file
1066
node_modules/terser/lib/scope.js
generated
vendored
Normal file
File diff suppressed because it is too large
Load diff
495
node_modules/terser/lib/size.js
generated
vendored
Normal file
495
node_modules/terser/lib/size.js
generated
vendored
Normal file
|
|
@ -0,0 +1,495 @@
|
|||
import {
|
||||
AST_Accessor,
|
||||
AST_Array,
|
||||
AST_Arrow,
|
||||
AST_Await,
|
||||
AST_BigInt,
|
||||
AST_Binary,
|
||||
AST_Block,
|
||||
AST_Break,
|
||||
AST_Call,
|
||||
AST_Case,
|
||||
AST_Class,
|
||||
AST_ClassStaticBlock,
|
||||
AST_ClassPrivateProperty,
|
||||
AST_ClassProperty,
|
||||
AST_ConciseMethod,
|
||||
AST_Conditional,
|
||||
AST_Const,
|
||||
AST_Continue,
|
||||
AST_Debugger,
|
||||
AST_Default,
|
||||
AST_Defun,
|
||||
AST_Destructuring,
|
||||
AST_Directive,
|
||||
AST_Do,
|
||||
AST_Dot,
|
||||
AST_DotHash,
|
||||
AST_EmptyStatement,
|
||||
AST_Expansion,
|
||||
AST_Export,
|
||||
AST_False,
|
||||
AST_For,
|
||||
AST_ForIn,
|
||||
AST_Function,
|
||||
AST_Hole,
|
||||
AST_If,
|
||||
AST_Import,
|
||||
AST_ImportMeta,
|
||||
AST_Infinity,
|
||||
AST_LabeledStatement,
|
||||
AST_Let,
|
||||
AST_NameMapping,
|
||||
AST_NaN,
|
||||
AST_New,
|
||||
AST_NewTarget,
|
||||
AST_Node,
|
||||
AST_Null,
|
||||
AST_Number,
|
||||
AST_Object,
|
||||
AST_ObjectKeyVal,
|
||||
AST_ObjectGetter,
|
||||
AST_ObjectSetter,
|
||||
AST_PrivateGetter,
|
||||
AST_PrivateMethod,
|
||||
AST_PrivateSetter,
|
||||
AST_PrivateIn,
|
||||
AST_RegExp,
|
||||
AST_Return,
|
||||
AST_Sequence,
|
||||
AST_String,
|
||||
AST_Sub,
|
||||
AST_Super,
|
||||
AST_Switch,
|
||||
AST_Symbol,
|
||||
AST_SymbolClassProperty,
|
||||
AST_SymbolExportForeign,
|
||||
AST_SymbolImportForeign,
|
||||
AST_SymbolRef,
|
||||
AST_SymbolDeclaration,
|
||||
AST_TemplateSegment,
|
||||
AST_TemplateString,
|
||||
AST_This,
|
||||
AST_Throw,
|
||||
AST_Toplevel,
|
||||
AST_True,
|
||||
AST_Try,
|
||||
AST_Catch,
|
||||
AST_Finally,
|
||||
AST_Unary,
|
||||
AST_Undefined,
|
||||
AST_Var,
|
||||
AST_VarDef,
|
||||
AST_While,
|
||||
AST_With,
|
||||
AST_Yield,
|
||||
walk_parent
|
||||
} from "./ast.js";
|
||||
import { first_in_statement } from "./utils/first_in_statement.js";
|
||||
|
||||
let mangle_options = undefined;
|
||||
AST_Node.prototype.size = function (compressor, stack) {
|
||||
mangle_options = compressor && compressor._mangle_options;
|
||||
|
||||
let size = 0;
|
||||
walk_parent(this, (node, info) => {
|
||||
size += node._size(info);
|
||||
|
||||
// Braceless arrow functions have fake "return" statements
|
||||
if (node instanceof AST_Arrow && node.is_braceless()) {
|
||||
size += node.body[0].value._size(info);
|
||||
return true;
|
||||
}
|
||||
}, stack || (compressor && compressor.stack));
|
||||
|
||||
// just to save a bit of memory
|
||||
mangle_options = undefined;
|
||||
|
||||
return size;
|
||||
};
|
||||
|
||||
AST_Node.prototype._size = () => 0;
|
||||
|
||||
AST_Debugger.prototype._size = () => 8;
|
||||
|
||||
AST_Directive.prototype._size = function () {
|
||||
// TODO string encoding stuff
|
||||
return 2 + this.value.length;
|
||||
};
|
||||
|
||||
/** Count commas/semicolons necessary to show a list of expressions/statements */
|
||||
const list_overhead = (array) => array.length && array.length - 1;
|
||||
|
||||
AST_Block.prototype._size = function () {
|
||||
return 2 + list_overhead(this.body);
|
||||
};
|
||||
|
||||
AST_Toplevel.prototype._size = function() {
|
||||
return list_overhead(this.body);
|
||||
};
|
||||
|
||||
AST_EmptyStatement.prototype._size = () => 1;
|
||||
|
||||
AST_LabeledStatement.prototype._size = () => 2; // x:
|
||||
|
||||
AST_Do.prototype._size = () => 9;
|
||||
|
||||
AST_While.prototype._size = () => 7;
|
||||
|
||||
AST_For.prototype._size = () => 8;
|
||||
|
||||
AST_ForIn.prototype._size = () => 8;
|
||||
// AST_ForOf inherits ^
|
||||
|
||||
AST_With.prototype._size = () => 6;
|
||||
|
||||
AST_Expansion.prototype._size = () => 3;
|
||||
|
||||
const lambda_modifiers = func =>
|
||||
(func.is_generator ? 1 : 0) + (func.async ? 6 : 0);
|
||||
|
||||
AST_Accessor.prototype._size = function () {
|
||||
return lambda_modifiers(this) + 4 + list_overhead(this.argnames) + list_overhead(this.body);
|
||||
};
|
||||
|
||||
AST_Function.prototype._size = function (info) {
|
||||
const first = !!first_in_statement(info);
|
||||
return (first * 2) + lambda_modifiers(this) + 12 + list_overhead(this.argnames) + list_overhead(this.body);
|
||||
};
|
||||
|
||||
AST_Defun.prototype._size = function () {
|
||||
return lambda_modifiers(this) + 13 + list_overhead(this.argnames) + list_overhead(this.body);
|
||||
};
|
||||
|
||||
AST_Arrow.prototype._size = function () {
|
||||
let args_and_arrow = 2 + list_overhead(this.argnames);
|
||||
|
||||
if (
|
||||
!(
|
||||
this.argnames.length === 1
|
||||
&& this.argnames[0] instanceof AST_Symbol
|
||||
)
|
||||
) {
|
||||
args_and_arrow += 2; // parens around the args
|
||||
}
|
||||
|
||||
const body_overhead = this.is_braceless() ? 0 : list_overhead(this.body) + 2;
|
||||
|
||||
return lambda_modifiers(this) + args_and_arrow + body_overhead;
|
||||
};
|
||||
|
||||
AST_Destructuring.prototype._size = () => 2;
|
||||
|
||||
AST_TemplateString.prototype._size = function () {
|
||||
return 2 + (Math.floor(this.segments.length / 2) * 3); /* "${}" */
|
||||
};
|
||||
|
||||
AST_TemplateSegment.prototype._size = function () {
|
||||
return this.value.length;
|
||||
};
|
||||
|
||||
AST_Return.prototype._size = function () {
|
||||
return this.value ? 7 : 6;
|
||||
};
|
||||
|
||||
AST_Throw.prototype._size = () => 6;
|
||||
|
||||
AST_Break.prototype._size = function () {
|
||||
return this.label ? 6 : 5;
|
||||
};
|
||||
|
||||
AST_Continue.prototype._size = function () {
|
||||
return this.label ? 9 : 8;
|
||||
};
|
||||
|
||||
AST_If.prototype._size = () => 4;
|
||||
|
||||
AST_Switch.prototype._size = function () {
|
||||
return 8 + list_overhead(this.body);
|
||||
};
|
||||
|
||||
AST_Case.prototype._size = function () {
|
||||
return 5 + list_overhead(this.body);
|
||||
};
|
||||
|
||||
AST_Default.prototype._size = function () {
|
||||
return 8 + list_overhead(this.body);
|
||||
};
|
||||
|
||||
AST_Try.prototype._size = () => 3;
|
||||
|
||||
AST_Catch.prototype._size = function () {
|
||||
let size = 7 + list_overhead(this.body);
|
||||
if (this.argname) {
|
||||
size += 2;
|
||||
}
|
||||
return size;
|
||||
};
|
||||
|
||||
AST_Finally.prototype._size = function () {
|
||||
return 7 + list_overhead(this.body);
|
||||
};
|
||||
|
||||
AST_Var.prototype._size = function () {
|
||||
return 4 + list_overhead(this.definitions);
|
||||
};
|
||||
|
||||
AST_Let.prototype._size = function () {
|
||||
return 4 + list_overhead(this.definitions);
|
||||
};
|
||||
|
||||
AST_Const.prototype._size = function () {
|
||||
return 6 + list_overhead(this.definitions);
|
||||
};
|
||||
|
||||
AST_VarDef.prototype._size = function () {
|
||||
return this.value ? 1 : 0;
|
||||
};
|
||||
|
||||
AST_NameMapping.prototype._size = function () {
|
||||
// foreign name isn't mangled
|
||||
return this.name ? 4 : 0;
|
||||
};
|
||||
|
||||
AST_Import.prototype._size = function () {
|
||||
// import
|
||||
let size = 6;
|
||||
|
||||
if (this.imported_name) size += 1;
|
||||
|
||||
// from
|
||||
if (this.imported_name || this.imported_names) size += 5;
|
||||
|
||||
// braces, and the commas
|
||||
if (this.imported_names) {
|
||||
size += 2 + list_overhead(this.imported_names);
|
||||
}
|
||||
|
||||
return size;
|
||||
};
|
||||
|
||||
AST_ImportMeta.prototype._size = () => 11;
|
||||
|
||||
AST_Export.prototype._size = function () {
|
||||
let size = 7 + (this.is_default ? 8 : 0);
|
||||
|
||||
if (this.exported_value) {
|
||||
size += this.exported_value._size();
|
||||
}
|
||||
|
||||
if (this.exported_names) {
|
||||
// Braces and commas
|
||||
size += 2 + list_overhead(this.exported_names);
|
||||
}
|
||||
|
||||
if (this.module_name) {
|
||||
// "from "
|
||||
size += 5;
|
||||
}
|
||||
|
||||
return size;
|
||||
};
|
||||
|
||||
AST_Call.prototype._size = function () {
|
||||
if (this.optional) {
|
||||
return 4 + list_overhead(this.args);
|
||||
}
|
||||
return 2 + list_overhead(this.args);
|
||||
};
|
||||
|
||||
AST_New.prototype._size = function () {
|
||||
return 6 + list_overhead(this.args);
|
||||
};
|
||||
|
||||
AST_Sequence.prototype._size = function () {
|
||||
return list_overhead(this.expressions);
|
||||
};
|
||||
|
||||
AST_Dot.prototype._size = function () {
|
||||
if (this.optional) {
|
||||
return this.property.length + 2;
|
||||
}
|
||||
return this.property.length + 1;
|
||||
};
|
||||
|
||||
AST_DotHash.prototype._size = function () {
|
||||
if (this.optional) {
|
||||
return this.property.length + 3;
|
||||
}
|
||||
return this.property.length + 2;
|
||||
};
|
||||
|
||||
AST_Sub.prototype._size = function () {
|
||||
return this.optional ? 4 : 2;
|
||||
};
|
||||
|
||||
AST_Unary.prototype._size = function () {
|
||||
if (this.operator === "typeof") return 7;
|
||||
if (this.operator === "void") return 5;
|
||||
return this.operator.length;
|
||||
};
|
||||
|
||||
AST_Binary.prototype._size = function (info) {
|
||||
if (this.operator === "in") return 4;
|
||||
|
||||
let size = this.operator.length;
|
||||
|
||||
if (
|
||||
(this.operator === "+" || this.operator === "-")
|
||||
&& this.right instanceof AST_Unary && this.right.operator === this.operator
|
||||
) {
|
||||
// 1+ +a > needs space between the +
|
||||
size += 1;
|
||||
}
|
||||
|
||||
if (this.needs_parens(info)) {
|
||||
size += 2;
|
||||
}
|
||||
|
||||
return size;
|
||||
};
|
||||
|
||||
AST_Conditional.prototype._size = () => 3;
|
||||
|
||||
AST_Array.prototype._size = function () {
|
||||
return 2 + list_overhead(this.elements);
|
||||
};
|
||||
|
||||
AST_Object.prototype._size = function (info) {
|
||||
let base = 2;
|
||||
if (first_in_statement(info)) {
|
||||
base += 2; // parens
|
||||
}
|
||||
return base + list_overhead(this.properties);
|
||||
};
|
||||
|
||||
/*#__INLINE__*/
|
||||
const key_size = key =>
|
||||
typeof key === "string" ? key.length : 0;
|
||||
|
||||
AST_ObjectKeyVal.prototype._size = function () {
|
||||
return key_size(this.key) + 1;
|
||||
};
|
||||
|
||||
/*#__INLINE__*/
|
||||
const static_size = is_static => is_static ? 7 : 0;
|
||||
|
||||
AST_ObjectGetter.prototype._size = function () {
|
||||
return 5 + static_size(this.static) + key_size(this.key);
|
||||
};
|
||||
|
||||
AST_ObjectSetter.prototype._size = function () {
|
||||
return 5 + static_size(this.static) + key_size(this.key);
|
||||
};
|
||||
|
||||
AST_ConciseMethod.prototype._size = function () {
|
||||
return static_size(this.static) + key_size(this.key) + lambda_modifiers(this);
|
||||
};
|
||||
|
||||
AST_PrivateMethod.prototype._size = function () {
|
||||
return AST_ConciseMethod.prototype._size.call(this) + 1;
|
||||
};
|
||||
|
||||
AST_PrivateGetter.prototype._size = AST_PrivateSetter.prototype._size = function () {
|
||||
return AST_ConciseMethod.prototype._size.call(this) + 4;
|
||||
};
|
||||
|
||||
AST_PrivateIn.prototype._size = function () {
|
||||
return 5; // "#", and " in "
|
||||
};
|
||||
|
||||
AST_Class.prototype._size = function () {
|
||||
return (
|
||||
(this.name ? 8 : 7)
|
||||
+ (this.extends ? 8 : 0)
|
||||
);
|
||||
};
|
||||
|
||||
AST_ClassStaticBlock.prototype._size = function () {
|
||||
// "static{}" + semicolons
|
||||
return 8 + list_overhead(this.body);
|
||||
};
|
||||
|
||||
AST_ClassProperty.prototype._size = function () {
|
||||
return (
|
||||
static_size(this.static)
|
||||
+ (typeof this.key === "string" ? this.key.length + 2 : 0)
|
||||
+ (this.value ? 1 : 0)
|
||||
);
|
||||
};
|
||||
|
||||
AST_ClassPrivateProperty.prototype._size = function () {
|
||||
return AST_ClassProperty.prototype._size.call(this) + 1;
|
||||
};
|
||||
|
||||
AST_Symbol.prototype._size = function () {
|
||||
if (!(mangle_options && this.thedef && !this.thedef.unmangleable(mangle_options))) {
|
||||
return this.name.length;
|
||||
} else {
|
||||
return 1;
|
||||
}
|
||||
};
|
||||
|
||||
// TODO take propmangle into account
|
||||
AST_SymbolClassProperty.prototype._size = function () {
|
||||
return this.name.length;
|
||||
};
|
||||
|
||||
AST_SymbolRef.prototype._size = AST_SymbolDeclaration.prototype._size = function () {
|
||||
if (this.name === "arguments") return 9;
|
||||
|
||||
return AST_Symbol.prototype._size.call(this);
|
||||
};
|
||||
|
||||
AST_NewTarget.prototype._size = () => 10;
|
||||
|
||||
AST_SymbolImportForeign.prototype._size = function () {
|
||||
return this.name.length;
|
||||
};
|
||||
|
||||
AST_SymbolExportForeign.prototype._size = function () {
|
||||
return this.name.length;
|
||||
};
|
||||
|
||||
AST_This.prototype._size = () => 4;
|
||||
|
||||
AST_Super.prototype._size = () => 5;
|
||||
|
||||
AST_String.prototype._size = function () {
|
||||
return this.value.length + 2;
|
||||
};
|
||||
|
||||
AST_Number.prototype._size = function () {
|
||||
const { value } = this;
|
||||
if (value === 0) return 1;
|
||||
if (value > 0 && Math.floor(value) === value) {
|
||||
return Math.floor(Math.log10(value) + 1);
|
||||
}
|
||||
return value.toString().length;
|
||||
};
|
||||
|
||||
AST_BigInt.prototype._size = function () {
|
||||
return this.value.length;
|
||||
};
|
||||
|
||||
AST_RegExp.prototype._size = function () {
|
||||
return this.value.toString().length;
|
||||
};
|
||||
|
||||
AST_Null.prototype._size = () => 4;
|
||||
|
||||
AST_NaN.prototype._size = () => 3;
|
||||
|
||||
AST_Undefined.prototype._size = () => 6; // "void 0"
|
||||
|
||||
AST_Hole.prototype._size = () => 0; // comma is taken into account by list_overhead()
|
||||
|
||||
AST_Infinity.prototype._size = () => 8;
|
||||
|
||||
AST_True.prototype._size = () => 4;
|
||||
|
||||
AST_False.prototype._size = () => 5;
|
||||
|
||||
AST_Await.prototype._size = () => 6;
|
||||
|
||||
AST_Yield.prototype._size = () => 6;
|
||||
148
node_modules/terser/lib/sourcemap.js
generated
vendored
Normal file
148
node_modules/terser/lib/sourcemap.js
generated
vendored
Normal file
|
|
@ -0,0 +1,148 @@
|
|||
/***********************************************************************
|
||||
|
||||
A JavaScript tokenizer / parser / beautifier / compressor.
|
||||
https://github.com/mishoo/UglifyJS2
|
||||
|
||||
-------------------------------- (C) ---------------------------------
|
||||
|
||||
Author: Mihai Bazon
|
||||
<mihai.bazon@gmail.com>
|
||||
http://mihai.bazon.net/blog
|
||||
|
||||
Distributed under the BSD license:
|
||||
|
||||
Copyright 2012 (c) Mihai Bazon <mihai.bazon@gmail.com>
|
||||
|
||||
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 {SourceMapConsumer, SourceMapGenerator} from "@jridgewell/source-map";
|
||||
import {defaults, HOP} from "./utils/index.js";
|
||||
|
||||
// a small wrapper around source-map and @jridgewell/source-map
|
||||
function* SourceMap(options) {
|
||||
options = defaults(options, {
|
||||
file : null,
|
||||
root : null,
|
||||
orig : null,
|
||||
files: {},
|
||||
});
|
||||
|
||||
var orig_map;
|
||||
var generator = new SourceMapGenerator({
|
||||
file : options.file,
|
||||
sourceRoot : options.root
|
||||
});
|
||||
|
||||
let sourcesContent = {__proto__: null};
|
||||
let files = options.files;
|
||||
for (var name in files) if (HOP(files, name)) {
|
||||
sourcesContent[name] = files[name];
|
||||
}
|
||||
if (options.orig) {
|
||||
// We support both @jridgewell/source-map (which has a sync
|
||||
// SourceMapConsumer) and source-map (which has an async
|
||||
// SourceMapConsumer).
|
||||
orig_map = yield new SourceMapConsumer(options.orig);
|
||||
if (orig_map.sourcesContent) {
|
||||
orig_map.sources.forEach(function(source, i) {
|
||||
var content = orig_map.sourcesContent[i];
|
||||
if (content) {
|
||||
sourcesContent[source] = content;
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
function add(source, gen_line, gen_col, orig_line, orig_col, name) {
|
||||
let generatedPos = { line: gen_line, column: gen_col };
|
||||
|
||||
if (orig_map) {
|
||||
var info = orig_map.originalPositionFor({
|
||||
line: orig_line,
|
||||
column: orig_col
|
||||
});
|
||||
if (info.source === null) {
|
||||
generator.addMapping({
|
||||
generated: generatedPos,
|
||||
original: null,
|
||||
source: null,
|
||||
name: null
|
||||
});
|
||||
return;
|
||||
}
|
||||
source = info.source;
|
||||
orig_line = info.line;
|
||||
orig_col = info.column;
|
||||
name = info.name || name;
|
||||
}
|
||||
generator.addMapping({
|
||||
generated : generatedPos,
|
||||
original : { line: orig_line, column: orig_col },
|
||||
source : source,
|
||||
name : name
|
||||
});
|
||||
generator.setSourceContent(source, sourcesContent[source]);
|
||||
}
|
||||
|
||||
function clean(map) {
|
||||
const allNull = map.sourcesContent && map.sourcesContent.every(c => c == null);
|
||||
if (allNull) delete map.sourcesContent;
|
||||
if (map.file === undefined) delete map.file;
|
||||
if (map.sourceRoot === undefined) delete map.sourceRoot;
|
||||
return map;
|
||||
}
|
||||
|
||||
function getDecoded() {
|
||||
if (!generator.toDecodedMap) return null;
|
||||
return clean(generator.toDecodedMap());
|
||||
}
|
||||
|
||||
function getEncoded() {
|
||||
return clean(generator.toJSON());
|
||||
}
|
||||
|
||||
function destroy() {
|
||||
// @jridgewell/source-map's SourceMapConsumer does not need to be
|
||||
// manually freed.
|
||||
if (orig_map && orig_map.destroy) orig_map.destroy();
|
||||
}
|
||||
|
||||
return {
|
||||
add,
|
||||
getDecoded,
|
||||
getEncoded,
|
||||
destroy,
|
||||
};
|
||||
}
|
||||
|
||||
export {
|
||||
SourceMap,
|
||||
};
|
||||
323
node_modules/terser/lib/transform.js
generated
vendored
Normal file
323
node_modules/terser/lib/transform.js
generated
vendored
Normal file
|
|
@ -0,0 +1,323 @@
|
|||
/***********************************************************************
|
||||
|
||||
A JavaScript tokenizer / parser / beautifier / compressor.
|
||||
https://github.com/mishoo/UglifyJS2
|
||||
|
||||
-------------------------------- (C) ---------------------------------
|
||||
|
||||
Author: Mihai Bazon
|
||||
<mihai.bazon@gmail.com>
|
||||
http://mihai.bazon.net/blog
|
||||
|
||||
Distributed under the BSD license:
|
||||
|
||||
Copyright 2012 (c) Mihai Bazon <mihai.bazon@gmail.com>
|
||||
|
||||
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 {
|
||||
AST_Array,
|
||||
AST_Await,
|
||||
AST_Binary,
|
||||
AST_PrivateIn,
|
||||
AST_Block,
|
||||
AST_Call,
|
||||
AST_Case,
|
||||
AST_Catch,
|
||||
AST_Chain,
|
||||
AST_Class,
|
||||
AST_ClassStaticBlock,
|
||||
AST_Conditional,
|
||||
AST_Definitions,
|
||||
AST_Destructuring,
|
||||
AST_Do,
|
||||
AST_Exit,
|
||||
AST_Expansion,
|
||||
AST_Export,
|
||||
AST_For,
|
||||
AST_ForIn,
|
||||
AST_If,
|
||||
AST_Import,
|
||||
AST_LabeledStatement,
|
||||
AST_Lambda,
|
||||
AST_LoopControl,
|
||||
AST_NameMapping,
|
||||
AST_Node,
|
||||
AST_Number,
|
||||
AST_Object,
|
||||
AST_ObjectProperty,
|
||||
AST_PrefixedTemplateString,
|
||||
AST_PropAccess,
|
||||
AST_Sequence,
|
||||
AST_SimpleStatement,
|
||||
AST_Sub,
|
||||
AST_Switch,
|
||||
AST_TemplateString,
|
||||
AST_Try,
|
||||
AST_Unary,
|
||||
AST_VarDef,
|
||||
AST_While,
|
||||
AST_With,
|
||||
AST_Yield,
|
||||
} from "./ast.js";
|
||||
import {
|
||||
MAP as do_list,
|
||||
noop,
|
||||
} from "./utils/index.js";
|
||||
|
||||
function def_transform(node, descend) {
|
||||
node.DEFMETHOD("transform", function(tw, in_list) {
|
||||
let transformed = undefined;
|
||||
tw.push(this);
|
||||
if (tw.before) transformed = tw.before(this, descend, in_list);
|
||||
if (transformed === undefined) {
|
||||
transformed = this;
|
||||
descend(transformed, tw);
|
||||
if (tw.after) {
|
||||
const after_ret = tw.after(transformed, in_list);
|
||||
if (after_ret !== undefined) transformed = after_ret;
|
||||
}
|
||||
}
|
||||
tw.pop();
|
||||
return transformed;
|
||||
});
|
||||
}
|
||||
|
||||
def_transform(AST_Node, noop);
|
||||
|
||||
def_transform(AST_LabeledStatement, function(self, tw) {
|
||||
self.label = self.label.transform(tw);
|
||||
self.body = self.body.transform(tw);
|
||||
});
|
||||
|
||||
def_transform(AST_SimpleStatement, function(self, tw) {
|
||||
self.body = self.body.transform(tw);
|
||||
});
|
||||
|
||||
def_transform(AST_Block, function(self, tw) {
|
||||
self.body = do_list(self.body, tw);
|
||||
});
|
||||
|
||||
def_transform(AST_Do, function(self, tw) {
|
||||
self.body = self.body.transform(tw);
|
||||
self.condition = self.condition.transform(tw);
|
||||
});
|
||||
|
||||
def_transform(AST_While, function(self, tw) {
|
||||
self.condition = self.condition.transform(tw);
|
||||
self.body = self.body.transform(tw);
|
||||
});
|
||||
|
||||
def_transform(AST_For, function(self, tw) {
|
||||
if (self.init) self.init = self.init.transform(tw);
|
||||
if (self.condition) self.condition = self.condition.transform(tw);
|
||||
if (self.step) self.step = self.step.transform(tw);
|
||||
self.body = self.body.transform(tw);
|
||||
});
|
||||
|
||||
def_transform(AST_ForIn, function(self, tw) {
|
||||
self.init = self.init.transform(tw);
|
||||
self.object = self.object.transform(tw);
|
||||
self.body = self.body.transform(tw);
|
||||
});
|
||||
|
||||
def_transform(AST_With, function(self, tw) {
|
||||
self.expression = self.expression.transform(tw);
|
||||
self.body = self.body.transform(tw);
|
||||
});
|
||||
|
||||
def_transform(AST_Exit, function(self, tw) {
|
||||
if (self.value) self.value = self.value.transform(tw);
|
||||
});
|
||||
|
||||
def_transform(AST_LoopControl, function(self, tw) {
|
||||
if (self.label) self.label = self.label.transform(tw);
|
||||
});
|
||||
|
||||
def_transform(AST_If, function(self, tw) {
|
||||
self.condition = self.condition.transform(tw);
|
||||
self.body = self.body.transform(tw);
|
||||
if (self.alternative) self.alternative = self.alternative.transform(tw);
|
||||
});
|
||||
|
||||
def_transform(AST_Switch, function(self, tw) {
|
||||
self.expression = self.expression.transform(tw);
|
||||
self.body = do_list(self.body, tw);
|
||||
});
|
||||
|
||||
def_transform(AST_Case, function(self, tw) {
|
||||
self.expression = self.expression.transform(tw);
|
||||
self.body = do_list(self.body, tw);
|
||||
});
|
||||
|
||||
def_transform(AST_Try, function(self, tw) {
|
||||
self.body = self.body.transform(tw);
|
||||
if (self.bcatch) self.bcatch = self.bcatch.transform(tw);
|
||||
if (self.bfinally) self.bfinally = self.bfinally.transform(tw);
|
||||
});
|
||||
|
||||
def_transform(AST_Catch, function(self, tw) {
|
||||
if (self.argname) self.argname = self.argname.transform(tw);
|
||||
self.body = do_list(self.body, tw);
|
||||
});
|
||||
|
||||
def_transform(AST_Definitions, function(self, tw) {
|
||||
self.definitions = do_list(self.definitions, tw);
|
||||
});
|
||||
|
||||
def_transform(AST_VarDef, function(self, tw) {
|
||||
self.name = self.name.transform(tw);
|
||||
if (self.value) self.value = self.value.transform(tw);
|
||||
});
|
||||
|
||||
def_transform(AST_Destructuring, function(self, tw) {
|
||||
self.names = do_list(self.names, tw);
|
||||
});
|
||||
|
||||
def_transform(AST_Lambda, function(self, tw) {
|
||||
if (self.name) self.name = self.name.transform(tw);
|
||||
self.argnames = do_list(self.argnames, tw, /* allow_splicing */ false);
|
||||
if (self.body instanceof AST_Node) {
|
||||
self.body = self.body.transform(tw);
|
||||
} else {
|
||||
self.body = do_list(self.body, tw);
|
||||
}
|
||||
});
|
||||
|
||||
def_transform(AST_Call, function(self, tw) {
|
||||
self.expression = self.expression.transform(tw);
|
||||
self.args = do_list(self.args, tw, /* allow_splicing */ false);
|
||||
});
|
||||
|
||||
def_transform(AST_Sequence, function(self, tw) {
|
||||
const result = do_list(self.expressions, tw);
|
||||
self.expressions = result.length
|
||||
? result
|
||||
: [new AST_Number({ value: 0 })];
|
||||
});
|
||||
|
||||
def_transform(AST_PropAccess, function(self, tw) {
|
||||
self.expression = self.expression.transform(tw);
|
||||
});
|
||||
|
||||
def_transform(AST_Sub, function(self, tw) {
|
||||
self.expression = self.expression.transform(tw);
|
||||
self.property = self.property.transform(tw);
|
||||
});
|
||||
|
||||
def_transform(AST_Chain, function(self, tw) {
|
||||
self.expression = self.expression.transform(tw);
|
||||
});
|
||||
|
||||
def_transform(AST_Yield, function(self, tw) {
|
||||
if (self.expression) self.expression = self.expression.transform(tw);
|
||||
});
|
||||
|
||||
def_transform(AST_Await, function(self, tw) {
|
||||
self.expression = self.expression.transform(tw);
|
||||
});
|
||||
|
||||
def_transform(AST_Unary, function(self, tw) {
|
||||
self.expression = self.expression.transform(tw);
|
||||
});
|
||||
|
||||
def_transform(AST_Binary, function(self, tw) {
|
||||
self.left = self.left.transform(tw);
|
||||
self.right = self.right.transform(tw);
|
||||
});
|
||||
|
||||
def_transform(AST_PrivateIn, function(self, tw) {
|
||||
self.key = self.key.transform(tw);
|
||||
self.value = self.value.transform(tw);
|
||||
});
|
||||
|
||||
def_transform(AST_Conditional, function(self, tw) {
|
||||
self.condition = self.condition.transform(tw);
|
||||
self.consequent = self.consequent.transform(tw);
|
||||
self.alternative = self.alternative.transform(tw);
|
||||
});
|
||||
|
||||
def_transform(AST_Array, function(self, tw) {
|
||||
self.elements = do_list(self.elements, tw);
|
||||
});
|
||||
|
||||
def_transform(AST_Object, function(self, tw) {
|
||||
self.properties = do_list(self.properties, tw);
|
||||
});
|
||||
|
||||
def_transform(AST_ObjectProperty, function(self, tw) {
|
||||
if (self.key instanceof AST_Node) {
|
||||
self.key = self.key.transform(tw);
|
||||
}
|
||||
if (self.value) self.value = self.value.transform(tw);
|
||||
});
|
||||
|
||||
def_transform(AST_Class, function(self, tw) {
|
||||
if (self.name) self.name = self.name.transform(tw);
|
||||
if (self.extends) self.extends = self.extends.transform(tw);
|
||||
self.properties = do_list(self.properties, tw);
|
||||
});
|
||||
|
||||
def_transform(AST_ClassStaticBlock, function(self, tw) {
|
||||
self.body = do_list(self.body, tw);
|
||||
});
|
||||
|
||||
def_transform(AST_Expansion, function(self, tw) {
|
||||
self.expression = self.expression.transform(tw);
|
||||
});
|
||||
|
||||
def_transform(AST_NameMapping, function(self, tw) {
|
||||
self.foreign_name = self.foreign_name.transform(tw);
|
||||
self.name = self.name.transform(tw);
|
||||
});
|
||||
|
||||
def_transform(AST_Import, function(self, tw) {
|
||||
if (self.imported_name) self.imported_name = self.imported_name.transform(tw);
|
||||
if (self.imported_names) do_list(self.imported_names, tw);
|
||||
self.module_name = self.module_name.transform(tw);
|
||||
});
|
||||
|
||||
def_transform(AST_Export, function(self, tw) {
|
||||
if (self.exported_definition) self.exported_definition = self.exported_definition.transform(tw);
|
||||
if (self.exported_value) self.exported_value = self.exported_value.transform(tw);
|
||||
if (self.exported_names) do_list(self.exported_names, tw);
|
||||
if (self.module_name) self.module_name = self.module_name.transform(tw);
|
||||
});
|
||||
|
||||
def_transform(AST_TemplateString, function(self, tw) {
|
||||
self.segments = do_list(self.segments, tw);
|
||||
});
|
||||
|
||||
def_transform(AST_PrefixedTemplateString, function(self, tw) {
|
||||
self.prefix = self.prefix.transform(tw);
|
||||
self.template_string = self.template_string.transform(tw);
|
||||
});
|
||||
|
||||
53
node_modules/terser/lib/utils/first_in_statement.js
generated
vendored
Normal file
53
node_modules/terser/lib/utils/first_in_statement.js
generated
vendored
Normal file
|
|
@ -0,0 +1,53 @@
|
|||
import {
|
||||
AST_Binary,
|
||||
AST_Conditional,
|
||||
AST_Chain,
|
||||
AST_Dot,
|
||||
AST_Object,
|
||||
AST_Sequence,
|
||||
AST_Statement,
|
||||
AST_Sub,
|
||||
AST_UnaryPostfix,
|
||||
AST_PrefixedTemplateString
|
||||
} from "../ast.js";
|
||||
|
||||
// return true if the node at the top of the stack (that means the
|
||||
// innermost node in the current output) is lexically the first in
|
||||
// a statement.
|
||||
function first_in_statement(stack) {
|
||||
let node = stack.parent(-1);
|
||||
for (let i = 0, p; p = stack.parent(i); i++) {
|
||||
if (p instanceof AST_Statement && p.body === node)
|
||||
return true;
|
||||
if ((p instanceof AST_Sequence && p.expressions[0] === node) ||
|
||||
(p.TYPE === "Call" && p.expression === node) ||
|
||||
(p instanceof AST_PrefixedTemplateString && p.prefix === node) ||
|
||||
(p instanceof AST_Dot && p.expression === node) ||
|
||||
(p instanceof AST_Sub && p.expression === node) ||
|
||||
(p instanceof AST_Chain && p.expression === node) ||
|
||||
(p instanceof AST_Conditional && p.condition === node) ||
|
||||
(p instanceof AST_Binary && p.left === node) ||
|
||||
(p instanceof AST_UnaryPostfix && p.expression === node)
|
||||
) {
|
||||
node = p;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Returns whether the leftmost item in the expression is an object
|
||||
function left_is_object(node) {
|
||||
if (node instanceof AST_Object) return true;
|
||||
if (node instanceof AST_Sequence) return left_is_object(node.expressions[0]);
|
||||
if (node.TYPE === "Call") return left_is_object(node.expression);
|
||||
if (node instanceof AST_PrefixedTemplateString) return left_is_object(node.prefix);
|
||||
if (node instanceof AST_Dot || node instanceof AST_Sub) return left_is_object(node.expression);
|
||||
if (node instanceof AST_Chain) return left_is_object(node.expression);
|
||||
if (node instanceof AST_Conditional) return left_is_object(node.condition);
|
||||
if (node instanceof AST_Binary) return left_is_object(node.left);
|
||||
if (node instanceof AST_UnaryPostfix) return left_is_object(node.expression);
|
||||
return false;
|
||||
}
|
||||
|
||||
export { first_in_statement, left_is_object };
|
||||
295
node_modules/terser/lib/utils/index.js
generated
vendored
Normal file
295
node_modules/terser/lib/utils/index.js
generated
vendored
Normal file
|
|
@ -0,0 +1,295 @@
|
|||
/***********************************************************************
|
||||
|
||||
A JavaScript tokenizer / parser / beautifier / compressor.
|
||||
https://github.com/mishoo/UglifyJS2
|
||||
|
||||
-------------------------------- (C) ---------------------------------
|
||||
|
||||
Author: Mihai Bazon
|
||||
<mihai.bazon@gmail.com>
|
||||
http://mihai.bazon.net/blog
|
||||
|
||||
Distributed under the BSD license:
|
||||
|
||||
Copyright 2012 (c) Mihai Bazon <mihai.bazon@gmail.com>
|
||||
|
||||
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 { AST_Node } from "../ast.js";
|
||||
|
||||
function characters(str) {
|
||||
return str.split("");
|
||||
}
|
||||
|
||||
function member(name, array) {
|
||||
return array.includes(name);
|
||||
}
|
||||
|
||||
class DefaultsError extends Error {
|
||||
constructor(msg, defs) {
|
||||
super();
|
||||
|
||||
this.name = "DefaultsError";
|
||||
this.message = msg;
|
||||
this.defs = defs;
|
||||
}
|
||||
}
|
||||
|
||||
function defaults(args, defs, croak) {
|
||||
if (args === true) {
|
||||
args = {};
|
||||
} else if (args != null && typeof args === "object") {
|
||||
args = {...args};
|
||||
}
|
||||
|
||||
const ret = args || {};
|
||||
|
||||
if (croak) for (const i in ret) if (HOP(ret, i) && !HOP(defs, i)) {
|
||||
throw new DefaultsError("`" + i + "` is not a supported option", defs);
|
||||
}
|
||||
|
||||
for (const i in defs) if (HOP(defs, i)) {
|
||||
if (!args || !HOP(args, i)) {
|
||||
ret[i] = defs[i];
|
||||
} else if (i === "ecma") {
|
||||
let ecma = args[i] | 0;
|
||||
if (ecma > 5 && ecma < 2015) ecma += 2009;
|
||||
ret[i] = ecma;
|
||||
} else {
|
||||
ret[i] = (args && HOP(args, i)) ? args[i] : defs[i];
|
||||
}
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
function noop() {}
|
||||
function return_false() { return false; }
|
||||
function return_true() { return true; }
|
||||
function return_this() { return this; }
|
||||
function return_null() { return null; }
|
||||
|
||||
var MAP = (function() {
|
||||
function MAP(a, tw, allow_splicing = true) {
|
||||
const new_a = [];
|
||||
|
||||
for (let i = 0; i < a.length; ++i) {
|
||||
let item = a[i];
|
||||
let ret = item.transform(tw, allow_splicing);
|
||||
|
||||
if (ret instanceof AST_Node) {
|
||||
new_a.push(ret);
|
||||
} else if (ret instanceof Splice) {
|
||||
new_a.push(...ret.v);
|
||||
}
|
||||
}
|
||||
|
||||
return new_a;
|
||||
}
|
||||
|
||||
MAP.splice = function(val) { return new Splice(val); };
|
||||
MAP.skip = {};
|
||||
function Splice(val) { this.v = val; }
|
||||
return MAP;
|
||||
})();
|
||||
|
||||
function make_node(ctor, orig, props) {
|
||||
if (!props) props = {};
|
||||
if (orig) {
|
||||
if (!props.start) props.start = orig.start;
|
||||
if (!props.end) props.end = orig.end;
|
||||
}
|
||||
return new ctor(props);
|
||||
}
|
||||
|
||||
function push_uniq(array, el) {
|
||||
if (!array.includes(el))
|
||||
array.push(el);
|
||||
}
|
||||
|
||||
function string_template(text, props) {
|
||||
return text.replace(/{(.+?)}/g, function(str, p) {
|
||||
return props && props[p];
|
||||
});
|
||||
}
|
||||
|
||||
function remove(array, el) {
|
||||
for (var i = array.length; --i >= 0;) {
|
||||
if (array[i] === el) array.splice(i, 1);
|
||||
}
|
||||
}
|
||||
|
||||
function mergeSort(array, cmp) {
|
||||
if (array.length < 2) return array.slice();
|
||||
function merge(a, b) {
|
||||
var r = [], ai = 0, bi = 0, i = 0;
|
||||
while (ai < a.length && bi < b.length) {
|
||||
cmp(a[ai], b[bi]) <= 0
|
||||
? r[i++] = a[ai++]
|
||||
: r[i++] = b[bi++];
|
||||
}
|
||||
if (ai < a.length) r.push.apply(r, a.slice(ai));
|
||||
if (bi < b.length) r.push.apply(r, b.slice(bi));
|
||||
return r;
|
||||
}
|
||||
function _ms(a) {
|
||||
if (a.length <= 1)
|
||||
return a;
|
||||
var m = Math.floor(a.length / 2), left = a.slice(0, m), right = a.slice(m);
|
||||
left = _ms(left);
|
||||
right = _ms(right);
|
||||
return merge(left, right);
|
||||
}
|
||||
return _ms(array);
|
||||
}
|
||||
|
||||
function makePredicate(words) {
|
||||
if (!Array.isArray(words)) words = words.split(" ");
|
||||
|
||||
return new Set(words.sort());
|
||||
}
|
||||
|
||||
function map_add(map, key, value) {
|
||||
if (map.has(key)) {
|
||||
map.get(key).push(value);
|
||||
} else {
|
||||
map.set(key, [ value ]);
|
||||
}
|
||||
}
|
||||
|
||||
function map_from_object(obj) {
|
||||
var map = new Map();
|
||||
for (var key in obj) {
|
||||
if (HOP(obj, key) && key.charAt(0) === "$") {
|
||||
map.set(key.substr(1), obj[key]);
|
||||
}
|
||||
}
|
||||
return map;
|
||||
}
|
||||
|
||||
function map_to_object(map) {
|
||||
var obj = Object.create(null);
|
||||
map.forEach(function (value, key) {
|
||||
obj["$" + key] = value;
|
||||
});
|
||||
return obj;
|
||||
}
|
||||
|
||||
function HOP(obj, prop) {
|
||||
return Object.prototype.hasOwnProperty.call(obj, prop);
|
||||
}
|
||||
|
||||
function keep_name(keep_setting, name) {
|
||||
return keep_setting === true
|
||||
|| (keep_setting instanceof RegExp && keep_setting.test(name));
|
||||
}
|
||||
|
||||
var lineTerminatorEscape = {
|
||||
"\0": "0",
|
||||
"\n": "n",
|
||||
"\r": "r",
|
||||
"\u2028": "u2028",
|
||||
"\u2029": "u2029",
|
||||
};
|
||||
function regexp_source_fix(source) {
|
||||
// V8 does not escape line terminators in regexp patterns in node 12
|
||||
// We'll also remove literal \0
|
||||
return source.replace(/[\0\n\r\u2028\u2029]/g, function (match, offset) {
|
||||
var escaped = source[offset - 1] == "\\"
|
||||
&& (source[offset - 2] != "\\"
|
||||
|| /(?:^|[^\\])(?:\\{2})*$/.test(source.slice(0, offset - 1)));
|
||||
return (escaped ? "" : "\\") + lineTerminatorEscape[match];
|
||||
});
|
||||
}
|
||||
|
||||
// Subset of regexps that is not going to cause regexp based DDOS
|
||||
// https://owasp.org/www-community/attacks/Regular_expression_Denial_of_Service_-_ReDoS
|
||||
const re_safe_regexp = /^[\\/|\0\s\w^$.[\]()]*$/;
|
||||
|
||||
/** Check if the regexp is safe for Terser to create without risking a RegExp DOS */
|
||||
export const regexp_is_safe = (source) => re_safe_regexp.test(source);
|
||||
|
||||
const all_flags = "dgimsuyv";
|
||||
function sort_regexp_flags(flags) {
|
||||
const existing_flags = new Set(flags.split(""));
|
||||
let out = "";
|
||||
for (const flag of all_flags) {
|
||||
if (existing_flags.has(flag)) {
|
||||
out += flag;
|
||||
existing_flags.delete(flag);
|
||||
}
|
||||
}
|
||||
if (existing_flags.size) {
|
||||
// Flags Terser doesn't know about
|
||||
existing_flags.forEach(flag => { out += flag; });
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
function has_annotation(node, annotation) {
|
||||
return node._annotations & annotation;
|
||||
}
|
||||
|
||||
function set_annotation(node, annotation) {
|
||||
node._annotations |= annotation;
|
||||
}
|
||||
|
||||
function clear_annotation(node, annotation) {
|
||||
node._annotations &= ~annotation;
|
||||
}
|
||||
|
||||
export {
|
||||
characters,
|
||||
defaults,
|
||||
HOP,
|
||||
keep_name,
|
||||
make_node,
|
||||
makePredicate,
|
||||
map_add,
|
||||
map_from_object,
|
||||
map_to_object,
|
||||
MAP,
|
||||
member,
|
||||
mergeSort,
|
||||
noop,
|
||||
push_uniq,
|
||||
regexp_source_fix,
|
||||
remove,
|
||||
return_false,
|
||||
return_null,
|
||||
return_this,
|
||||
return_true,
|
||||
sort_regexp_flags,
|
||||
string_template,
|
||||
has_annotation,
|
||||
set_annotation,
|
||||
clear_annotation,
|
||||
};
|
||||
Loading…
Add table
Add a link
Reference in a new issue