html-minifier-next 1.4.0 → 1.4.2

package/dist/htmlminifier.esm.bundle.js

@@ -26520,6 +26520,8 @@ var RE_BIN_NUMBER = /^0b[01]+$/i;
 var RE_DEC_NUMBER = /^\d*\.?\d*(?:e[+-]?\d*(?:\d\.?|\.?\d)\d*)?$/i;
 var RE_BIG_INT = /^(0[xob])?[0-9a-f]+n$/i;
 
+var RE_KEYWORD_RELATIONAL_OPERATORS = /in(?:stanceof)?/y;
+
 var OPERATORS = makePredicate([
     "in",
     "instanceof",
@@ -26844,6 +26846,56 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
             next();
     }
 
+    function peek_next_token_start_or_newline() {
+        var pos = S.pos;
+        for (var in_multiline_comment = false; pos < S.text.length; ) {
+            var ch = get_full_char(S.text, pos);
+            if (NEWLINE_CHARS.has(ch)) {
+                return { char: ch, pos: pos };
+            } else if (in_multiline_comment) {
+                if (ch == "*" && get_full_char(S.text, pos + 1) == "/") {
+                    pos += 2;
+                    in_multiline_comment = false;
+                } else {
+                    pos++;
+                }
+            } else if (!WHITESPACE_CHARS.has(ch)) {
+                if (ch == "/") {
+                    var next_ch = get_full_char(S.text, pos + 1);
+                    if (next_ch == "/") {
+                        pos = find_eol();
+                        return { char: get_full_char(S.text, pos), pos: pos };
+                    } else if (next_ch == "*") {
+                        in_multiline_comment = true;
+                        pos += 2;
+                        continue;
+                    }
+                }
+                return { char: ch, pos: pos };
+            } else {
+                pos++;
+            }
+        }
+        return { char: null, pos: pos };
+    }
+
+    function ch_starts_binding_identifier(ch, pos) {
+        if (ch == "\\") {
+            return true;
+        } else if (is_identifier_start(ch)) {
+            RE_KEYWORD_RELATIONAL_OPERATORS.lastIndex = pos;
+            if (RE_KEYWORD_RELATIONAL_OPERATORS.test(S.text)) {
+                var after = get_full_char(S.text, RE_KEYWORD_RELATIONAL_OPERATORS.lastIndex);
+                if (!is_identifier_char(after) && after != "\\") {
+                    // "in" or "instanceof" are keywords, not binding identifiers
+                    return false; 
+                }
+            }
+            return true;
+        }
+        return false;
+    }
+
     function read_while(pred) {
         var ret = "", ch, i = 0;
         while ((ch = peek()) && pred(ch, i++))
@@ -27086,7 +27138,8 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
             && (ch >= "a" && ch <= "z" || ch >= "A" && ch <= "Z")
         );
 
-        if (end > start + 1 && ch && ch !== "\\" && !is_identifier_char(ch)) {
+        // 0x7F is very rare in actual code, so we compare it to "~" (0x7E)
+        if (end > start + 1 && ch && ch !== "\\" && !is_identifier_char(ch) && ch <= "~") {
             S.pos += end - start;
             S.col += end - start;
             return S.text.slice(start, S.pos);
@@ -27347,6 +27400,9 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
         return S.directives[directive] > 0;
     };
 
+    next_token.peek_next_token_start_or_newline = peek_next_token_start_or_newline;
+    next_token.ch_starts_binding_identifier = ch_starts_binding_identifier;
+
     return next_token;
 
 }
@@ -27568,10 +27624,6 @@ function parse($TEXT, options) {
             return simple_statement();
 
           case "name":
-          case "privatename":
-            if(is("privatename") && !S.in_class)
-                croak("Private field must be used in an enclosing class");
-
             if (S.token.value == "async" && is_token(peek(), "keyword", "function")) {
                 next();
                 next();
@@ -27586,10 +27638,31 @@ function parse($TEXT, options) {
                 semicolon();
                 return node;
             }
+            if (S.token.value == "using" && is_token(peek(), "name") && !has_newline_before(peek())) {
+                next();
+                var node = using_();
+                semicolon();
+                return node;
+            }
+            if (S.token.value == "await" && can_await() && is_token(peek(), "name", "using") && !has_newline_before(peek())) {
+                var next_next = S.input.peek_next_token_start_or_newline();
+                if (S.input.ch_starts_binding_identifier(next_next.char, next_next.pos)) {
+                    next();
+                    // The "using" token will be consumed by the await_using_ function.
+                    var node = await_using_();
+                    semicolon();
+                    return node;
+                }
+            }
             return is_token(peek(), "punc", ":")
                 ? labeled_statement()
                 : simple_statement();
 
+          case "privatename":
+            if(!S.in_class)
+              croak("Private field must be used in an enclosing class");
+            return simple_statement();
+
           case "punc":
             switch (S.token.value) {
               case "{":
@@ -27814,6 +27887,8 @@ function parse($TEXT, options) {
                 is("keyword", "var") ? (next(), var_(true)) :
                 is("keyword", "let") ? (next(), let_(true)) :
                 is("keyword", "const") ? (next(), const_(true)) :
+                is("name", "using") && is_token(peek(), "name") && (peek().value != "of" || S.input.peek_next_token_start_or_newline().char == "=") ? (next(), using_(true)) :
+                is("name", "await") && can_await() && is_token(peek(), "name", "using") ? (next(), await_using_(true)) :
                                        expression(true, true);
             var is_in = is("operator", "in");
             var is_of = is("name", "of");
@@ -27821,9 +27896,12 @@ function parse($TEXT, options) {
                 token_error(await_tok, for_await_error);
             }
             if (is_in || is_of) {
-                if (init instanceof AST_Definitions) {
+                if (init instanceof AST_DefinitionsLike) {
                     if (init.definitions.length > 1)
                         token_error(init.start, "Only one variable declaration allowed in for..in loop");
+                    if (is_in && init instanceof AST_Using) {
+                        token_error(init.start, "Invalid using declaration in for..in loop");
+                    }
                 } else if (!(is_assignable(init) || (init = to_destructuring(init)) instanceof AST_Destructuring)) {
                     token_error(init.start, "Invalid left-hand side in for..in loop");
                 }
@@ -27855,7 +27933,7 @@ function parse($TEXT, options) {
     }
 
     function for_of(init, is_await) {
-        var lhs = init instanceof AST_Definitions ? init.definitions[0].name : null;
+        var lhs = init instanceof AST_DefinitionsLike ? init.definitions[0].name : null;
         var obj = expression(true);
         expect(")");
         return new AST_ForOf({
@@ -28451,23 +28529,26 @@ function parse($TEXT, options) {
             var sym_type =
                 kind === "var" ? AST_SymbolVar :
                 kind === "const" ? AST_SymbolConst :
-                kind === "let" ? AST_SymbolLet : null;
+                kind === "let" ? AST_SymbolLet :
+                kind === "using" ? AST_SymbolUsing :
+                kind === "await using" ? AST_SymbolUsing : null;
+            var def_type = kind === "using" || kind === "await using" ? AST_UsingDef : AST_VarDef;
             // var { a } = b
             if (is("punc", "{") || is("punc", "[")) {
-                def = new AST_VarDef({
+                def = new def_type({
                     start: S.token,
                     name: binding_element(undefined, sym_type),
                     value: is("operator", "=") ? (expect_token("operator", "="), expression(false, no_in)) : null,
                     end: prev()
                 });
             } else {
-                def = new AST_VarDef({
+                def = new def_type({
                     start : S.token,
                     name  : as_symbol(sym_type),
                     value : is("operator", "=")
                         ? (next(), expression(false, no_in))
-                        : !no_in && kind === "const"
-                            ? croak("Missing initializer in const declaration") : null,
+                        : !no_in && (kind === "const" || kind === "using" || kind === "await using")
+                            ? croak("Missing initializer in " + kind + " declaration") : null,
                     end   : prev()
                 });
                 if (def.name.name == "import") croak("Unexpected token: import");
@@ -28504,6 +28585,25 @@ function parse($TEXT, options) {
         });
     };
 
+    var using_ = function(no_in) {
+        return new AST_Using({
+            start       : prev(),
+            await       : false,
+            definitions : vardefs(no_in, "using"),
+            end         : prev()
+        });
+    };
+
+    var await_using_ = function(no_in) {
+        // Assumption: When await_using_ is called, only the `await` token has been consumed.
+        return new AST_Using({
+            start       : prev(),
+            await       : true,
+            definitions : (next(), vardefs(no_in, "await using")),
+            end         : prev()
+        });
+    };
+
     var new_ = function(allow_calls) {
         var start = S.token;
         expect_token("operator", "new");
@@ -28922,13 +29022,13 @@ function parse($TEXT, options) {
             return name;
         };
 
+        var is_private = prev().type === "privatename";
         const is_not_method_start = () =>
-            !is("punc", "(") && !is("punc", ",") && !is("punc", "}") && !is("punc", ";") && !is("operator", "=");
+            !is("punc", "(") && !is("punc", ",") && !is("punc", "}") && !is("punc", ";") && !is("operator", "=") && !is_private;
 
         var is_async = false;
         var is_static = false;
         var is_generator = false;
-        var is_private = false;
         var accessor_type = null;
 
         if (is_class && name === "static" && is_not_method_start()) {
@@ -28951,7 +29051,7 @@ function parse($TEXT, options) {
             accessor_type = name;
             name = as_property_name();
         }
-        if (prev().type === "privatename") {
+        if (!is_private && prev().type === "privatename") {
             is_private = true;
         }
 
@@ -31180,7 +31280,7 @@ var AST_Finally = DEFNODE("Finally", null, function AST_Finally(props) {
 
 /* -----[ VAR/CONST ]----- */
 
-var AST_Definitions = DEFNODE("Definitions", "definitions", function AST_Definitions(props) {
+var AST_DefinitionsLike = DEFNODE("DefinitionsLike", "definitions", function AST_DefinitionsLike(props) {
     if (props) {
         this.definitions = props.definitions;
         this.start = props.start;
@@ -31189,9 +31289,9 @@ var AST_Definitions = DEFNODE("Definitions", "definitions", function AST_Definit
 
     this.flags = 0;
 }, {
-    $documentation: "Base class for `var` or `const` nodes (variable declarations/initializations)",
+    $documentation: "Base class for variable definitions and `using`",
     $propdoc: {
-        definitions: "[AST_VarDef*] array of variable definitions"
+        definitions: "[AST_VarDef*|AST_UsingDef*] array of variable definitions"
     },
     _walk: function(visitor) {
         return visitor._visit(this, function() {
@@ -31207,6 +31307,18 @@ var AST_Definitions = DEFNODE("Definitions", "definitions", function AST_Definit
     },
 }, AST_Statement);
 
+var AST_Definitions = DEFNODE("Definitions", null, function AST_Definitions(props) {
+    if (props) {
+        this.definitions = props.definitions;
+        this.start = props.start;
+        this.end = props.end;
+    }
+
+    this.flags = 0;
+}, {
+    $documentation: "Base class for `var` or `const` nodes (variable declarations/initializations)",
+}, AST_DefinitionsLike);
+
 var AST_Var = DEFNODE("Var", null, function AST_Var(props) {
     if (props) {
         this.definitions = props.definitions;
@@ -31243,7 +31355,23 @@ var AST_Const = DEFNODE("Const", null, function AST_Const(props) {
     $documentation: "A `const` statement"
 }, AST_Definitions);
 
-var AST_VarDef = DEFNODE("VarDef", "name value", function AST_VarDef(props) {
+var AST_Using = DEFNODE("Using", "await", function AST_Using(props) {
+    if (props) {
+        this.await = props.await;
+        this.definitions = props.definitions;
+        this.start = props.start;
+        this.end = props.end;
+    }
+
+    this.flags = 0;
+}, {
+    $documentation: "A `using` statement",
+    $propdoc: {
+        await: "[boolean] Whether it's `await using`"
+    },
+}, AST_DefinitionsLike);
+
+var AST_VarDefLike = DEFNODE("VarDefLike", "name value", function AST_VarDefLike(props) {
     if (props) {
         this.name = props.name;
         this.value = props.value;
@@ -31253,9 +31381,9 @@ var AST_VarDef = DEFNODE("VarDef", "name value", function AST_VarDef(props) {
 
     this.flags = 0;
 }, {
-    $documentation: "A variable declaration; only appears in a AST_Definitions node",
+    $documentation: "A name=value pair in a variable definition statement or `using`",
     $propdoc: {
-        name: "[AST_Destructuring|AST_SymbolConst|AST_SymbolLet|AST_SymbolVar] name of the variable",
+        name: "[AST_Destructuring|AST_SymbolDeclaration] name of the variable",
         value: "[AST_Node?] initializer, or null of there's no initializer"
     },
     _walk: function(visitor) {
@@ -31270,13 +31398,39 @@ var AST_VarDef = DEFNODE("VarDef", "name value", function AST_VarDef(props) {
     },
     declarations_as_names() {
         if (this.name instanceof AST_SymbolDeclaration) {
-            return [this];
+            return [this.name];
         } else {
             return this.name.all_symbols();
         }
     }
 });
 
+var AST_VarDef = DEFNODE("VarDef", null, function AST_VarDef(props) {
+    if (props) {
+        this.name = props.name;
+        this.value = props.value;
+        this.start = props.start;
+        this.end = props.end;
+    }
+
+    this.flags = 0;
+}, {
+    $documentation: "A variable declaration; only appears in a AST_Definitions node",
+}, AST_VarDefLike);
+
+var AST_UsingDef = DEFNODE("UsingDef", null, function AST_UsingDef(props) {
+    if (props) {
+        this.name = props.name;
+        this.value = props.value;
+        this.start = props.start;
+        this.end = props.end;
+    }
+
+    this.flags = 0;
+}, {
+    $documentation: "Like VarDef but specific to AST_Using",
+}, AST_VarDefLike);
+
 var AST_NameMapping = DEFNODE("NameMapping", "foreign_name name", function AST_NameMapping(props) {
     if (props) {
         this.foreign_name = props.foreign_name;
@@ -32372,6 +32526,21 @@ var AST_SymbolConst = DEFNODE("SymbolConst", null, function AST_SymbolConst(prop
     $documentation: "A constant declaration"
 }, AST_SymbolBlockDeclaration);
 
+var AST_SymbolUsing = DEFNODE("SymbolUsing", null, function AST_SymbolUsing(props) {
+    if (props) {
+        this.init = props.init;
+        this.scope = props.scope;
+        this.name = props.name;
+        this.thedef = props.thedef;
+        this.start = props.start;
+        this.end = props.end;
+    }
+
+    this.flags = 0;
+}, {
+    $documentation: "A `using` declaration"
+}, AST_SymbolBlockDeclaration);
+
 var AST_SymbolLet = DEFNODE("SymbolLet", null, function AST_SymbolLet(props) {
     if (props) {
         this.init = props.init;
@@ -33218,11 +33387,11 @@ def_transform(AST_Catch, function(self, tw) {
     self.body = MAP(self.body, tw);
 });
 
-def_transform(AST_Definitions, function(self, tw) {
+def_transform(AST_DefinitionsLike, function(self, tw) {
     self.definitions = MAP(self.definitions, tw);
 });
 
-def_transform(AST_VarDef, function(self, tw) {
+def_transform(AST_VarDefLike, function(self, tw) {
     self.name = self.name.transform(tw);
     if (self.value) self.value = self.value.transform(tw);
 });
@@ -33757,19 +33926,30 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
 
         VariableDeclaration: function(M) {
             let decl_type;
+            let defs_type = AST_VarDef;
             let sym_type;
+            let await_using = false;
             if (M.kind === "const") {
                 decl_type = AST_Const;
                 sym_type = AST_SymbolConst;
             } else if (M.kind === "let") {
                 decl_type = AST_Let;
                 sym_type = AST_SymbolLet;
+            } else if (M.kind === "using") {
+                decl_type = AST_Using;
+                defs_type = AST_UsingDef;
+                sym_type = AST_SymbolUsing;
+            } else if (M.kind === "await using") {
+                decl_type = AST_Using;
+                defs_type = AST_UsingDef;
+                sym_type = AST_SymbolUsing;
+                await_using = true;
             } else {
                 decl_type = AST_Var;
                 sym_type = AST_SymbolVar;
             }
             const definitions = M.declarations.map(M => {
-                return new AST_VarDef({
+                return new defs_type({
                     start: my_start_token(M),
                     end: my_end_token(M),
                     name: from_moz_pattern(M.id, sym_type),
@@ -33780,6 +33960,7 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
                 start       : my_start_token(M),
                 end         : my_end_token(M),
                 definitions : definitions,
+                await       : await_using,
             });
         },
 
@@ -34379,7 +34560,7 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
             type: "DebuggerStatement"
         };
     });
-    def_to_moz(AST_VarDef, function To_Moz_VariableDeclarator(M) {
+    def_to_moz(AST_VarDefLike, function To_Moz_VariableDeclarator(M) {
         return {
             type: "VariableDeclarator",
             id: to_moz(M.name),
@@ -34595,12 +34776,14 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
         };
     });
 
-    def_to_moz(AST_Definitions, function To_Moz_VariableDeclaration(M) {
+    def_to_moz(AST_DefinitionsLike, function To_Moz_VariableDeclaration(M) {
         return {
             type: "VariableDeclaration",
             kind:
                 M instanceof AST_Const ? "const" :
-                M instanceof AST_Let ? "let" : "var",
+                M instanceof AST_Let ? "let" :
+                M instanceof AST_Using ? (M.await ? "await using" : "using") :
+                "var",
             declarations: M.definitions.map(to_moz)
         };
     });
@@ -36271,7 +36454,7 @@ function OutputStream(options) {
         return p instanceof AST_Call                          // (foo, bar)() or foo(1, (2, 3), 4)
             || p instanceof AST_Unary                         // !(foo, bar, baz)
             || p instanceof AST_Binary                        // 1 + (2, 3) + 4 ==> 8
-            || p instanceof AST_VarDef                        // var a = (1, 2), b = a + a; ==> b == 4
+            || p instanceof AST_VarDefLike                    // var a = (1, 2), b = a + a; ==> b == 4
             || p instanceof AST_PropAccess                    // (1, {foo:2}).foo or (1, {foo:2})["foo"] ==> 2
             || p instanceof AST_Array                         // [ 1, (2, 3), 4 ] ==> [ 1, 3, 4 ]
             || p instanceof AST_ObjectProperty                // { foo: (1, 2) }.foo ==> 2
@@ -36603,7 +36786,7 @@ function OutputStream(options) {
         output.space();
         output.with_parens(function() {
             if (self.init) {
-                if (self.init instanceof AST_Definitions) {
+                if (self.init instanceof AST_DefinitionsLike) {
                     self.init.print(output);
                 } else {
                     parenthesize_for_noin(self.init, output, true);
@@ -36963,7 +37146,7 @@ function OutputStream(options) {
     });
 
     /* -----[ var/const ]----- */
-    AST_Definitions.DEFMETHOD("_do_print", function(output, kind) {
+    AST_DefinitionsLike.DEFMETHOD("_do_print", function(output, kind) {
         output.print(kind);
         output.space();
         this.definitions.forEach(function(def, i) {
@@ -36985,6 +37168,9 @@ function OutputStream(options) {
     DEFPRINT(AST_Const, function(self, output) {
         self._do_print(output, "const");
     });
+    DEFPRINT(AST_Using, function(self, output) {
+        self._do_print(output, self.await ? "await using" : "using");
+    });
     DEFPRINT(AST_Import, function(self, output) {
         output.print("import");
         output.space();
@@ -37152,7 +37338,7 @@ function OutputStream(options) {
         node.print(output, parens);
     }
 
-    DEFPRINT(AST_VarDef, function(self, output) {
+    DEFPRINT(AST_VarDefLike, function(self, output) {
         self.name.print(output);
         if (self.value) {
             output.space();
@@ -37628,7 +37814,7 @@ function OutputStream(options) {
         } else {
             if (!stat || stat instanceof AST_EmptyStatement)
                 output.force_semicolon();
-            else if (stat instanceof AST_Let || stat instanceof AST_Const || stat instanceof AST_Class)
+            else if ((stat instanceof AST_DefinitionsLike && !(stat instanceof AST_Var)) || stat instanceof AST_Class)
                 make_block(stat, output);
             else
                 stat.print(output);
@@ -37708,7 +37894,7 @@ function OutputStream(options) {
         AST_Class,
         AST_Constant,
         AST_Debugger,
-        AST_Definitions,
+        AST_DefinitionsLike,
         AST_Directive,
         AST_Finally,
         AST_Jump,
@@ -37871,9 +38057,9 @@ AST_Catch.prototype.shallow_cmp = function(other) {
 
 AST_Finally.prototype.shallow_cmp = pass_through;
 
-AST_Definitions.prototype.shallow_cmp = pass_through;
+AST_DefinitionsLike.prototype.shallow_cmp = pass_through;
 
-AST_VarDef.prototype.shallow_cmp = function(other) {
+AST_VarDefLike.prototype.shallow_cmp = function(other) {
     return this.value == null ? other.value == null : this.value === other.value;
 };
 
@@ -38243,6 +38429,7 @@ AST_Scope.DEFMETHOD("figure_out_scope", function(options, { parent_scope = undef
             node instanceof AST_SymbolVar
             || node instanceof AST_SymbolLet
             || node instanceof AST_SymbolConst
+            || node instanceof AST_SymbolUsing
             || node instanceof AST_SymbolCatch
         ) {
             var def;
@@ -38256,7 +38443,7 @@ AST_Scope.DEFMETHOD("figure_out_scope", function(options, { parent_scope = undef
                 if (node instanceof AST_SymbolBlockDeclaration) {
                     return sym instanceof AST_SymbolLambda;
                 }
-                return !(sym instanceof AST_SymbolLet || sym instanceof AST_SymbolConst);
+                return !(sym instanceof AST_SymbolLet || sym instanceof AST_SymbolConst || sym instanceof AST_SymbolUsing);
             })) {
                 js_error(
                     `"${node.name}" is redeclared`,
@@ -39136,7 +39323,12 @@ AST_Const.prototype._size = function () {
     return 6 + list_overhead(this.definitions);
 };
 
-AST_VarDef.prototype._size = function () {
+AST_Using.prototype._size = function () {
+    const await_size = this.await ? 6 : 0;
+    return await_size + 6 + list_overhead(this.definitions);
+};
+
+AST_VarDefLike.prototype._size = function () {
     return this.value ? 1 : 0;
 };
 
@@ -39607,7 +39799,7 @@ function get_simple_key(key) {
     if (key instanceof AST_UnaryPrefix
         && key.operator == "void"
         && key.expression instanceof AST_Constant) {
-        return;
+        return undefined;
     }
     return key;
 }
@@ -39717,6 +39909,7 @@ function can_be_evicted_from_block(node) {
         node instanceof AST_Defun ||
         node instanceof AST_Let ||
         node instanceof AST_Const ||
+        node instanceof AST_Using ||
         node instanceof AST_Export ||
         node instanceof AST_Import
     );
@@ -42476,7 +42669,7 @@ function mark_escaped(tw, d, scope, node, value, level = 0, depth = 1) {
         parent instanceof AST_Assign && (parent.operator === "=" || parent.logical) && node === parent.right
         || parent instanceof AST_Call && (node !== parent.expression || parent instanceof AST_New)
         || parent instanceof AST_Exit && node === parent.value && node.scope !== d.scope
-        || parent instanceof AST_VarDef && node === parent.value
+        || parent instanceof AST_VarDefLike && node === parent.value
         || parent instanceof AST_Yield && node === parent.value && node.scope !== d.scope
     ) {
         if (depth > 1 && !(value && value.is_constant_expression(scope))) depth = 1;
@@ -42859,7 +43052,7 @@ function handle_defined_after_hoist(parent) {
 
     // Refine `defun_first_read_map` to be as high as possible
     for (const [defun, defun_first_read] of defun_first_read_map) {
-        // Update all depdencies of `defun`
+        // Update all dependencies of `defun`
         const queue = new Set(defun_dependencies_map.get(defun));
         for (const enclosed_defun of queue) {
             let enclosed_defun_first_read = defun_first_read_map.get(enclosed_defun);
@@ -43088,6 +43281,10 @@ def_reduce_vars(AST_VarDef, function(tw, descend) {
     }
 });
 
+def_reduce_vars(AST_UsingDef, function() {
+    suppress(this.name);
+});
+
 def_reduce_vars(AST_While, function(tw, descend, compressor) {
     reset_block_variables(compressor, this);
     const saved_loop = tw.in_loop;
@@ -43296,6 +43493,7 @@ function tighten_body(statements, compressor) {
             if (node instanceof AST_Assign
                     && (node.logical || node.operator != "=" && lhs.equivalent_to(node.left))
                 || node instanceof AST_Await
+                || node instanceof AST_Using
                 || node instanceof AST_Call && lhs instanceof AST_PropAccess && lhs.equivalent_to(node.expression)
                 ||
                     (node instanceof AST_Call || node instanceof AST_PropAccess)
@@ -43394,6 +43592,7 @@ function tighten_body(statements, compressor) {
                 && ((lvalues.has(node.name) && lvalues.get(node.name).modified) || side_effects && may_modify(node))
                 || node instanceof AST_VarDef && node.value
                 && (lvalues.has(node.name.name) || side_effects && may_modify(node.name))
+                || node instanceof AST_Using
                 || (sym = is_lhs(node.left, node))
                 && (sym instanceof AST_PropAccess || lvalues.has(sym.name))
                 || may_throw
@@ -43808,7 +44007,9 @@ function tighten_body(statements, compressor) {
                     ? expr.left
                     : expr.expression;
                 return !is_ref_of(lhs, AST_SymbolConst)
-                    && !is_ref_of(lhs, AST_SymbolLet) && lhs;
+                    && !is_ref_of(lhs, AST_SymbolLet)
+                    && !is_ref_of(lhs, AST_SymbolUsing)
+                    && lhs;
             }
         }
 
@@ -44143,7 +44344,7 @@ function tighten_body(statements, compressor) {
                 return false;
             for (var j = i + 1, len = statements.length; j < len; j++) {
                 var stat = statements[j];
-                if (stat instanceof AST_Const || stat instanceof AST_Let)
+                if (stat instanceof AST_DefinitionsLike && !(stat instanceof AST_Var))
                     return false;
             }
             var lct = ab instanceof AST_LoopControl ? compressor.loopcontrol_target(ab) : null;
@@ -44283,7 +44484,7 @@ function tighten_body(statements, compressor) {
             var line = block.body[i];
             if (line instanceof AST_Var && declarations_only(line)) {
                 decls.push(line);
-            } else if (stat || line instanceof AST_Const || line instanceof AST_Let) {
+            } else if (stat || line instanceof AST_DefinitionsLike && !(line instanceof AST_Var)) {
                 return false;
             } else {
                 stat = line;
@@ -44306,7 +44507,7 @@ function tighten_body(statements, compressor) {
                 if (stat instanceof AST_Exit) {
                     stat.value = cons_seq(stat.value || make_node(AST_Undefined, stat).transform(compressor));
                 } else if (stat instanceof AST_For) {
-                    if (!(stat.init instanceof AST_Definitions)) {
+                    if (!(stat.init instanceof AST_DefinitionsLike)) {
                         const abort = walk(prev.body, node => {
                             if (node instanceof AST_Scope)
                                 return true;
@@ -44326,7 +44527,7 @@ function tighten_body(statements, compressor) {
                         }
                     }
                 } else if (stat instanceof AST_ForIn) {
-                    if (!(stat.init instanceof AST_Const) && !(stat.init instanceof AST_Let)) {
+                    if (!(stat.init instanceof AST_DefinitionsLike) || stat.init instanceof AST_Var) {
                         stat.object = cons_seq(stat.object);
                     }
                 } else if (stat instanceof AST_If) {
@@ -44443,6 +44644,12 @@ function tighten_body(statements, compressor) {
                     statements[++j] = stat;
                     defs = stat;
                 }
+            } else if (
+                stat instanceof AST_Using
+                && prev instanceof AST_Using
+                && prev.await === stat.await
+            ) {
+                prev.definitions = prev.definitions.concat(stat.definitions);
             } else if (stat instanceof AST_Exit) {
                 stat.value = extract_object_assignments(stat.value);
             } else if (stat instanceof AST_For) {
@@ -45733,6 +45940,7 @@ function can_be_extracted_from_if_block(node) {
     return !(
         node instanceof AST_Const
         || node instanceof AST_Let
+        || node instanceof AST_Using
         || node instanceof AST_Class
     );
 }
@@ -45911,6 +46119,7 @@ AST_Scope.DEFMETHOD("hoist_properties", function(compressor) {
             let def;
             let value;
             if (sym.scope === self
+                && !(sym instanceof AST_SymbolUsing)
                 && (def = sym.definition()).escaped != 1
                 && !def.assignments
                 && !def.direct_access
@@ -59916,7 +60125,7 @@ class CaseInsensitiveSet extends Set {
   }
 }
 
-// Regular Expressions for parsing tags and attributes
+// Regular expressions for parsing tags and attributes
 const singleAttrIdentifier = /([^\s"'<>/=]+)/;
 const singleAttrAssigns = [/=/];
 const singleAttrValues = [
@@ -59947,10 +60156,10 @@ let IS_REGEX_CAPTURING_BROKEN = false;
   IS_REGEX_CAPTURING_BROKEN = g === '';
 });
 
-// Empty Elements
+// Empty elements
 const empty = new CaseInsensitiveSet(['area', 'base', 'basefont', 'br', 'col', 'embed', 'frame', 'hr', 'img', 'input', 'isindex', 'keygen', 'link', 'meta', 'param', 'source', 'track', 'wbr']);
 
-// Inline Elements
+// Inline elements
 const inline = new CaseInsensitiveSet(['a', 'abbr', 'acronym', 'applet', 'b', 'basefont', 'bdo', 'big', 'br', 'button', 'cite', 'code', 'del', 'dfn', 'em', 'font', 'i', 'iframe', 'img', 'input', 'ins', 'kbd', 'label', 'map', 'noscript', 'object', 'q', 's', 'samp', 'script', 'select', 'small', 'span', 'strike', 'strong', 'sub', 'sup', 'svg', 'textarea', 'tt', 'u', 'var']);
 
 // Elements that you can, intentionally, leave open
@@ -59960,10 +60169,10 @@ const closeSelf = new CaseInsensitiveSet(['colgroup', 'dd', 'dt', 'li', 'option'
 // Attributes that have their values filled in disabled='disabled'
 const fillAttrs = new CaseInsensitiveSet(['checked', 'compact', 'declare', 'defer', 'disabled', 'ismap', 'multiple', 'nohref', 'noresize', 'noshade', 'nowrap', 'readonly', 'selected']);
 
-// Special Elements (can contain anything)
+// Special elements (can contain anything)
 const special = new CaseInsensitiveSet(['script', 'style']);
 
-// HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
+// HTML5 elements https://html.spec.whatwg.org/multipage/indices.html#elements-3
 // Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
 const nonPhrasing = new CaseInsensitiveSet(['address', 'article', 'aside', 'base', 'blockquote', 'body', 'caption', 'col', 'colgroup', 'dd', 'details', 'dialog', 'div', 'dl', 'dt', 'fieldset', 'figcaption', 'figure', 'footer', 'form', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'head', 'header', 'hgroup', 'hr', 'html', 'legend', 'li', 'menuitem', 'meta', 'ol', 'optgroup', 'option', 'param', 'rp', 'rt', 'source', 'style', 'summary', 'tbody', 'td', 'tfoot', 'th', 'thead', 'title', 'tr', 'track', 'ul']);
 
@@ -60011,7 +60220,7 @@ class HTMLParser {
     let last, prevTag, nextTag;
     while (html) {
       last = html;
-      // Make sure we're not in a script or style element
+      // Make sure we’re not in a `script` or `style` element
       if (!lastTag || !special.has(lastTag)) {
         let textEnd = html.indexOf('<');
         if (textEnd === 0) {
@@ -60087,7 +60296,7 @@ class HTMLParser {
           html = '';
         }
 
-        // next tag
+        // Next tag
         let nextTagMatch = parseStartTag(html);
         if (nextTagMatch) {
           nextTag = nextTagMatch.tagName;
@@ -60200,9 +60409,9 @@ class HTMLParser {
 
       const attrs = match.attrs.map(function (args) {
         let name, value, customOpen, customClose, customAssign, quote;
-        const ncp = 7; // number of captured parts, scalar
+        const ncp = 7; // Number of captured parts, scalar
 
-        // hackish work around FF bug https://bugzilla.mozilla.org/show_bug.cgi?id=369778
+        // Hackish workaround for FF bug https://bugzilla.mozilla.org/show_bug.cgi?id=369778
         if (IS_REGEX_CAPTURING_BROKEN && args[0].indexOf('""') === -1) {
           if (args[3] === '') { delete args[3]; }
           if (args[4] === '') { delete args[4]; }
@@ -60424,28 +60633,28 @@ function collapseWhitespace(str, options, trimLeft, trimRight, collapseAll) {
   }
 
   if (collapseAll) {
-    // strip non space whitespace then compress spaces to one
+    // Strip non-space whitespace then compress spaces to one
     str = collapseWhitespaceAll(str);
   }
 
   return lineBreakBefore + str + lineBreakAfter;
 }
 
-// non-empty elements that will maintain whitespace around them
-const inlineHtmlElements = ['a', 'abbr', 'acronym', 'b', 'bdi', 'bdo', 'big', 'button', 'cite', 'code', 'del', 'dfn', 'em', 'font', 'i', 'img', 'input', 'ins', 'kbd', 'label', 'mark', 'math', 'meter', 'nobr', 'object', 'output', 'progress', 'q', 'rp', 'rt', 'rtc', 'ruby', 's', 'samp', 'select', 'small', 'span', 'strike', 'strong', 'sub', 'sup', 'svg', 'textarea', 'time', 'tt', 'u', 'var', 'wbr'];
-// non-empty elements that will maintain whitespace within them
-const inlineTextTags = new Set(['a', 'abbr', 'acronym', 'b', 'big', 'del', 'em', 'font', 'i', 'ins', 'kbd', 'mark', 'nobr', 'rp', 's', 'samp', 'small', 'span', 'strike', 'strong', 'sub', 'sup', 'time', 'tt', 'u', 'var']);
-// self-closing elements that will maintain whitespace around them
-const selfClosingInlineTags = new Set(['comment', 'img', 'input', 'wbr']);
+// Non-empty elements that will maintain whitespace around them
+const inlineElementsToKeepWhitespaceAround = ['a', 'abbr', 'acronym', 'b', 'bdi', 'bdo', 'big', 'button', 'cite', 'code', 'del', 'dfn', 'em', 'font', 'i', 'img', 'input', 'ins', 'kbd', 'label', 'mark', 'math', 'meter', 'nobr', 'object', 'output', 'progress', 'q', 'rp', 'rt', 'rtc', 'ruby', 's', 'samp', 'select', 'small', 'span', 'strike', 'strong', 'sub', 'sup', 'svg', 'textarea', 'time', 'tt', 'u', 'var', 'wbr'];
+// Non-empty elements that will maintain whitespace within them
+const inlineElementsToKeepWhitespaceWithin = new Set(['a', 'abbr', 'acronym', 'b', 'big', 'del', 'em', 'font', 'i', 'ins', 'kbd', 'mark', 'nobr', 'rp', 's', 'samp', 'small', 'span', 'strike', 'strong', 'sub', 'sup', 'time', 'tt', 'u', 'var']);
+// Elements that will always maintain whitespace around them
+const inlineElementsToKeepWhitespace = new Set(['comment', 'img', 'input', 'wbr']);
 
-function collapseWhitespaceSmart(str, prevTag, nextTag, options, inlineTags) {
-  let trimLeft = prevTag && !selfClosingInlineTags.has(prevTag);
+function collapseWhitespaceSmart(str, prevTag, nextTag, options, inlineElements, inlineTextSet) {
+  let trimLeft = prevTag && !inlineElementsToKeepWhitespace.has(prevTag);
   if (trimLeft && !options.collapseInlineTagWhitespace) {
-    trimLeft = prevTag.charAt(0) === '/' ? !inlineTags.has(prevTag.slice(1)) : !inlineTextTags.has(prevTag);
+    trimLeft = prevTag.charAt(0) === '/' ? !inlineElements.has(prevTag.slice(1)) : !inlineTextSet.has(prevTag);
   }
-  let trimRight = nextTag && !selfClosingInlineTags.has(nextTag);
+  let trimRight = nextTag && !inlineElementsToKeepWhitespace.has(nextTag);
   if (trimRight && !options.collapseInlineTagWhitespace) {
-    trimRight = nextTag.charAt(0) === '/' ? !inlineTextTags.has(nextTag.slice(1)) : !inlineTags.has(nextTag);
+    trimRight = nextTag.charAt(0) === '/' ? !inlineTextSet.has(nextTag.slice(1)) : !inlineElements.has(nextTag);
   }
   return collapseWhitespace(str, options, trimLeft, trimRight, prevTag && nextTag);
 }
@@ -60632,7 +60841,7 @@ function isSrcset(attrName, tag) {
   return attrName === 'srcset' && srcsetTags.has(tag);
 }
 
-async function cleanAttributeValue(tag, attrName, attrValue, options, attrs) {
+async function cleanAttributeValue(tag, attrName, attrValue, options, attrs, minifyHTMLSelf) {
   if (isEventAttribute(attrName, options)) {
     attrValue = trimWhitespace(attrValue).replace(/^javascript:\s*/i, '');
     return options.minifyJS(attrValue, true);
@@ -60690,6 +60899,13 @@ async function cleanAttributeValue(tag, attrName, attrValue, options, attrs) {
   } else if (isMediaQuery(tag, attrs, attrName)) {
     attrValue = trimWhitespace(attrValue);
     return options.minifyCSS(attrValue, 'media');
+  } else if (tag === 'iframe' && attrName === 'srcdoc') {
+    // Recursively minify HTML content within srcdoc attribute
+    // Fast-path: skip if nothing would change
+    if (!shouldMinifyInnerHTML(options)) {
+      return attrValue;
+    }
+    return minifyHTMLSelf(attrValue, options, true);
   }
   return attrValue;
 }
@@ -60767,7 +60983,7 @@ async function processScript(text, options, currentAttrs) {
 // Tag omission rules from https://html.spec.whatwg.org/multipage/syntax.html#optional-tags
 // with the following deviations:
 // - retain <body> if followed by <noscript>
-// - </rb>, </rt>, </rtc>, </rp> & </tfoot> follow https://www.w3.org/TR/html5/syntax.html#optional-tags
+// - </rb>, </rt>, </rtc>, </rp>, and </tfoot> follow https://www.w3.org/TR/html5/syntax.html#optional-tags
 // - retain all tags which are adjacent to non-standard HTML tags
 const optionalStartTags = new Set(['html', 'head', 'body', 'colgroup', 'tbody']);
 const optionalEndTags = new Set(['html', 'head', 'body', 'li', 'dt', 'dd', 'p', 'rb', 'rt', 'rtc', 'rp', 'optgroup', 'option', 'colgroup', 'caption', 'thead', 'tbody', 'tfoot', 'tr', 'td', 'th']);
@@ -60929,7 +61145,7 @@ async function normalizeAttr(attr, attrs, tag, options) {
   }
 
   if (attrValue) {
-    attrValue = await cleanAttributeValue(tag, attrName, attrValue, options, attrs);
+    attrValue = await cleanAttributeValue(tag, attrName, attrValue, options, attrs, minifyHTML);
   }
 
   if (options.removeEmptyAttributes &&
@@ -60977,7 +61193,7 @@ function buildAttr(normalized, hasUnarySlash, options, isLast, uidAttr) {
       emittedAttrValue += ' ';
     }
   } else if (isLast && !hasUnarySlash && !/\/$/.test(attrValue)) {
-    // make sure trailing slash is not interpreted as HTML self-closing tag
+    // Make sure trailing slash is not interpreted as HTML self-closing tag
     emittedAttrValue = attrValue;
   } else {
     emittedAttrValue = attrValue + ' ';
@@ -61004,6 +61220,17 @@ function identityAsync(value) {
   return Promise.resolve(value);
 }
 
+function shouldMinifyInnerHTML(options) {
+  return Boolean(
+    options.collapseWhitespace ||
+    options.removeComments ||
+    options.removeOptionalTags ||
+    options.minifyJS !== identity ||
+    options.minifyCSS !== identityAsync ||
+    options.minifyURLs !== identity
+  );
+}
+
 const processOptions = (inputOptions) => {
   const options = {
     name: function (name) {
@@ -61238,11 +61465,16 @@ async function minifyHTML(value, options, partialMarkup) {
   let uidIgnore;
   let uidAttr;
   let uidPattern;
-  let inlineTags = new Set([...inlineHtmlElements, ...(options.inlineCustomElements ?? [])]);
-
-  // temporarily replace ignored chunks with comments,
-  // so that we don't have to worry what's there.
-  // for all we care there might be
+  // Create inline tags/text sets with custom elements
+  const customElementsInput = options.inlineCustomElements ?? [];
+  const customElementsArr = Array.isArray(customElementsInput) ? customElementsInput : Array.from(customElementsInput);
+  const normalizedCustomElements = customElementsArr.map(name => options.name(name));
+  const inlineTextSet = new Set([...inlineElementsToKeepWhitespaceWithin, ...normalizedCustomElements]);
+  const inlineElements = new Set([...inlineElementsToKeepWhitespaceAround, ...normalizedCustomElements]);
+
+  // Temporarily replace ignored chunks with comments,
+  // so that we don’t have to worry what’s there.
+  // For all we care there might be
   // completely-horribly-broken-alien-non-html-emoj-cthulhu-filled content
   value = value.replace(/<!-- htmlmin:ignore -->([\s\S]*?)<!-- htmlmin:ignore -->/g, function (match, group1) {
     if (!uidIgnore) {
@@ -61363,20 +61595,20 @@ async function minifyHTML(value, options, partialMarkup) {
     buffer.length = Math.max(0, index);
   }
 
-  // look for trailing whitespaces, bypass any inline tags
+  // Look for trailing whitespaces, bypass any inline tags
   function trimTrailingWhitespace(index, nextTag) {
     for (let endTag = null; index >= 0 && _canTrimWhitespace(endTag); index--) {
       const str = buffer[index];
       const match = str.match(/^<\/([\w:-]+)>$/);
       if (match) {
         endTag = match[1];
-      } else if (/>$/.test(str) || (buffer[index] = collapseWhitespaceSmart(str, null, nextTag, options, inlineTags))) {
+      } else if (/>$/.test(str) || (buffer[index] = collapseWhitespaceSmart(str, null, nextTag, options, inlineElements, inlineTextSet))) {
         break;
       }
     }
   }
 
-  // look for trailing whitespaces from previously processed text
+  // Look for trailing whitespaces from previously processed text
   // which may not be trimmed due to a following comment or an empty
   // element which has now been removed
   function squashTrailingWhitespace(nextTag) {
@@ -61407,7 +61639,7 @@ async function minifyHTML(value, options, partialMarkup) {
       tag = options.name(tag);
       currentTag = tag;
       charsPrevTag = tag;
-      if (!inlineTextTags.has(tag)) {
+      if (!inlineTextSet.has(tag)) {
         currentChars = '';
       }
       hasChars = false;
@@ -61425,7 +61657,7 @@ async function minifyHTML(value, options, partialMarkup) {
           removeStartTag();
         }
         optionalStartTag = '';
-        // end-tag-followed-by-start-tag omission rules
+        // End-tag-followed-by-start-tag omission rules
         if (htmlTag && canRemovePrecedingTag(optionalEndTag, tag)) {
           removeEndTag();
           // <colgroup> cannot be omitted if preceding </colgroup> is omitted
@@ -61435,7 +61667,7 @@ async function minifyHTML(value, options, partialMarkup) {
         optionalEndTag = '';
       }
 
-      // set whitespace flags for nested tags (eg. <code> within a <pre>)
+      // Set whitespace flags for nested tags (eg. <code> within a <pre>)
       if (options.collapseWhitespace) {
         if (!stackNoTrimWhitespace.length) {
           squashTrailingWhitespace(tag);
@@ -61471,7 +61703,7 @@ async function minifyHTML(value, options, partialMarkup) {
         buffer.push(' ');
         buffer.push.apply(buffer, parts);
       } else if (optional && optionalStartTags.has(tag)) {
-        // start tag must never be omitted if it has any attributes
+        // Start tag must never be omitted if it has any attributes
         optionalStartTag = tag;
       }
 
@@ -61488,7 +61720,7 @@ async function minifyHTML(value, options, partialMarkup) {
       }
       tag = options.name(tag);
 
-      // check if current tag is in a whitespace stack
+      // Check if current tag is in a whitespace stack
       if (options.collapseWhitespace) {
         if (stackNoTrimWhitespace.length) {
           if (tag === stackNoTrimWhitespace[stackNoTrimWhitespace.length - 1]) {
@@ -61526,7 +61758,7 @@ async function minifyHTML(value, options, partialMarkup) {
       }
 
       if (options.removeEmptyElements && isElementEmpty && canRemoveElement(tag, attrs)) {
-        // remove last "element" from buffer
+        // Remove last “element” from buffer
         removeStartTag();
         optionalStartTag = '';
         optionalEndTag = '';
@@ -61537,7 +61769,7 @@ async function minifyHTML(value, options, partialMarkup) {
           buffer.push('</' + tag + '>');
         }
         charsPrevTag = '/' + tag;
-        if (!inlineTags.has(tag)) {
+        if (!inlineElements.has(tag)) {
           currentChars = '';
         } else if (isElementEmpty) {
           currentChars += '|';
@@ -61576,12 +61808,12 @@ async function minifyHTML(value, options, partialMarkup) {
                 }
                 trimTrailingWhitespace(tagIndex - 1, 'br');
               }
-            } else if (inlineTextTags.has(prevTag.charAt(0) === '/' ? prevTag.slice(1) : prevTag)) {
+            } else if (inlineTextSet.has(prevTag.charAt(0) === '/' ? prevTag.slice(1) : prevTag)) {
               text = collapseWhitespace(text, options, /(?:^|\s)$/.test(currentChars));
             }
           }
           if (prevTag || nextTag) {
-            text = collapseWhitespaceSmart(text, prevTag, nextTag, options, inlineTags);
+            text = collapseWhitespaceSmart(text, prevTag, nextTag, options, inlineElements, inlineTextSet);
           } else {
             text = collapseWhitespace(text, options, true, true);
           }
@@ -61651,7 +61883,7 @@ async function minifyHTML(value, options, partialMarkup) {
         text = prefix + text + suffix;
       }
       if (options.removeOptionalTags && text) {
-        // preceding comments suppress tag omissions
+        // Preceding comments suppress tag omissions
         optionalStartTag = '';
         optionalEndTag = '';
       }