html-minifier-next 1.4.0 → 1.4.2

package/dist/htmlminifier.umd.bundle.js

@@ -26526,6 +26526,8 @@
 	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",
@@ -26850,6 +26852,56 @@
 	            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++))
@@ -27092,7 +27144,8 @@
 	            && (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);
@@ -27353,6 +27406,9 @@
 	        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;
 
 	}
@@ -27574,10 +27630,6 @@
 	            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();
@@ -27592,10 +27644,31 @@
 	                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 "{":
@@ -27820,6 +27893,8 @@
 	                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");
@@ -27827,9 +27902,12 @@
 	                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");
 	                }
@@ -27861,7 +27939,7 @@
 	    }
 
 	    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({
@@ -28457,23 +28535,26 @@
 	            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");
@@ -28510,6 +28591,25 @@
 	        });
 	    };
 
+	    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");
@@ -28928,13 +29028,13 @@
 	            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()) {
@@ -28957,7 +29057,7 @@
 	            accessor_type = name;
 	            name = as_property_name();
 	        }
-	        if (prev().type === "privatename") {
+	        if (!is_private && prev().type === "privatename") {
 	            is_private = true;
 	        }
 
@@ -31186,7 +31286,7 @@
 
 	/* -----[ 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;
@@ -31195,9 +31295,9 @@
 
 	    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() {
@@ -31213,6 +31313,18 @@
 	    },
 	}, 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;
@@ -31249,7 +31361,23 @@
 	    $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;
@@ -31259,9 +31387,9 @@
 
 	    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) {
@@ -31276,13 +31404,39 @@
 	    },
 	    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;
@@ -32378,6 +32532,21 @@
 	    $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;
@@ -33224,11 +33393,11 @@
 	    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);
 	});
@@ -33763,19 +33932,30 @@
 
 	        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),
@@ -33786,6 +33966,7 @@
 	                start       : my_start_token(M),
 	                end         : my_end_token(M),
 	                definitions : definitions,
+	                await       : await_using,
 	            });
 	        },
 
@@ -34385,7 +34566,7 @@
 	            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),
@@ -34601,12 +34782,14 @@
 	        };
 	    });
 
-	    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)
 	        };
 	    });
@@ -36277,7 +36460,7 @@
 	        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
@@ -36609,7 +36792,7 @@
 	        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);
@@ -36969,7 +37152,7 @@
 	    });
 
 	    /* -----[ 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) {
@@ -36991,6 +37174,9 @@
 	    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();
@@ -37158,7 +37344,7 @@
 	        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();
@@ -37634,7 +37820,7 @@
 	        } 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);
@@ -37714,7 +37900,7 @@
 	        AST_Class,
 	        AST_Constant,
 	        AST_Debugger,
-	        AST_Definitions,
+	        AST_DefinitionsLike,
 	        AST_Directive,
 	        AST_Finally,
 	        AST_Jump,
@@ -37877,9 +38063,9 @@
 
 	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;
 	};
 
@@ -38249,6 +38435,7 @@
 	            node instanceof AST_SymbolVar
 	            || node instanceof AST_SymbolLet
 	            || node instanceof AST_SymbolConst
+	            || node instanceof AST_SymbolUsing
 	            || node instanceof AST_SymbolCatch
 	        ) {
 	            var def;
@@ -38262,7 +38449,7 @@
 	                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`,
@@ -39142,7 +39329,12 @@
 	    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;
 	};
 
@@ -39613,7 +39805,7 @@
 	    if (key instanceof AST_UnaryPrefix
 	        && key.operator == "void"
 	        && key.expression instanceof AST_Constant) {
-	        return;
+	        return undefined;
 	    }
 	    return key;
 	}
@@ -39723,6 +39915,7 @@
 	        node instanceof AST_Defun ||
 	        node instanceof AST_Let ||
 	        node instanceof AST_Const ||
+	        node instanceof AST_Using ||
 	        node instanceof AST_Export ||
 	        node instanceof AST_Import
 	    );
@@ -42482,7 +42675,7 @@
 	        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;
@@ -42865,7 +43058,7 @@
 
 	    // 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);
@@ -43094,6 +43287,10 @@
 	    }
 	});
 
+	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;
@@ -43302,6 +43499,7 @@
 	            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)
@@ -43400,6 +43598,7 @@
 	                && ((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
@@ -43814,7 +44013,9 @@
 	                    ? 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;
 	            }
 	        }
 
@@ -44149,7 +44350,7 @@
 	                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;
@@ -44289,7 +44490,7 @@
 	            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;
@@ -44312,7 +44513,7 @@
 	                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;
@@ -44332,7 +44533,7 @@
 	                        }
 	                    }
 	                } 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) {
@@ -44449,6 +44650,12 @@
 	                    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) {
@@ -45739,6 +45946,7 @@
 	    return !(
 	        node instanceof AST_Const
 	        || node instanceof AST_Let
+	        || node instanceof AST_Using
 	        || node instanceof AST_Class
 	    );
 	}
@@ -45917,6 +46125,7 @@
 	            let def;
 	            let value;
 	            if (sym.scope === self
+	                && !(sym instanceof AST_SymbolUsing)
 	                && (def = sym.definition()).escaped != 1
 	                && !def.assignments
 	                && !def.direct_access
@@ -59922,7 +60131,7 @@
 	  }
 	}
 
-	// Regular Expressions for parsing tags and attributes
+	// Regular expressions for parsing tags and attributes
 	const singleAttrIdentifier = /([^\s"'<>/=]+)/;
 	const singleAttrAssigns = [/=/];
 	const singleAttrValues = [
@@ -59953,10 +60162,10 @@
 	  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
@@ -59966,10 +60175,10 @@
 	// 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']);
 
@@ -60017,7 +60226,7 @@
 	    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) {
@@ -60093,7 +60302,7 @@
 	          html = '';
 	        }
 
-	        // next tag
+	        // Next tag
 	        let nextTagMatch = parseStartTag(html);
 	        if (nextTagMatch) {
 	          nextTag = nextTagMatch.tagName;
@@ -60206,9 +60415,9 @@
 
 	      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]; }
@@ -60430,28 +60639,28 @@
 	  }
 
 	  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);
 	}
@@ -60638,7 +60847,7 @@
 	  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);
@@ -60696,6 +60905,13 @@
 	  } 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;
 	}
@@ -60773,7 +60989,7 @@
 	// 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']);
@@ -60935,7 +61151,7 @@
 	  }
 
 	  if (attrValue) {
-	    attrValue = await cleanAttributeValue(tag, attrName, attrValue, options, attrs);
+	    attrValue = await cleanAttributeValue(tag, attrName, attrValue, options, attrs, minifyHTML);
 	  }
 
 	  if (options.removeEmptyAttributes &&
@@ -60983,7 +61199,7 @@
 	      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 + ' ';
@@ -61010,6 +61226,17 @@
 	  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) {
@@ -61244,11 +61471,16 @@
 	  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) {
@@ -61369,20 +61601,20 @@
 	    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) {
@@ -61413,7 +61645,7 @@
 	      tag = options.name(tag);
 	      currentTag = tag;
 	      charsPrevTag = tag;
-	      if (!inlineTextTags.has(tag)) {
+	      if (!inlineTextSet.has(tag)) {
 	        currentChars = '';
 	      }
 	      hasChars = false;
@@ -61431,7 +61663,7 @@
 	          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
@@ -61441,7 +61673,7 @@
 	        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);
@@ -61477,7 +61709,7 @@
 	        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;
 	      }
 
@@ -61494,7 +61726,7 @@
 	      }
 	      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]) {
@@ -61532,7 +61764,7 @@
 	      }
 
 	      if (options.removeEmptyElements && isElementEmpty && canRemoveElement(tag, attrs)) {
-	        // remove last "element" from buffer
+	        // Remove last “element” from buffer
 	        removeStartTag();
 	        optionalStartTag = '';
 	        optionalEndTag = '';
@@ -61543,7 +61775,7 @@
 	          buffer.push('</' + tag + '>');
 	        }
 	        charsPrevTag = '/' + tag;
-	        if (!inlineTags.has(tag)) {
+	        if (!inlineElements.has(tag)) {
 	          currentChars = '';
 	        } else if (isElementEmpty) {
 	          currentChars += '|';
@@ -61582,12 +61814,12 @@
 	                }
 	                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);
 	          }
@@ -61657,7 +61889,7 @@
 	        text = prefix + text + suffix;
 	      }
 	      if (options.removeOptionalTags && text) {
-	        // preceding comments suppress tag omissions
+	        // Preceding comments suppress tag omissions
 	        optionalStartTag = '';
 	        optionalEndTag = '';
 	      }