terser 5.16.1 → 5.17.7

package/lib/compress/index.js

@@ -245,6 +245,7 @@ class Compressor extends TreeWalker {
             keep_fargs    : true,
             keep_fnames   : false,
             keep_infinity : false,
+            lhs_constants : !false_by_default,
             loops         : !false_by_default,
             module        : false,
             negate_iife   : !false_by_default,
@@ -441,6 +442,13 @@ class Compressor extends TreeWalker {
         if (opt === node) set_flag(opt, SQUEEZED);
         return opt;
     }
+
+    /** Alternative to plain is_lhs() which doesn't work within .optimize() */
+    is_lhs() {
+        const self = this.stack[this.stack.length - 1];
+        const parent = this.stack[this.stack.length - 2];
+        return is_lhs(self, parent);
+    }
 }
 
 function def_optimize(node, optimizer) {
@@ -647,8 +655,6 @@ def_optimize(AST_Lambda, opt_AST_Lambda);
 AST_Scope.DEFMETHOD("hoist_declarations", function(compressor) {
     var self = this;
     if (compressor.has_directive("use asm")) return self;
-    // Hoisting makes no sense in an arrow func
-    if (!Array.isArray(self.body)) return self;
 
     var hoist_funs = compressor.option("hoist_funs");
     var hoist_vars = compressor.option("hoist_vars");
@@ -1529,9 +1535,9 @@ def_optimize(AST_Switch, function(self, compressor) {
 });
 
 def_optimize(AST_Try, function(self, compressor) {
-    tighten_body(self.body, compressor);
     if (self.bcatch && self.bfinally && self.bfinally.body.every(is_empty)) self.bfinally = null;
-    if (compressor.option("dead_code") && self.body.every(is_empty)) {
+
+    if (compressor.option("dead_code") && self.body.body.every(is_empty)) {
         var body = [];
         if (self.bcatch) {
             trim_unreachable_code(compressor, self.bcatch, body);
@@ -1544,26 +1550,6 @@ def_optimize(AST_Try, function(self, compressor) {
     return self;
 });
 
-AST_Definitions.DEFMETHOD("remove_initializers", function() {
-    var decls = [];
-    this.definitions.forEach(function(def) {
-        if (def.name instanceof AST_SymbolDeclaration) {
-            def.value = null;
-            decls.push(def);
-        } else {
-            walk(def.name, node => {
-                if (node instanceof AST_SymbolDeclaration) {
-                    decls.push(make_node(AST_VarDef, def, {
-                        name: node,
-                        value: null
-                    }));
-                }
-            });
-        }
-    });
-    this.definitions = decls;
-});
-
 AST_Definitions.DEFMETHOD("to_assignments", function(compressor) {
     var reduce_vars = compressor.option("reduce_vars");
     var assignments = [];
@@ -2131,7 +2117,7 @@ def_optimize(AST_Binary, function(self, compressor) {
             self.right = tmp;
         }
     }
-    if (commutativeOperators.has(self.operator)) {
+    if (compressor.option("lhs_constants") && commutativeOperators.has(self.operator)) {
         if (self.right.is_constant()
             && !self.left.is_constant()) {
             // if right is a constant, whatever side effects the
@@ -2161,6 +2147,9 @@ def_optimize(AST_Binary, function(self, compressor) {
         // void 0 == x => null == x
         if (!is_strict_comparison && is_undefined(self.left, compressor)) {
             self.left = make_node(AST_Null, self.left);
+        // x == void 0 => x == null
+        } else if (!is_strict_comparison && is_undefined(self.right, compressor)) {
+            self.right = make_node(AST_Null, self.right);
         } else if (compressor.option("typeofs")
             // "undefined" == typeof x => undefined === x
             && self.left instanceof AST_String
@@ -2174,6 +2163,19 @@ def_optimize(AST_Binary, function(self, compressor) {
                 self.left = make_node(AST_Undefined, self.left).optimize(compressor);
                 if (self.operator.length == 2) self.operator += "=";
             }
+        } else if (compressor.option("typeofs")
+            // typeof x === "undefined" => x === undefined
+            && self.left instanceof AST_UnaryPrefix
+            && self.left.operator == "typeof"
+            && self.right instanceof AST_String
+            && self.right.value == "undefined") {
+            var expr = self.left.expression;
+            if (expr instanceof AST_SymbolRef ? expr.is_declared(compressor)
+                : !(expr instanceof AST_PropAccess && compressor.option("ie8"))) {
+                self.left = expr;
+                self.right = make_node(AST_Undefined, self.right).optimize(compressor);
+                if (self.operator.length == 2) self.operator += "=";
+            }
         } else if (self.left instanceof AST_SymbolRef
             // obj !== obj => false
             && self.right instanceof AST_SymbolRef
@@ -2602,8 +2604,7 @@ def_optimize(AST_SymbolRef, function(self, compressor) {
         }
     }
 
-    const parent = compressor.parent();
-    if (compressor.option("reduce_vars") && is_lhs(self, parent) !== self) {
+    if (compressor.option("reduce_vars") && !compressor.is_lhs()) {
         return inline_into_symbolref(self, compressor);
     } else {
         return self;
@@ -2627,7 +2628,7 @@ def_optimize(AST_Undefined, function(self, compressor) {
             return ref;
         }
     }
-    var lhs = is_lhs(compressor.self(), compressor.parent());
+    var lhs = compressor.is_lhs();
     if (lhs && is_atomic(lhs, self)) return self;
     return make_node(AST_UnaryPrefix, self, {
         operator: "void",
@@ -2638,7 +2639,7 @@ def_optimize(AST_Undefined, function(self, compressor) {
 });
 
 def_optimize(AST_Infinity, function(self, compressor) {
-    var lhs = is_lhs(compressor.self(), compressor.parent());
+    var lhs = compressor.is_lhs();
     if (lhs && is_atomic(lhs, self)) return self;
     if (
         compressor.option("keep_infinity")
@@ -2659,7 +2660,7 @@ def_optimize(AST_Infinity, function(self, compressor) {
 });
 
 def_optimize(AST_NaN, function(self, compressor) {
-    var lhs = is_lhs(compressor.self(), compressor.parent());
+    var lhs = compressor.is_lhs();
     if (lhs && !is_atomic(lhs, self)
         || find_variable(compressor, "NaN")) {
         return make_node(AST_Binary, self, {
@@ -2737,16 +2738,21 @@ def_optimize(AST_Assign, function(self, compressor) {
     return self;
 
     function in_try(level, node) {
-        var right = self.right;
-        self.right = make_node(AST_Null, right);
-        var may_throw = node.may_throw(compressor);
-        self.right = right;
-        var scope = self.left.definition().scope;
+        function may_assignment_throw() {
+            const right = self.right;
+            self.right = make_node(AST_Null, right);
+            const may_throw = node.may_throw(compressor);
+            self.right = right;
+
+            return may_throw;
+        }
+
+        var stop_at = self.left.definition().scope.get_defun_scope();
         var parent;
-        while ((parent = compressor.parent(level++)) !== scope) {
+        while ((parent = compressor.parent(level++)) !== stop_at) {
             if (parent instanceof AST_Try) {
                 if (parent.bfinally) return true;
-                if (may_throw && parent.bcatch) return true;
+                if (parent.bcatch && may_assignment_throw()) return true;
             }
         }
     }
@@ -2759,8 +2765,21 @@ def_optimize(AST_DefaultAssign, function(self, compressor) {
     var evaluateRight = self.right.evaluate(compressor);
 
     // `[x = undefined] = foo` ---> `[x] = foo`
+    // `(arg = undefined) => ...` ---> `(arg) => ...` (unless `keep_fargs`)
+    // `((arg = undefined) => ...)()` ---> `((arg) => ...)()`
+    let lambda, iife;
     if (evaluateRight === undefined) {
-        self = self.left;
+        if (
+            (lambda = compressor.parent()) instanceof AST_Lambda
+                ? (
+                    compressor.option("keep_fargs") === false
+                    || (iife = compressor.parent(1)).TYPE === "Call"
+                        && iife.expression === lambda
+                )
+                : true
+        ) {
+            self = self.left;
+        }
     } else if (evaluateRight !== self.right) {
         evaluateRight = make_node_from_constant(evaluateRight, self.right);
         self.right = best_of_expression(evaluateRight, self.right);
@@ -3217,7 +3236,10 @@ def_optimize(AST_Sub, function(self, compressor) {
                     }
                 }
             }
-            prop = self.property = best_of_expression(prop, make_node_from_constant(key, prop).transform(compressor));
+            prop = self.property = best_of_expression(
+                prop,
+                make_node_from_constant(key, prop).transform(compressor)
+            );
             var property = "" + key;
             if (is_basic_identifier_string(property)
                 && property.length <= prop.size() + 1) {
@@ -3275,7 +3297,7 @@ def_optimize(AST_Sub, function(self, compressor) {
             return sym;
         }
     }
-    if (is_lhs(self, compressor.parent())) return self;
+    if (compressor.is_lhs()) return self;
     if (key !== prop) {
         var sub = self.flatten_object(property, compressor);
         if (sub) {
@@ -3343,22 +3365,9 @@ def_optimize(AST_Chain, function (self, compressor) {
     return self;
 });
 
-AST_Lambda.DEFMETHOD("contains_this", function() {
-    return walk(this, node => {
-        if (node instanceof AST_This) return walk_abort;
-        if (
-            node !== this
-            && node instanceof AST_Scope
-            && !(node instanceof AST_Arrow)
-        ) {
-            return true;
-        }
-    });
-});
-
 def_optimize(AST_Dot, function(self, compressor) {
     const parent = compressor.parent();
-    if (is_lhs(self, parent)) return self;
+    if (compressor.is_lhs()) return self;
     if (compressor.option("unsafe_proto")
         && self.expression instanceof AST_Dot
         && self.expression.property == "prototype") {

package/lib/compress/inference.js

@@ -45,6 +45,7 @@ import {
   AST_Array,
   AST_Arrow,
   AST_Assign,
+  AST_BigInt,
   AST_Binary,
   AST_Block,
   AST_BlockStatement,
@@ -63,9 +64,11 @@ import {
   AST_EmptyStatement,
   AST_Expansion,
   AST_False,
+  AST_ForIn,
   AST_Function,
   AST_If,
   AST_Import,
+  AST_ImportMeta,
   AST_Jump,
   AST_LabeledStatement,
   AST_Lambda,
@@ -81,6 +84,7 @@ import {
   AST_PropAccess,
   AST_RegExp,
   AST_Return,
+  AST_Scope,
   AST_Sequence,
   AST_SimpleStatement,
   AST_Statement,
@@ -171,7 +175,7 @@ export const unary_side_effects = makePredicate("delete ++ --");
     def_is_number(AST_Number, return_true);
     const unary = makePredicate("+ - ~ ++ --");
     def_is_number(AST_Unary, function() {
-        return unary.has(this.operator);
+        return unary.has(this.operator) && !(this.expression instanceof AST_BigInt);
     });
     const numeric_ops = makePredicate("- * / % & | ^ << >> >>>");
     def_is_number(AST_Binary, function(compressor) {
@@ -300,7 +304,7 @@ export function is_nullish(node, compressor) {
             || any(this.body, compressor);
     });
     def_has_side_effects(AST_Try, function(compressor) {
-        return any(this.body, compressor)
+        return this.body.has_side_effects(compressor)
             || this.bcatch && this.bcatch.has_side_effects(compressor)
             || this.bfinally && this.bfinally.has_side_effects(compressor);
     });
@@ -309,6 +313,7 @@ export function is_nullish(node, compressor) {
             || this.body && this.body.has_side_effects(compressor)
             || this.alternative && this.alternative.has_side_effects(compressor);
     });
+    def_has_side_effects(AST_ImportMeta, return_false);
     def_has_side_effects(AST_LabeledStatement, function(compressor) {
         return this.body.has_side_effects(compressor);
     });
@@ -412,6 +417,7 @@ export function is_nullish(node, compressor) {
     def_may_throw(AST_Lambda, return_false);
     def_may_throw(AST_SymbolDeclaration, return_false);
     def_may_throw(AST_This, return_false);
+    def_may_throw(AST_ImportMeta, return_false);
 
     function any(list, compressor) {
         for (var i = list.length; --i >= 0;)
@@ -529,7 +535,7 @@ export function is_nullish(node, compressor) {
     });
     def_may_throw(AST_SymbolClassProperty, return_false);
     def_may_throw(AST_Try, function(compressor) {
-        return this.bcatch ? this.bcatch.may_throw(compressor) : any(this.body, compressor)
+        return this.bcatch ? this.bcatch.may_throw(compressor) : this.body.may_throw(compressor)
             || this.bfinally && this.bfinally.may_throw(compressor);
     });
     def_may_throw(AST_Unary, function(compressor) {
@@ -708,6 +714,7 @@ export function is_nullish(node, compressor) {
 export function is_lhs(node, parent) {
     if (parent instanceof AST_Unary && unary_side_effects.has(parent.operator)) return parent.expression;
     if (parent instanceof AST_Assign && parent.left === node) return node;
+    if (parent instanceof AST_ForIn && parent.init === node) return node;
 }
 
 (function(def_find_defs) {
@@ -775,6 +782,11 @@ export function is_lhs(node, parent) {
         var name = this.name + suffix;
         if (HOP(defines, name)) return to_node(defines[name], this);
     });
+    def_find_defs(AST_ImportMeta, function(compressor, suffix) {
+        var defines = compressor.option("global_defs");
+        var name = "import.meta" + suffix;
+        if (HOP(defines, name)) return to_node(defines[name], this);
+    });
 })(function(node, func) {
     node.DEFMETHOD("_find_defs", func);
 });
@@ -806,6 +818,9 @@ export function is_lhs(node, parent) {
     def_negate(AST_Function, function() {
         return basic_negation(this);
     });
+    def_negate(AST_Class, function() {
+        return basic_negation(this);
+    });
     def_negate(AST_Arrow, function() {
         return basic_negation(this);
     });
@@ -939,6 +954,19 @@ export const aborts = (thing) => thing && thing.aborts();
     node.DEFMETHOD("aborts", func);
 });
 
+AST_Node.DEFMETHOD("contains_this", function() {
+    return walk(this, node => {
+        if (node instanceof AST_This) return walk_abort;
+        if (
+            node !== this
+            && node instanceof AST_Scope
+            && !(node instanceof AST_Arrow)
+        ) {
+            return true;
+        }
+    });
+});
+
 export function is_modified(compressor, tw, node, value, level, immutable) {
     var parent = tw.parent(level);
     var lhs = is_lhs(node, parent);

package/lib/compress/inline.js

@@ -92,7 +92,6 @@ import "../size.js";
 import "./evaluate.js";
 import "./drop-side-effect-free.js";
 import "./reduce-vars.js";
-import { is_lhs } from "./inference.js";
 import {
     SQUEEZED,
     INLINED,
@@ -114,6 +113,13 @@ import {
     retain_top_func,
 } from "./common.js";
 
+/**
+ * Module that contains the inlining logic.
+ *
+ * @module
+ *
+ * The stars of the show are `inline_into_symbolref` and `inline_into_call`.
+ */
 
 function within_array_or_object_literal(compressor) {
     var node, level = 0;
@@ -144,136 +150,135 @@ function scope_encloses_variables_in_this_scope(scope, pulled_scope) {
 
 export function inline_into_symbolref(self, compressor) {
     const parent = compressor.parent();
-    if (compressor.option("reduce_vars") && is_lhs(self, parent) !== self) {
-        const def = self.definition();
-        const nearest_scope = compressor.find_scope();
-        if (compressor.top_retain && def.global && compressor.top_retain(def)) {
-            def.fixed = false;
-            def.single_use = false;
-            return self;
-        }
 
-        let fixed = self.fixed_value();
-        let single_use = def.single_use
-            && !(parent instanceof AST_Call
-                && (parent.is_callee_pure(compressor))
-                    || has_annotation(parent, _NOINLINE))
-            && !(parent instanceof AST_Export
-                && fixed instanceof AST_Lambda
-                && fixed.name);
-
-        if (single_use && fixed instanceof AST_Node) {
-            single_use =
-                !fixed.has_side_effects(compressor)
-                && !fixed.may_throw(compressor);
-        }
+    const def = self.definition();
+    const nearest_scope = compressor.find_scope();
+    if (compressor.top_retain && def.global && compressor.top_retain(def)) {
+        def.fixed = false;
+        def.single_use = false;
+        return self;
+    }
 
-        if (single_use && (fixed instanceof AST_Lambda || fixed instanceof AST_Class)) {
-            if (retain_top_func(fixed, compressor)) {
-                single_use = false;
-            } else if (def.scope !== self.scope
-                && (def.escaped == 1
-                    || has_flag(fixed, INLINED)
-                    || within_array_or_object_literal(compressor)
-                    || !compressor.option("reduce_funcs"))) {
-                single_use = false;
-            } else if (is_recursive_ref(compressor, def)) {
-                single_use = false;
-            } else if (def.scope !== self.scope || def.orig[0] instanceof AST_SymbolFunarg) {
-                single_use = fixed.is_constant_expression(self.scope);
-                if (single_use == "f") {
-                    var scope = self.scope;
-                    do {
-                        if (scope instanceof AST_Defun || is_func_expr(scope)) {
-                            set_flag(scope, INLINED);
-                        }
-                    } while (scope = scope.parent_scope);
-                }
+    let fixed = self.fixed_value();
+    let single_use = def.single_use
+        && !(parent instanceof AST_Call
+            && (parent.is_callee_pure(compressor))
+                || has_annotation(parent, _NOINLINE))
+        && !(parent instanceof AST_Export
+            && fixed instanceof AST_Lambda
+            && fixed.name);
+
+    if (single_use && fixed instanceof AST_Node) {
+        single_use =
+            !fixed.has_side_effects(compressor)
+            && !fixed.may_throw(compressor);
+    }
+
+    if (single_use && (fixed instanceof AST_Lambda || fixed instanceof AST_Class)) {
+        if (retain_top_func(fixed, compressor)) {
+            single_use = false;
+        } else if (def.scope !== self.scope
+            && (def.escaped == 1
+                || has_flag(fixed, INLINED)
+                || within_array_or_object_literal(compressor)
+                || !compressor.option("reduce_funcs"))) {
+            single_use = false;
+        } else if (is_recursive_ref(compressor, def)) {
+            single_use = false;
+        } else if (def.scope !== self.scope || def.orig[0] instanceof AST_SymbolFunarg) {
+            single_use = fixed.is_constant_expression(self.scope);
+            if (single_use == "f") {
+                var scope = self.scope;
+                do {
+                    if (scope instanceof AST_Defun || is_func_expr(scope)) {
+                        set_flag(scope, INLINED);
+                    }
+                } while (scope = scope.parent_scope);
             }
         }
+    }
 
-        if (single_use && (fixed instanceof AST_Lambda || fixed instanceof AST_Class)) {
-            single_use =
-                def.scope === self.scope
-                    && !scope_encloses_variables_in_this_scope(nearest_scope, fixed)
-                || parent instanceof AST_Call
-                    && parent.expression === self
-                    && !scope_encloses_variables_in_this_scope(nearest_scope, fixed)
-                    && !(fixed.name && fixed.name.definition().recursive_refs > 0);
-        }
+    if (single_use && (fixed instanceof AST_Lambda || fixed instanceof AST_Class)) {
+        single_use =
+            def.scope === self.scope
+                && !scope_encloses_variables_in_this_scope(nearest_scope, fixed)
+            || parent instanceof AST_Call
+                && parent.expression === self
+                && !scope_encloses_variables_in_this_scope(nearest_scope, fixed)
+                && !(fixed.name && fixed.name.definition().recursive_refs > 0);
+    }
 
-        if (single_use && fixed) {
-            if (fixed instanceof AST_DefClass) {
-                set_flag(fixed, SQUEEZED);
-                fixed = make_node(AST_ClassExpression, fixed, fixed);
-            }
-            if (fixed instanceof AST_Defun) {
-                set_flag(fixed, SQUEEZED);
-                fixed = make_node(AST_Function, fixed, fixed);
+    if (single_use && fixed) {
+        if (fixed instanceof AST_DefClass) {
+            set_flag(fixed, SQUEEZED);
+            fixed = make_node(AST_ClassExpression, fixed, fixed);
+        }
+        if (fixed instanceof AST_Defun) {
+            set_flag(fixed, SQUEEZED);
+            fixed = make_node(AST_Function, fixed, fixed);
+        }
+        if (def.recursive_refs > 0 && fixed.name instanceof AST_SymbolDefun) {
+            const defun_def = fixed.name.definition();
+            let lambda_def = fixed.variables.get(fixed.name.name);
+            let name = lambda_def && lambda_def.orig[0];
+            if (!(name instanceof AST_SymbolLambda)) {
+                name = make_node(AST_SymbolLambda, fixed.name, fixed.name);
+                name.scope = fixed;
+                fixed.name = name;
+                lambda_def = fixed.def_function(name);
             }
-            if (def.recursive_refs > 0 && fixed.name instanceof AST_SymbolDefun) {
-                const defun_def = fixed.name.definition();
-                let lambda_def = fixed.variables.get(fixed.name.name);
-                let name = lambda_def && lambda_def.orig[0];
-                if (!(name instanceof AST_SymbolLambda)) {
-                    name = make_node(AST_SymbolLambda, fixed.name, fixed.name);
-                    name.scope = fixed;
-                    fixed.name = name;
-                    lambda_def = fixed.def_function(name);
+            walk(fixed, node => {
+                if (node instanceof AST_SymbolRef && node.definition() === defun_def) {
+                    node.thedef = lambda_def;
+                    lambda_def.references.push(node);
                 }
-                walk(fixed, node => {
-                    if (node instanceof AST_SymbolRef && node.definition() === defun_def) {
-                        node.thedef = lambda_def;
-                        lambda_def.references.push(node);
-                    }
-                });
+            });
+        }
+        if (
+            (fixed instanceof AST_Lambda || fixed instanceof AST_Class)
+            && fixed.parent_scope !== nearest_scope
+        ) {
+            fixed = fixed.clone(true, compressor.get_toplevel());
+
+            nearest_scope.add_child_scope(fixed);
+        }
+        return fixed.optimize(compressor);
+    }
+
+    // multiple uses
+    if (fixed) {
+        let replace;
+
+        if (fixed instanceof AST_This) {
+            if (!(def.orig[0] instanceof AST_SymbolFunarg)
+                && def.references.every((ref) =>
+                    def.scope === ref.scope
+                )) {
+                replace = fixed;
             }
+        } else {
+            var ev = fixed.evaluate(compressor);
             if (
-                (fixed instanceof AST_Lambda || fixed instanceof AST_Class)
-                && fixed.parent_scope !== nearest_scope
+                ev !== fixed
+                && (compressor.option("unsafe_regexp") || !(ev instanceof RegExp))
             ) {
-                fixed = fixed.clone(true, compressor.get_toplevel());
-
-                nearest_scope.add_child_scope(fixed);
+                replace = make_node_from_constant(ev, fixed);
             }
-            return fixed.optimize(compressor);
         }
 
-        // multiple uses
-        if (fixed) {
-            let replace;
+        if (replace) {
+            const name_length = self.size(compressor);
+            const replace_size = replace.size(compressor);
 
-            if (fixed instanceof AST_This) {
-                if (!(def.orig[0] instanceof AST_SymbolFunarg)
-                    && def.references.every((ref) =>
-                        def.scope === ref.scope
-                    )) {
-                    replace = fixed;
-                }
-            } else {
-                var ev = fixed.evaluate(compressor);
-                if (
-                    ev !== fixed
-                    && (compressor.option("unsafe_regexp") || !(ev instanceof RegExp))
-                ) {
-                    replace = make_node_from_constant(ev, fixed);
-                }
+            let overhead = 0;
+            if (compressor.option("unused") && !compressor.exposed(def)) {
+                overhead =
+                    (name_length + 2 + replace_size) /
+                    (def.references.length - def.assignments);
             }
 
-            if (replace) {
-                const name_length = self.size(compressor);
-                const replace_size = replace.size(compressor);
-
-                let overhead = 0;
-                if (compressor.option("unused") && !compressor.exposed(def)) {
-                    overhead =
-                        (name_length + 2 + replace_size) /
-                        (def.references.length - def.assignments);
-                }
-
-                if (replace_size <= name_length + overhead) {
-                    return replace;
-                }
+            if (replace_size <= name_length + overhead) {
+                return replace;
             }
         }
     }

package/lib/compress/native-objects.js

@@ -79,6 +79,9 @@ const object_methods = [
 
 export const is_pure_native_method = make_nested_lookup({
     Array: [
+        "at",
+        "flat",
+        "includes",
         "indexOf",
         "join",
         "lastIndexOf",
@@ -99,22 +102,41 @@ export const is_pure_native_method = make_nested_lookup({
         ...object_methods,
     ],
     String: [
+        "at",
         "charAt",
         "charCodeAt",
+        "charPointAt",
         "concat",
+        "endsWith",
+        "fromCharCode",
+        "fromCodePoint",
+        "includes",
         "indexOf",
         "italics",
         "lastIndexOf",
+        "localeCompare",
         "match",
+        "matchAll",
+        "normalize",
+        "padStart",
+        "padEnd",
+        "repeat",
         "replace",
+        "replaceAll",
         "search",
         "slice",
         "split",
+        "startsWith",
         "substr",
         "substring",
+        "repeat",
+        "toLocaleLowerCase",
+        "toLocaleUpperCase",
         "toLowerCase",
         "toUpperCase",
         "trim",
+        "trimEnd",
+        "trimStart",
         ...object_methods,
     ],
 });