@lwc/template-compiler 8.21.6 → 8.22.3

package/dist/index.cjs.js

@@ -8511,7 +8511,7 @@ new Set([
     TAG_NAMES.WBR,
 ]);
 
-function parseFragment$1(fragmentContext, html, options) {
+function parseFragment(fragmentContext, html, options) {
     if (typeof fragmentContext === 'string') {
         options = html;
         html = fragmentContext;
@@ -8542,7 +8542,7 @@ function isTemplateNode(node) {
 const isElementNode = defaultTreeAdapter.isElementNode;
 const isCommentNode = defaultTreeAdapter.isCommentNode;
 defaultTreeAdapter.isDocumentTypeNode;
-const isTextNode$1 = defaultTreeAdapter.isTextNode;
+const isTextNode = defaultTreeAdapter.isTextNode;
 
 defaultTreeAdapter.appendChild;
 
@@ -9652,10 +9652,6 @@ class ParserCtx {
         this.config = config;
         this.renderMode = exports.LWCDirectiveRenderMode.shadow;
         this.preserveComments = config.preserveHtmlComments;
-        // TODO [#3370]: remove experimental template expression flag
-        if (config.experimentalComplexExpressions) {
-            this.preparsedJsExpressions = new Map();
-        }
         this.ecmaVersion = config.experimentalComplexExpressions
             ? TMPL_EXPR_ECMASCRIPT_EDITION
             : 2020;
@@ -9995,6 +9991,200 @@ const errorCodesToWarnOnInOlderAPIVersions = new Set([
     'eof-in-element-that-can-contain-only-text',
 ]);
 
+/*
+ * Copyright (c) 2018, salesforce.com, inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: MIT
+ * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
+ */
+function getLwcErrorFromParse5Error(ctx, code) {
+    /* istanbul ignore else */
+    if (errorCodesToErrorOn.has(code)) {
+        return errors.ParserDiagnostics.INVALID_HTML_SYNTAX;
+    }
+    else if (errorCodesToWarnOnInOlderAPIVersions.has(code)) {
+        // In newer API versions, all parse 5 errors are errors, not warnings
+        if (shared.isAPIFeatureEnabled(1 /* APIFeature.TREAT_ALL_PARSE5_ERRORS_AS_ERRORS */, ctx.apiVersion)) {
+            return errors.ParserDiagnostics.INVALID_HTML_SYNTAX;
+        }
+        else {
+            return errors.ParserDiagnostics.INVALID_HTML_SYNTAX_WARNING;
+        }
+    }
+    else {
+        // It should be impossible to reach here; we have a test in parser.spec.ts to ensure
+        // all error codes are accounted for. But just to be safe, make it a warning.
+        // TODO [#2650]: better system for handling unexpected parse5 errors
+        // eslint-disable-next-line no-console
+        console.warn('Found a Parse5 error that we do not know how to handle:', code);
+        return errors.ParserDiagnostics.INVALID_HTML_SYNTAX_WARNING;
+    }
+}
+function parseHTML(ctx, source) {
+    const onParseError = (err) => {
+        const { code, ...location } = err;
+        const lwcError = getLwcErrorFromParse5Error(ctx, code);
+        ctx.warnAtLocation(lwcError, sourceLocation(location), [code]);
+    };
+    return parseFragment(source, {
+        sourceCodeLocationInfo: true,
+        onParseError,
+    });
+}
+// https://github.com/babel/babel/blob/d33d02359474296402b1577ef53f20d94e9085c4/packages/babel-types/src/react.js#L9-L55
+function cleanTextNode(value) {
+    const lines = value.split(/\r\n|\n|\r/);
+    let lastNonEmptyLine = 0;
+    for (let i = 0; i < lines.length; i++) {
+        if (lines[i].match(/[^ \t]/)) {
+            lastNonEmptyLine = i;
+        }
+    }
+    let str = '';
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const isFirstLine = i === 0;
+        const isLastLine = i === lines.length - 1;
+        const isLastNonEmptyLine = i === lastNonEmptyLine;
+        let trimmedLine = line.replace(/\t/g, ' ');
+        if (!isFirstLine) {
+            trimmedLine = trimmedLine.replace(/^[ ]+/, '');
+        }
+        if (!isLastLine) {
+            trimmedLine = trimmedLine.replace(/[ ]+$/, '');
+        }
+        if (trimmedLine) {
+            if (!isLastNonEmptyLine) {
+                trimmedLine += ' ';
+            }
+            str += trimmedLine;
+        }
+    }
+    return str;
+}
+function decodeTextContent(source) {
+    return he__namespace.decode(source);
+}
+
+/*
+ * Copyright (c) 2018, salesforce.com, inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: MIT
+ * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
+ */
+// https://262.ecma-international.org/12.0/#sec-keywords-and-reserved-words
+// prettier-ignore
+const REVERSED_KEYWORDS = new Set([
+    // Reserved keywords
+    'await', 'break', 'case', 'catch', 'class', 'const', 'continue', 'debugger', 'default', 'delete',
+    'do', 'else', 'enum', 'export', 'extends', 'false', 'finally', 'for', 'function', 'if', 'import',
+    'in', 'instanceof', 'new', 'null', 'return', 'super', 'switch', 'this', 'throw', 'true', 'try',
+    'typeof', 'var', 'void', 'while', 'with', 'yield',
+    // Strict mode only reserved keywords
+    'let', 'static', 'implements', 'interface', 'package', 'private', 'protected', 'public'
+]);
+function isReservedES6Keyword(str) {
+    return REVERSED_KEYWORDS.has(str);
+}
+
+/*
+ * Copyright (c) 2018, salesforce.com, inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: MIT
+ * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
+ */
+const EXPRESSION_SYMBOL_START = '{';
+const EXPRESSION_SYMBOL_END = '}';
+const POTENTIAL_EXPRESSION_RE = /^.?{.+}.*$/;
+const WHITESPACES_RE = /\s/;
+function isExpression(source) {
+    // Issue #3418: Legacy behavior, previous regex treated "{}" attribute value as non expression
+    return source[0] === '{' && source.slice(-1) === '}' && source.length > 2;
+}
+function isPotentialExpression(source) {
+    return !!source.match(POTENTIAL_EXPRESSION_RE);
+}
+function validateExpression(source, node, config) {
+    const isValidNode = isIdentifier(node) || isMemberExpression(node);
+    // INVALID_XYZ_COMPLEX provides additional context to the user if CTE is enabled.
+    // The author may not have delimited the CTE with quotes, resulting in it being parsed
+    // as a legacy expression.
+    errors.invariant(isValidNode, config.experimentalComplexExpressions
+        ? errors.ParserDiagnostics.INVALID_NODE_COMPLEX
+        : errors.ParserDiagnostics.INVALID_NODE, [node.type, source]);
+    if (isMemberExpression(node)) {
+        errors.invariant(config.experimentalComputedMemberExpression || !node.computed, config.experimentalComplexExpressions
+            ? errors.ParserDiagnostics.COMPUTED_PROPERTY_ACCESS_NOT_ALLOWED_COMPLEX
+            : errors.ParserDiagnostics.COMPUTED_PROPERTY_ACCESS_NOT_ALLOWED, [source]);
+        const { object, property } = node;
+        if (!isIdentifier(object)) {
+            validateExpression(source, object, config);
+        }
+        if (!isIdentifier(property)) {
+            validateExpression(source, property, config);
+        }
+    }
+}
+function validateSourceIsParsedExpression(source, parsedExpression) {
+    if (parsedExpression.end === source.length - 1) {
+        return;
+    }
+    let unclosedParenthesisCount = 0;
+    for (let i = 0, n = parsedExpression.start; i < n; i++) {
+        if (source[i] === '(') {
+            unclosedParenthesisCount++;
+        }
+    }
+    // source[source.length - 1] === '}', n = source.length - 1 is to avoid processing '}'.
+    for (let i = parsedExpression.end, n = source.length - 1; i < n; i++) {
+        const character = source[i];
+        if (character === ')') {
+            unclosedParenthesisCount--;
+        }
+        else if (character === ';') {
+            // acorn parseExpressionAt will stop at the first ";", it may be that the expression is not
+            // a multiple expression ({foo;}), but this is a case that we explicitly do not want to support.
+            // in such case, let's fail with the same error as if it were a multiple expression.
+            errors.invariant(false, errors.ParserDiagnostics.MULTIPLE_EXPRESSIONS);
+        }
+        else {
+            errors.invariant(WHITESPACES_RE.test(character), errors.ParserDiagnostics.TEMPLATE_EXPRESSION_PARSING_ERROR, ['Unexpected end of expression']);
+        }
+    }
+    errors.invariant(unclosedParenthesisCount === 0, errors.ParserDiagnostics.TEMPLATE_EXPRESSION_PARSING_ERROR, [
+        'Unexpected end of expression',
+    ]);
+}
+function parseExpression(ctx, source, location) {
+    const { ecmaVersion } = ctx;
+    return ctx.withErrorWrapping(() => {
+        const parsed = acorn.parseExpressionAt(source, 1, {
+            ecmaVersion,
+            allowAwaitOutsideFunction: false,
+            onComment: () => errors.invariant(false, errors.ParserDiagnostics.INVALID_EXPR_COMMENTS_DISALLOWED),
+        });
+        validateSourceIsParsedExpression(source, parsed);
+        validateExpression(source, parsed, ctx.config);
+        return { ...parsed, location };
+    }, errors.ParserDiagnostics.TEMPLATE_EXPRESSION_PARSING_ERROR, location, (err) => `Invalid expression ${source} - ${err.message}`);
+}
+function parseIdentifier(ctx, source, location) {
+    let isValid = true;
+    isValid = acorn.isIdentifierStart(source.charCodeAt(0));
+    for (let i = 1; i < source.length && isValid; i++) {
+        isValid = acorn.isIdentifierChar(source.charCodeAt(i));
+    }
+    if (isValid && !isReservedES6Keyword(source)) {
+        return {
+            ...identifier(source),
+            location,
+        };
+    }
+    else {
+        ctx.throwAtLocation(errors.ParserDiagnostics.INVALID_IDENTIFIER, location, [source]);
+    }
+}
+
 /**
  * @typedef { import('estree').Node} Node
  * @typedef {{
@@ -10233,6 +10423,13 @@ function walk(ast, { enter, leave }) {
  * SPDX-License-Identifier: MIT
  * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
  */
+const OPENING_CURLY_LEN = 1;
+const CLOSING_CURLY_LEN = 1;
+const CLOSING_CURLY_BRACKET = 0x7d;
+const TRAILING_SPACES_AND_PARENS = /[\s)]*/;
+function getTrailingChars(str) {
+    return TRAILING_SPACES_AND_PARENS.exec(str)[0];
+}
 const ALWAYS_INVALID_TYPES = new Map(Object.entries({
     AwaitExpression: 'await expressions',
     ClassExpression: 'classes',
@@ -10340,157 +10537,6 @@ function validateExpressionAst(rootNode) {
         },
     });
 }
-
-/*
- * Copyright (c) 2018, salesforce.com, inc.
- * All rights reserved.
- * SPDX-License-Identifier: MIT
- * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
- */
-// https://262.ecma-international.org/12.0/#sec-keywords-and-reserved-words
-// prettier-ignore
-const REVERSED_KEYWORDS = new Set([
-    // Reserved keywords
-    'await', 'break', 'case', 'catch', 'class', 'const', 'continue', 'debugger', 'default', 'delete',
-    'do', 'else', 'enum', 'export', 'extends', 'false', 'finally', 'for', 'function', 'if', 'import',
-    'in', 'instanceof', 'new', 'null', 'return', 'super', 'switch', 'this', 'throw', 'true', 'try',
-    'typeof', 'var', 'void', 'while', 'with', 'yield',
-    // Strict mode only reserved keywords
-    'let', 'static', 'implements', 'interface', 'package', 'private', 'protected', 'public'
-]);
-function isReservedES6Keyword(str) {
-    return REVERSED_KEYWORDS.has(str);
-}
-
-/*
- * Copyright (c) 2018, salesforce.com, inc.
- * All rights reserved.
- * SPDX-License-Identifier: MIT
- * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
- */
-const EXPRESSION_SYMBOL_START = '{';
-const EXPRESSION_SYMBOL_END = '}';
-const POTENTIAL_EXPRESSION_RE = /^.?{.+}.*$/;
-const WHITESPACES_RE = /\s/;
-function isExpression(source) {
-    // Issue #3418: Legacy behavior, previous regex treated "{}" attribute value as non expression
-    return source[0] === '{' && source.slice(-1) === '}' && source.length > 2;
-}
-function isPotentialExpression(source) {
-    return !!source.match(POTENTIAL_EXPRESSION_RE);
-}
-function validateExpression(node, config) {
-    // TODO [#3370]: remove experimental template expression flag
-    if (config.experimentalComplexExpressions) {
-        return validateExpressionAst(node);
-    }
-    const isValidNode = isIdentifier(node) || isMemberExpression(node);
-    errors.invariant(isValidNode, errors.ParserDiagnostics.INVALID_NODE, [node.type]);
-    if (isMemberExpression(node)) {
-        errors.invariant(config.experimentalComputedMemberExpression || !node.computed, errors.ParserDiagnostics.COMPUTED_PROPERTY_ACCESS_NOT_ALLOWED);
-        const { object, property } = node;
-        if (!isIdentifier(object)) {
-            validateExpression(object, config);
-        }
-        if (!isIdentifier(property)) {
-            validateExpression(property, config);
-        }
-    }
-}
-function validateSourceIsParsedExpression(source, parsedExpression) {
-    if (parsedExpression.end === source.length - 1) {
-        return;
-    }
-    let unclosedParenthesisCount = 0;
-    for (let i = 0, n = parsedExpression.start; i < n; i++) {
-        if (source[i] === '(') {
-            unclosedParenthesisCount++;
-        }
-    }
-    // source[source.length - 1] === '}', n = source.length - 1 is to avoid processing '}'.
-    for (let i = parsedExpression.end, n = source.length - 1; i < n; i++) {
-        const character = source[i];
-        if (character === ')') {
-            unclosedParenthesisCount--;
-        }
-        else if (character === ';') {
-            // acorn parseExpressionAt will stop at the first ";", it may be that the expression is not
-            // a multiple expression ({foo;}), but this is a case that we explicitly do not want to support.
-            // in such case, let's fail with the same error as if it were a multiple expression.
-            errors.invariant(false, errors.ParserDiagnostics.MULTIPLE_EXPRESSIONS);
-        }
-        else {
-            errors.invariant(WHITESPACES_RE.test(character), errors.ParserDiagnostics.TEMPLATE_EXPRESSION_PARSING_ERROR, ['Unexpected end of expression']);
-        }
-    }
-    errors.invariant(unclosedParenthesisCount === 0, errors.ParserDiagnostics.TEMPLATE_EXPRESSION_PARSING_ERROR, [
-        'Unexpected end of expression',
-    ]);
-}
-function validatePreparsedJsExpressions(ctx) {
-    ctx.preparsedJsExpressions?.forEach(({ parsedExpression, rawText }) => {
-        const acornLoc = parsedExpression.loc;
-        const parse5Loc = {
-            startLine: acornLoc.start.line,
-            startCol: acornLoc.start.column,
-            startOffset: parsedExpression.start,
-            endLine: acornLoc.end.line,
-            endCol: acornLoc.end.column,
-            endOffset: parsedExpression.end,
-        };
-        ctx.withErrorWrapping(() => {
-            validateExpressionAst(parsedExpression);
-        }, errors.ParserDiagnostics.TEMPLATE_EXPRESSION_PARSING_ERROR, sourceLocation(parse5Loc), (err) => `Invalid expression ${rawText} - ${err.message}`);
-    });
-}
-function parseExpression(ctx, source, location) {
-    const { ecmaVersion } = ctx;
-    return ctx.withErrorWrapping(() => {
-        const parsed = acorn.parseExpressionAt(source, 1, {
-            ecmaVersion,
-            // TODO [#3370]: remove experimental template expression flag
-            allowAwaitOutsideFunction: ctx.config.experimentalComplexExpressions,
-        });
-        validateSourceIsParsedExpression(source, parsed);
-        validateExpression(parsed, ctx.config);
-        return { ...parsed, location };
-    }, errors.ParserDiagnostics.TEMPLATE_EXPRESSION_PARSING_ERROR, location, (err) => `Invalid expression ${source} - ${err.message}`);
-}
-function parseIdentifier(ctx, source, location) {
-    let isValid = true;
-    isValid = acorn.isIdentifierStart(source.charCodeAt(0));
-    for (let i = 1; i < source.length && isValid; i++) {
-        isValid = acorn.isIdentifierChar(source.charCodeAt(i));
-    }
-    if (isValid && !isReservedES6Keyword(source)) {
-        return {
-            ...identifier(source),
-            location,
-        };
-    }
-    else {
-        ctx.throwAtLocation(errors.ParserDiagnostics.INVALID_IDENTIFIER, location, [source]);
-    }
-}
-
-/*
- * Copyright (c) 2023, salesforce.com, inc.
- * All rights reserved.
- * SPDX-License-Identifier: MIT
- * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
- */
-const OPENING_CURLY_LEN = 1;
-const CLOSING_CURLY_LEN = 1;
-const OPENING_CURLY_BRACKET = 0x7b;
-const CLOSING_CURLY_BRACKET = 0x7d;
-const WHITESPACE = /\s*/;
-const TRAILING_SPACES_AND_PARENS = /[\s)]*/;
-function getWhitespaceLen(str) {
-    return WHITESPACE.exec(str)[0].length;
-}
-function getTrailingChars(str) {
-    return TRAILING_SPACES_AND_PARENS.exec(str)[0];
-}
 /**
  * This function checks for "unbalanced" extraneous parentheses surrounding the expression.
  *
@@ -10519,189 +10565,32 @@ function validateMatchingExtraParens(leadingChars, trailingChars) {
     const numTrailingParens = trailingChars.split(')').length - 1;
     errors.invariant(numLeadingParens === numTrailingParens, errors.ParserDiagnostics.TEMPLATE_EXPRESSION_PARSING_ERROR, ['expression must have balanced parentheses.']);
 }
-/**
- * This class extends `parse5`'s internal tokenizer.
- *
- * Its behavior diverges from that specified in the WHATWG HTML spec
- * in two places:
- * - 13.2.5.38 - unquoted attribute values
- * - 13.2.5.1 - the "data" state, which corresponds to parsing outside of tags
- *
- * Specifically, this tokenizer defers to Acorn's JavaScript parser when
- * encountering a `{` character for an attribute value or within a text
- * node. Acorn parses the expression, and the tokenizer continues its work
- * following the closing `}`.
- *
- * The tokenizer itself is a massive state machine - code points are consumed one at
- * a time and, when certain conditions are met, sequences of those code points are
- * emitted as tokens. The tokenizer will also transition to new states, under conditions
- * specified by the HTML spec.
- */
-class TemplateHtmlTokenizer extends Tokenizer {
-    constructor(opts, parser, handler) {
-        super(opts, handler);
-        // We track which attribute values are in-progess so that we can defer
-        // to the default tokenizer's behavior after the first character of
-        // an unquoted attr value has been checked for an opening curly brace.
-        this.checkedAttrs = new WeakSet();
-        this.parser = parser;
-    }
-    parseTemplateExpression() {
-        const expressionStart = this.preprocessor.pos;
-        const html = this.preprocessor.html;
-        const leadingWhitespaceLen = getWhitespaceLen(html.slice(expressionStart + 1));
-        const javascriptExprStart = expressionStart + leadingWhitespaceLen + OPENING_CURLY_LEN;
-        // Start parsing after the opening curly brace and any leading whitespace.
-        const estreeNode = acorn.parseExpressionAt(html, javascriptExprStart, {
-            ecmaVersion: TMPL_EXPR_ECMASCRIPT_EDITION,
-            allowAwaitOutsideFunction: true,
-            locations: true,
-            ranges: true,
-            onComment: () => errors.invariant(false, errors.ParserDiagnostics.INVALID_EXPR_COMMENTS_DISALLOWED),
-        });
-        const leadingChars = html.slice(expressionStart + 1, estreeNode.start);
-        const trailingChars = getTrailingChars(html.slice(estreeNode.end));
-        validateMatchingExtraParens(leadingChars, trailingChars);
-        const idxOfClosingBracket = estreeNode.end + trailingChars.length;
-        // Capture text content between the outer curly braces, inclusive.
-        const expressionTextNodeValue = html.slice(expressionStart, idxOfClosingBracket + CLOSING_CURLY_LEN);
-        errors.invariant(html.codePointAt(idxOfClosingBracket) === CLOSING_CURLY_BRACKET, errors.ParserDiagnostics.TEMPLATE_EXPRESSION_PARSING_ERROR, ['expression must end with curly brace.']);
-        // Parsed expressions that are cached here will be later retrieved when the
-        // LWC template AST is being constructed.
-        this.parser.preparsedJsExpressions.set(expressionStart, {
-            parsedExpression: estreeNode,
-            rawText: expressionTextNodeValue,
-        });
-        return expressionTextNodeValue;
-    }
-    // ATTRIBUTE_VALUE_UNQUOTED_STATE is entered when an opening tag is being parsed,
-    // after an attribute name is parsed, and after the `=` character is parsed. The
-    // next character determines whether the lexer enters the ATTRIBUTE_VALUE_QUOTED_STATE
-    // or ATTRIBUTE_VALUE_UNQUOTED_STATE. Customizations required to support template
-    // expressions are only in effect when parsing an unquoted attribute value.
-    _stateAttributeValueUnquoted(codePoint) {
-        if (codePoint === OPENING_CURLY_BRACKET && !this.checkedAttrs.has(this.currentAttr)) {
-            this.checkedAttrs.add(this.currentAttr);
-            this.currentAttr.value = this.parseTemplateExpression();
-            this._advanceBy(this.currentAttr.value.length - 1);
-            this.consumedAfterSnapshot = this.currentAttr.value.length;
-        }
-        else {
-            // If the first character in an unquoted-attr-value is not an opening
-            // curly brace, it isn't a template expression. Opening curly braces
-            // coming later in an unquoted attr value should not be considered
-            // the beginning of a template expression.
-            this.checkedAttrs.add(this.currentAttr);
-            super._stateAttributeValueUnquoted(codePoint);
-        }
-    }
-    // DATA_STATE is the initial & default state of the lexer. It can be thought of as the
-    // state when the cursor is outside of an (opening or closing) tag, and outside of
-    // special parts of an HTML document like the contents of a <style> or <script> tag.
-    // In other words, we're parsing a text node when in DATA_STATE.
-    _stateData(codePoint) {
-        if (codePoint === OPENING_CURLY_BRACKET) {
-            // An opening curly brace may be the first character in a text node.
-            // If that is not the case, we need to emit the text node characters
-            // that come before the curly brace.
-            if (this.currentCharacterToken) {
-                this.currentLocation = this.getCurrentLocation(0);
-                this.consumedAfterSnapshot = 0;
-                // Emit the text segment preceding the curly brace.
-                this._emitCurrentCharacterToken(this.currentLocation);
-            }
-            const expressionTextNodeValue = this.parseTemplateExpression();
-            // Create a new text-node token to contain our `{expression}`
-            this._createCharacterToken(TokenType.CHARACTER, expressionTextNodeValue);
-            this._advanceBy(expressionTextNodeValue.length);
-            this.currentLocation = this.getCurrentLocation(0);
-            // Emit the text node token containing the `{expression}`
-            this._emitCurrentCharacterToken(this.currentLocation);
-            // Moving the cursor back by one allows the state machine to correctly detect
-            // the state into which it should next transition.
-            this.preprocessor.retreat(1);
-            this.currentToken = null;
-            this.currentCharacterToken = null;
-        }
-        else {
-            super._stateData(codePoint);
-        }
-    }
-}
-function isTemplateElement(node) {
-    return node.nodeName === 'template';
-}
-function isTextNode(node) {
-    return node?.nodeName === '#text';
-}
-function isTemplateExpressionTextNode(node, html) {
-    return (isTextNode(node) &&
-        isTemplateExpressionTextNodeValue(node.value, node.sourceCodeLocation.startOffset, html));
-}
-function isTemplateExpressionTextNodeValue(value, startOffset, html) {
-    return (value.startsWith(EXPRESSION_SYMBOL_START) &&
-        html.startsWith(EXPRESSION_SYMBOL_START, startOffset));
-}
-/**
- * This class extends `parse5`'s internal parser. The heavy lifting is
- * done in the tokenizer. This class is only present to facilitate use
- * of that tokenizer when parsing expressions.
- */
-class TemplateHtmlParser extends Parser {
-    constructor(extendedOpts, document, fragmentCxt) {
-        const { preparsedJsExpressions, ...options } = extendedOpts;
-        super(options, document, fragmentCxt);
-        this.preparsedJsExpressions = preparsedJsExpressions;
-        this.tokenizer = new TemplateHtmlTokenizer(this.options, this, this);
-    }
-    // The parser will try to concatenate adjacent text tokens into a single
-    // text node. Template expressions should be encapsulated in their own
-    // text node, and not combined with adjacent text or whitespace. To avoid
-    // that, we create a new text node for the template expression rather than
-    // allowing the concatenation to proceed.
-    _insertCharacters(token) {
-        const parentNode = this.openElements.current;
-        const previousPeer = parentNode.childNodes.at(-1);
-        const html = this.tokenizer.preprocessor.html;
-        if (
-        // If we're not dealing with a template expression...
-        !isTemplateExpressionTextNodeValue(token.chars, token.location.startOffset, html) &&
-            // ... and the previous node wasn't a text-node-template-expression...
-            !isTemplateExpressionTextNode(previousPeer, html)) {
-            // ... concatenate the provided characters with the previous token's characters.
-            return super._insertCharacters(token);
-        }
-        const textNode = {
-            nodeName: '#text',
-            value: token.chars,
-            sourceCodeLocation: token.location ? { ...token.location } : null,
-            parentNode,
-        };
-        if (isTemplateElement(parentNode)) {
-            parentNode.content.childNodes.push(textNode);
-        }
-        else {
-            parentNode.childNodes.push(textNode);
-        }
-    }
-}
-/**
- * Parse the LWC template using a customized parser & lexer that allow
- * for template expressions to be parsed correctly.
- * @param               source  raw template markup
- * @param  config
- * @returns     the parsed document
- */
-function parseFragment(source, config) {
-    const { ctx, sourceCodeLocationInfo = true, onParseError } = config;
-    const opts = {
-        sourceCodeLocationInfo,
-        onParseError,
-        preparsedJsExpressions: ctx.preparsedJsExpressions,
+function validateComplexExpression(expression, source, templateSource, expressionStart, options, location) {
+    const leadingChars = source.slice(expressionStart + OPENING_CURLY_LEN, expression.start);
+    const trailingChars = getTrailingChars(source.slice(expression.end));
+    const idxOfClosingBracket = expression.end + trailingChars.length;
+    // Capture text content between the outer curly braces, inclusive.
+    const expressionTextNodeValue = source.slice(expressionStart, idxOfClosingBracket + CLOSING_CURLY_LEN);
+    validateExpressionAst(expression);
+    validateMatchingExtraParens(leadingChars, trailingChars);
+    errors.invariant(source.codePointAt(idxOfClosingBracket) === CLOSING_CURLY_BRACKET, errors.ParserDiagnostics.TEMPLATE_EXPRESSION_PARSING_ERROR, ['expression must end with curly brace.']);
+    /*
+        This second parsing step should never be needed, but accounts for cases
+        where a portion of the expression has been incorrectly parsed by the html parser.
+        - E.g. the expression {call("}<c-status></c-status>")} would be parsed by parse5 like this:
+            1. {call("} (will next be evaluated as an expression)
+            2. <c-status></c-status> (will be evaluated as an element)
+            3. ")} (text node)
+        - The expression: call(" is invalid so the parser would have already failed to validate. But if, somehow a valid expression was produced, this step
+           would compare the length of that expression to the length of the expression parsed from the raw template source.
+           If the two expressions don't match in length, that indicates parse5 interpreted a portion of the expression as HTML and we throw.
+    */
+    const templateExpression = acorn.parseExpressionAt(templateSource, expressionStart + OPENING_CURLY_LEN, options);
+    errors.invariant(expression.end === templateExpression.end, errors.ParserDiagnostics.TEMPLATE_EXPRESSION_PARSING_ERROR, ['expression incorrectly formed']);
+    return {
+        expression: { ...expression, location },
+        raw: expressionTextNodeValue,
     };
-    const parser = TemplateHtmlParser.getFragmentParser(null, opts);
-    parser.tokenizer.write(source, true);
-    return parser.getFragment();
 }
 
 /*
@@ -10714,88 +10603,17 @@ function isComplexTemplateExpressionEnabled(ctx) {
     return (ctx.config.experimentalComplexExpressions &&
         shared.isAPIFeatureEnabled(11 /* APIFeature.ENABLE_COMPLEX_TEMPLATE_EXPRESSIONS */, ctx.apiVersion));
 }
-
-/*
- * Copyright (c) 2018, salesforce.com, inc.
- * All rights reserved.
- * SPDX-License-Identifier: MIT
- * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
- */
-function getLwcErrorFromParse5Error(ctx, code) {
-    /* istanbul ignore else */
-    if (errorCodesToErrorOn.has(code)) {
-        return errors.ParserDiagnostics.INVALID_HTML_SYNTAX;
-    }
-    else if (errorCodesToWarnOnInOlderAPIVersions.has(code)) {
-        // In newer API versions, all parse 5 errors are errors, not warnings
-        if (shared.isAPIFeatureEnabled(1 /* APIFeature.TREAT_ALL_PARSE5_ERRORS_AS_ERRORS */, ctx.apiVersion)) {
-            return errors.ParserDiagnostics.INVALID_HTML_SYNTAX;
-        }
-        else {
-            return errors.ParserDiagnostics.INVALID_HTML_SYNTAX_WARNING;
-        }
-    }
-    else {
-        // It should be impossible to reach here; we have a test in parser.spec.ts to ensure
-        // all error codes are accounted for. But just to be safe, make it a warning.
-        // TODO [#2650]: better system for handling unexpected parse5 errors
-        // eslint-disable-next-line no-console
-        console.warn('Found a Parse5 error that we do not know how to handle:', code);
-        return errors.ParserDiagnostics.INVALID_HTML_SYNTAX_WARNING;
-    }
-}
-function parseHTML(ctx, source) {
-    const onParseError = (err) => {
-        const { code, ...location } = err;
-        const lwcError = getLwcErrorFromParse5Error(ctx, code);
-        ctx.warnAtLocation(lwcError, sourceLocation(location), [code]);
-    };
-    // TODO [#3370]: remove experimental template expression flag
-    if (ctx.config.experimentalComplexExpressions) {
-        return parseFragment(source, {
-            ctx,
-            sourceCodeLocationInfo: true,
-            onParseError,
-        });
-    }
-    return parseFragment$1(source, {
-        sourceCodeLocationInfo: true,
-        onParseError,
-    });
-}
-// https://github.com/babel/babel/blob/d33d02359474296402b1577ef53f20d94e9085c4/packages/babel-types/src/react.js#L9-L55
-function cleanTextNode(value) {
-    const lines = value.split(/\r\n|\n|\r/);
-    let lastNonEmptyLine = 0;
-    for (let i = 0; i < lines.length; i++) {
-        if (lines[i].match(/[^ \t]/)) {
-            lastNonEmptyLine = i;
-        }
-    }
-    let str = '';
-    for (let i = 0; i < lines.length; i++) {
-        const line = lines[i];
-        const isFirstLine = i === 0;
-        const isLastLine = i === lines.length - 1;
-        const isLastNonEmptyLine = i === lastNonEmptyLine;
-        let trimmedLine = line.replace(/\t/g, ' ');
-        if (!isFirstLine) {
-            trimmedLine = trimmedLine.replace(/^[ ]+/, '');
-        }
-        if (!isLastLine) {
-            trimmedLine = trimmedLine.replace(/[ ]+$/, '');
-        }
-        if (trimmedLine) {
-            if (!isLastNonEmptyLine) {
-                trimmedLine += ' ';
-            }
-            str += trimmedLine;
-        }
-    }
-    return str;
-}
-function decodeTextContent(source) {
-    return he__namespace.decode(source);
+function parseComplexExpression(ctx, source, templateSource, location, expressionStart = 0) {
+    const { ecmaVersion } = ctx;
+    return ctx.withErrorWrapping(() => {
+        const options = {
+            ecmaVersion,
+            onComment: () => errors.invariant(false, errors.ParserDiagnostics.INVALID_EXPR_COMMENTS_DISALLOWED),
+            allowAwaitOutsideFunction: true,
+        };
+        const estreeNode = acorn.parseExpressionAt(source, expressionStart + OPENING_CURLY_LEN, options);
+        return validateComplexExpression(estreeNode, source, templateSource, expressionStart, options, location);
+    }, errors.ParserDiagnostics.TEMPLATE_EXPRESSION_PARSING_ERROR, location, (err) => `Invalid expression ${source} - ${err.message}`);
 }
 
 /*
@@ -11276,7 +11094,7 @@ function normalizeAttributeValue(ctx, raw, tag, attr, location) {
         }
         // <input value={myValue} />
         // -> Valid identifier.
-        return { value, escapedExpression: false };
+        return { value, escapedExpression: false, quotedExpression: !!isQuoted };
     }
     else if (!isEscaped && isPotentialExpression(value)) {
         const isExpressionEscaped = value.startsWith(`\\${EXPRESSION_SYMBOL_START}`);
@@ -11287,12 +11105,16 @@ function normalizeAttributeValue(ctx, raw, tag, attr, location) {
             // <input value={myValue}/>
             // -> By design the html parser consider the / as the last character of the attribute value.
             //    Make sure to remove strip the trailing / for self closing elements.
-            return { value: value.slice(0, -1), escapedExpression: false };
+            return {
+                value: value.slice(0, -1),
+                escapedExpression: false,
+                quotedExpression: !!isQuoted,
+            };
         }
         else if (isExpressionEscaped) {
             // <input value="\{myValue}"/>
             // -> Valid escaped string literal
-            return { value: value.slice(1), escapedExpression: true };
+            return { value: value.slice(1), escapedExpression: true, quotedExpression: !!isQuoted };
         }
         let escaped = raw.replace(/="?/, '="\\');
         escaped += escaped.endsWith('"') ? '' : '"';
@@ -11304,7 +11126,7 @@ function normalizeAttributeValue(ctx, raw, tag, attr, location) {
     }
     // <input value="myValue"/>
     // -> Valid string literal.
-    return { value, escapedExpression: false };
+    return { value, escapedExpression: false, quotedExpression: !!isQuoted };
 }
 function attributeName(attr) {
     const { prefix, name } = attr;
@@ -11467,7 +11289,6 @@ function parse$1(source, state) {
         return { warnings: ctx.warnings };
     }
     const root = ctx.withErrorRecovery(() => {
-        validatePreparsedJsExpressions(ctx);
         const templateRoot = getTemplateRoot(ctx, fragment);
         return parseRoot(ctx, templateRoot);
     });
@@ -11674,8 +11495,8 @@ function parseChildren(ctx, parse5Parent, parent, parse5ParentLocation) {
                     ctx.endIfChain();
                 }
             }
-            else if (isTextNode$1(child)) {
-                const textNodes = parseText(ctx, child);
+            else if (isTextNode(child)) {
+                const textNodes = parseTextNode(ctx, child);
                 parent.children.push(...textNodes);
                 // Non whitespace text nodes end any if chain we may be parsing
                 if (ctx.isParsingSiblingIfBlock() && textNodes.length > 0) {
@@ -11695,53 +11516,9 @@ function parseChildren(ctx, parse5Parent, parent, parse5ParentLocation) {
     }
     ctx.endSiblingScope();
 }
-function parseText(ctx, parse5Text) {
+function parseText(ctx, rawText, sourceLocation, location) {
     const parsedTextNodes = [];
-    const location = parse5Text.sourceCodeLocation;
-    /* istanbul ignore if */
-    if (!location) {
-        // Parse5 will recover from invalid HTML. When this happens the node's sourceCodeLocation will be undefined.
-        // https://github.com/inikulin/parse5/blob/master/packages/parse5/docs/options/parser-options.md#sourcecodelocationinfo
-        // This is a defensive check as this should never happen for TextNode.
-        throw new Error('An internal parsing error occurred during node creation; a text node was found without a sourceCodeLocation.');
-    }
-    // Extract the raw source to avoid HTML entity decoding done by parse5
-    const rawText = cleanTextNode(ctx.getSource(location.startOffset, location.endOffset));
-    /*
-    The original job of this if-block was to discard the whitespace between HTML tags, HTML
-    comments, and HTML tags and HTML comments. The whitespace inside the text content of HTML tags
-    would never be considered here because they would not be parsed into individual text nodes until
-    later (several lines below).
-
-    ["Hello {first} {last}!"] => ["Hello ", "{first}", " ", "{last}", "!"]
-
-    With the implementation of complex template expressions, whitespace that shouldn't be discarded
-    has already been parsed into individual text nodes at this point so we only discard when
-    experimentalComplexExpressions is disabled.
-
-    When removing the experimentalComplexExpressions flag, we need to figure out how to best discard
-    the HTML whitespace while preserving text content whitespace, while also taking into account how
-    comments are sometimes preserved (in which case we need to keep the HTML whitespace).
-    */
-    if (!rawText.trim().length && !ctx.config.experimentalComplexExpressions) {
-        return parsedTextNodes;
-    }
-    // TODO [#3370]: remove experimental template expression flag
-    if (ctx.config.experimentalComplexExpressions && isExpression(rawText)) {
-        // Implementation of the lexer ensures that each text-node template expression
-        // will be contained in its own text node. Adjacent static text will be in
-        // separate text nodes.
-        const entry = ctx.preparsedJsExpressions.get(location.startOffset);
-        if (!entry?.parsedExpression) {
-            throw new Error('Implementation error: cannot find preparsed template expression');
-        }
-        const value = {
-            ...entry.parsedExpression,
-            location: sourceLocation(location),
-        };
-        return [text(rawText, value, location)];
-    }
-    // Split the text node content arround expression and create node for each
+    // Split the text node content around expression and create node for each
     const tokenizedContent = rawText.split(EXPRESSION_RE);
     for (const token of tokenizedContent) {
         // Don't create nodes for emtpy strings
@@ -11750,7 +11527,7 @@ function parseText(ctx, parse5Text) {
         }
         let value;
         if (isExpression(token)) {
-            value = parseExpression(ctx, token, sourceLocation(location));
+            value = parseExpression(ctx, token, sourceLocation);
         }
         else {
             value = literal(decodeTextContent(token));
@@ -11759,6 +11536,53 @@ function parseText(ctx, parse5Text) {
     }
     return parsedTextNodes;
 }
+function parseTextComplex(ctx, rawText, sourceLocation, location) {
+    const parsedTextNodes = [];
+    let start = 0;
+    let index = 0;
+    const templateSource = cleanTextNode(ctx.getSource(location.startOffset));
+    while (index < rawText.length) {
+        if (rawText[index] === EXPRESSION_SYMBOL_START) {
+            // Parse any literal that preceeded the expression
+            if (start < index) {
+                const literalToken = rawText.slice(start, index);
+                parsedTextNodes.push(text(literalToken, literal(decodeTextContent(literalToken)), location));
+            }
+            const parsed = parseComplexExpression(ctx, rawText, templateSource, sourceLocation, index);
+            parsedTextNodes.push(text(parsed.raw, parsed.expression, location));
+            // Parse the remainder of the text node for expressions
+            index += parsed.raw.length;
+            start = index;
+            continue;
+        }
+        index++;
+    }
+    // Parse any remaining literal
+    if (start < rawText.length) {
+        const literalToken = rawText.slice(start, index);
+        parsedTextNodes.push(text(literalToken, literal(decodeTextContent(literalToken)), location));
+    }
+    return parsedTextNodes;
+}
+function parseTextNode(ctx, parse5Text) {
+    const location = parse5Text.sourceCodeLocation;
+    /* istanbul ignore if */
+    if (!location) {
+        // Parse5 will recover from invalid HTML. When this happens the node's sourceCodeLocation will be undefined.
+        // https://github.com/inikulin/parse5/blob/master/packages/parse5/docs/options/parser-options.md#sourcecodelocationinfo
+        // This is a defensive check as this should never happen for TextNode.
+        throw new Error('An internal parsing error occurred during node creation; a text node was found without a sourceCodeLocation.');
+    }
+    // Extract the raw source to avoid HTML entity decoding done by parse5
+    const rawText = cleanTextNode(ctx.getSource(location.startOffset, location.endOffset));
+    if (!rawText.trim().length) {
+        return [];
+    }
+    const sourceLocation$1 = sourceLocation(location);
+    return ctx.config.experimentalComplexExpressions
+        ? parseTextComplex(ctx, rawText, sourceLocation$1, location)
+        : parseText(ctx, rawText, sourceLocation$1, location);
+}
 function parseComment(parse5Comment) {
     const location = parse5Comment.sourceCodeLocation;
     /* istanbul ignore if */
@@ -11773,7 +11597,7 @@ function parseComment(parse5Comment) {
 function getTemplateRoot(ctx, documentFragment) {
     // Filter all the empty text nodes
     const validRoots = documentFragment.childNodes.filter((child) => isElementNode(child) ||
-        (isTextNode$1(child) && child.value.trim().length));
+        (isTextNode(child) && child.value.trim().length));
     if (validRoots.length > 1) {
         const duplicateRoot = validRoots[1].sourceCodeLocation ?? undefined;
         ctx.throw(errors.ParserDiagnostics.MULTIPLE_ROOTS_FOUND, [], duplicateRoot ? sourceLocation(duplicateRoot) : (duplicateRoot ?? undefined));
@@ -12628,13 +12452,22 @@ function getTemplateAttribute(ctx, tag, attribute$1, attributeLocation) {
         ]);
     }
     const isBooleanAttribute = !rawAttribute.includes('=');
-    const { value, escapedExpression } = normalizeAttributeValue(ctx, rawAttribute, tag, attribute$1, location);
+    const { value, escapedExpression, quotedExpression } = normalizeAttributeValue(ctx, rawAttribute, tag, attribute$1, location);
     let attrValue;
-    // TODO [#3370]: If complex template expressions are adopted, `preparsedJsExpressions`
-    // should be checked. However, to avoid significant complications in the internal types,
-    // arising from supporting both implementations simultaneously, we will re-parse the
-    // expression here when `ctx.config.experimentalComplexExpressions` is true.
-    if (isExpression(value) && !escapedExpression) {
+    /*
+        A complex attribute expression should only be parsed as a complex expression if it has been quoted.
+        Quoting complex expressions ensures that the expression is valid HTML. If the complex expression
+        has not been quoted, then it is parsed as a legacy expression and it will fail with an appropriate explanation.
+        This ensures backward compatibility with legacy expressions which do not require, or currently permit quotes
+        to be used.
+    */
+    const isPotentialComplexExpression = quotedExpression && !escapedExpression && value.startsWith(EXPRESSION_SYMBOL_START);
+    if (ctx.config.experimentalComplexExpressions && isPotentialComplexExpression) {
+        const attributeNameOffset = attribute$1.name.length + 2; // The +2 accounts for the '="' in the attribute: attr="...
+        const templateSource = ctx.getSource(attributeLocation.startOffset + attributeNameOffset);
+        attrValue = parseComplexExpression(ctx, value, templateSource, location).expression;
+    }
+    else if (isExpression(value) && !escapedExpression) {
         attrValue = parseExpression(ctx, value, location);
     }
     else if (isBooleanAttribute) {
@@ -14716,5 +14549,5 @@ exports.generateScopeTokens = generateScopeTokens;
 exports.kebabcaseToCamelcase = kebabcaseToCamelcase;
 exports.parse = parse;
 exports.toPropertyName = toPropertyName;
-/** version: 8.21.6 */
+/** version: 8.22.3 */
 //# sourceMappingURL=index.cjs.js.map