UglifyJS

const UglifyJS = require("uglify-js");

const { minify, parse, Dictionary, TreeWalker, TreeTransformer } = require("uglify-js");

const UglifyJS = require("uglify-js");

// Basic minification
const code = "function add(first, second) { return first + second; }";
const result = UglifyJS.minify(code);

if (result.error) {
    console.error("Error:", result.error);
} else {
    console.log(result.code); // minified output: function add(n,d){return n+d}
}

// Multiple files
const files = {
    "file1.js": "function add(a, b) { return a + b; }",
    "file2.js": "console.log(add(1, 2));"
};
const multiResult = UglifyJS.minify(files);
console.log(multiResult.code);

/**
 * Minify JavaScript code with comprehensive optimization options
 * @param files - Input files: string, array of strings, object with filename keys, or AST_Node
 * @param options - Minification options for parsing, compression, mangling, and output
 * @returns MinifyResult object with code, map, ast, error, warnings, and timings
 */
function minify(files, options);

/**
 * Parse JavaScript source code into AST
 * @param code - JavaScript source code string to parse
 * @param options - Parser configuration options
 * @returns AST_Toplevel node representing the parsed program
 */
function parse(code, options);

const UglifyJS = require("uglify-js");

// Basic parsing
const ast = UglifyJS.parse("function test() { return 42; }");

// Parse with options
const ast2 = UglifyJS.parse("return 42;", {
    bare_returns: true  // Allow return outside functions
});

// Parse as single expression
const expr = UglifyJS.parse("42 + 24", {
    expression: true
});

function TreeWalker(callback);
function TreeTransformer(before, after);
class Dictionary();

function TreeTransformer(before, after);
const List = require("uglify-js").List;
const push_uniq = require("uglify-js").push_uniq;

uglifyjs [input files] [options]

interface MinifyOptions {
  /** Parse options for input processing */
  parse?: ParseOptions;
  /** Compression options (default: {}) */
  compress?: CompressOptions | false;
  /** Name mangling options (default: true) */
  mangle?: MangleOptions | false;
  /** Output formatting options */
  output?: OutputOptions;
  /** Source map generation options */
  sourceMap?: SourceMapOptions | false;
  /** Process as ES module (default: true) */
  module?: boolean;
  /** Enable top-level variable/function mangling */
  toplevel?: boolean;
  /** Cache for mangled names across invocations */
  nameCache?: object;
  /** Return warnings in result.warnings */
  warnings?: boolean | "verbose";
  /** Handle comment annotations (/*@__PURE__*/) */
  annotations?: boolean;
  /** Parse as single expression (e.g., JSON) */
  expression?: boolean;
  /** Enclose output in IIFE with specified arguments */
  enclose?: string[] | false;
  /** Preserve function arguments from mangling */
  keep_fargs?: boolean;
  /** Preserve function names from mangling */
  keep_fnames?: boolean;
  /** Internet Explorer compatibility mode */
  ie?: boolean;
  /** Internet Explorer 8 compatibility mode */
  ie8?: boolean;
  /** Safari/WebKit compatibility mode */
  webkit?: boolean;
  /** Chrome/Node.js compatibility mode */
  v8?: boolean;
  /** Enable timing information collection */
  timings?: boolean;
  /** Enable AST validation */
  validate?: boolean;
  /** Wrap output in a function with specified name */
  wrap?: string | false;
}

interface MinifyResult {
  /** Minified JavaScript code */
  code?: string;
  /** Generated AST (if output.ast is true) */
  ast?: AST_Toplevel;
  /** Source map (if sourceMap option enabled) */
  map?: string;
  /** Runtime error information */
  error?: {
    message: string;
    filename: string;
    line: number;
    col: number;
    pos: number;
  };
  /** Compilation warnings (if warnings option enabled) */
  warnings?: string[];
  /** Timing information (if timings option enabled) */
  timings?: {
    parse: number;
    rename: number;
    compress: number;
    scope: number;
    mangle: number;
    properties: number;
    output: number;
    total: number;
  };
}

interface ParseOptions {
  /** Allow return statements outside functions */
  bare_returns?: boolean;
  /** Parse as single expression (e.g., JSON) */
  expression?: boolean;
  /** Filename for error reporting */
  filename?: string;
  /** Support HTML-style comments */
  html5_comments?: boolean;
  /** Parse as ES module */
  module?: boolean;
  /** Preserve shebang line */
  shebang?: boolean;
  /** Parse in strict mode */
  strict?: boolean;
}

/**
 * Creates a new Dictionary instance
 * @constructor
 */
function Dictionary();

interface Dictionary {
  /** Set a key-value pair */
  set(key: string, value: any): Dictionary;
  /** Get value for key */
  get(key: string): any;
  /** Check if key exists */
  has(key: string): boolean;
  /** Delete a key */
  del(key: string): Dictionary;
  /** Add value to array for key */
  add(key: string, value: any): Dictionary;
  /** Iterate over key-value pairs */
  each(callback: (value: any, key: string) => void): void;
}

/**
 * Add element to array if not already present
 * @param array - Target array
 * @param element - Element to add
 * @returns true if element was added
 */
function push_uniq(array, element);

/**
 * Check if AST node is a statement
 * @param node - AST node to check
 * @returns true if node is a statement
 */
function is_statement(node);

const UglifyJS = require("uglify-js");

// Add unique elements to an array
const deps = [];
UglifyJS.push_uniq(deps, "lodash");   // returns true, added
UglifyJS.push_uniq(deps, "react");    // returns true, added  
UglifyJS.push_uniq(deps, "lodash");   // returns false, already present

// Check if node is a statement
const ast = UglifyJS.parse("var x = 1; x + 2;");
ast.body.forEach(node => {
    console.log(UglifyJS.is_statement(node)); // true, false
});

interface AST_Node {
  /** Start position in source */
  start: {
    line: number;
    col: number;
    pos: number;
  };
  /** End position in source */
  end: {
    line: number;
    col: number;
    pos: number;
  };
  /** Clone the node */
  clone(deep?: boolean): AST_Node;
  /** Transform node using TreeTransformer */
  transform(transformer: TreeTransformer): AST_Node;
  /** Walk through node tree using TreeWalker */
  walk(walker: TreeWalker): void;
}