@lwc/template-compiler 3.7.0 → 3.7.2

package/dist/index.js

@@ -158,167 +158,6 @@ function normalizeConfig(config) {
         experimentalComplexExpressions: false, experimentalDynamicDirective: false, enableDynamicComponents: false, enableStaticContentOptimization: true, enableLwcSpread: true }, config), { apiVersion }), { customRendererConfig }), { instrumentation });
 }
 
-function isIdentifier(node) {
-    return node.type === 'Identifier';
-}
-function isMemberExpression(node) {
-    return node.type === 'MemberExpression';
-}
-function isArrayExpression(node) {
-    return node.type === 'ArrayExpression';
-}
-function isObjectExpression(node) {
-    return node.type === 'ObjectExpression';
-}
-function isProperty$1(node) {
-    return node.type === 'Property';
-}
-function isArrowFunctionExpression(node) {
-    return node.type === 'ArrowFunctionExpression';
-}
-function isObjectPattern(node) {
-    return node.type === 'ObjectPattern';
-}
-function isArrayPattern(node) {
-    return node.type === 'ArrayPattern';
-}
-function isRestElement(node) {
-    return node.type === 'RestElement';
-}
-function isAssignmentPattern(node) {
-    return node.type === 'AssigmentPattern';
-}
-function isUnaryExpression(node) {
-    return node.type === 'UnaryExpression';
-}
-function identifier(name, config) {
-    return Object.assign({ type: 'Identifier', name }, config);
-}
-function isLiteral(node) {
-    return node.type === 'Literal';
-}
-function memberExpression(object, property, config) {
-    return Object.assign({ type: 'MemberExpression', object,
-        property, computed: false, optional: false }, config);
-}
-function callExpression(callee, args, config) {
-    return Object.assign({ type: 'CallExpression', callee, arguments: args, optional: false }, config);
-}
-function literal$1(value, config) {
-    return Object.assign({ type: 'Literal', value }, config);
-}
-function conditionalExpression(test, consequent, alternate, config) {
-    return Object.assign({ type: 'ConditionalExpression', test,
-        consequent,
-        alternate }, config);
-}
-function unaryExpression(operator, argument, config) {
-    return Object.assign({ type: 'UnaryExpression', argument,
-        operator, prefix: true }, config);
-}
-function binaryExpression(operator, left, right, config) {
-    return Object.assign({ type: 'BinaryExpression', left,
-        operator,
-        right }, config);
-}
-function logicalExpression(operator, left, right, config) {
-    return Object.assign({ type: 'LogicalExpression', operator,
-        left,
-        right }, config);
-}
-function assignmentExpression(operator, left, right, config) {
-    return Object.assign({ type: 'AssignmentExpression', operator,
-        left,
-        right }, config);
-}
-function property$1(key, value, config) {
-    return Object.assign({ type: 'Property', key,
-        value, kind: 'init', computed: false, method: false, shorthand: false }, config);
-}
-function spreadElement(argument) {
-    return {
-        type: 'SpreadElement',
-        argument,
-    };
-}
-function assignmentProperty(key, value, config) {
-    return Object.assign({ type: 'Property', key,
-        value, kind: 'init', computed: false, method: false, shorthand: false }, config);
-}
-function objectExpression(properties, config) {
-    return Object.assign({ type: 'ObjectExpression', properties }, config);
-}
-function objectPattern(properties, config) {
-    return Object.assign({ type: 'ObjectPattern', properties }, config);
-}
-function arrayExpression(elements, config) {
-    return Object.assign({ type: 'ArrayExpression', elements }, config);
-}
-function expressionStatement(expression, config) {
-    return Object.assign({ type: 'ExpressionStatement', expression }, config);
-}
-function taggedTemplateExpression(tag, quasi) {
-    return {
-        type: 'TaggedTemplateExpression',
-        tag,
-        quasi,
-    };
-}
-function templateLiteral(quasis, expressions) {
-    return {
-        type: 'TemplateLiteral',
-        quasis,
-        expressions,
-    };
-}
-function functionExpression(id, params, body, config) {
-    return Object.assign({ type: 'FunctionExpression', id,
-        params,
-        body }, config);
-}
-function functionDeclaration(id, params, body, config) {
-    return Object.assign({ type: 'FunctionDeclaration', id,
-        params,
-        body }, config);
-}
-function blockStatement(body, config) {
-    return Object.assign({ type: 'BlockStatement', body }, config);
-}
-function returnStatement(argument, config) {
-    return Object.assign({ type: 'ReturnStatement', argument }, config);
-}
-function variableDeclarator(id, init, config) {
-    return Object.assign({ type: 'VariableDeclarator', id,
-        init }, config);
-}
-function variableDeclaration(kind, declarations, config) {
-    return Object.assign({ type: 'VariableDeclaration', kind,
-        declarations }, config);
-}
-function importDeclaration(specifiers, source, config) {
-    return Object.assign({ type: 'ImportDeclaration', specifiers,
-        source }, config);
-}
-function importDefaultSpecifier(local, config) {
-    return Object.assign({ type: 'ImportDefaultSpecifier', local }, config);
-}
-function importSpecifier(imported, local, config) {
-    return Object.assign({ type: 'ImportSpecifier', imported,
-        local }, config);
-}
-function exportDefaultDeclaration(declaration, config) {
-    return Object.assign({ type: 'ExportDefaultDeclaration', declaration }, config);
-}
-function program(body, config) {
-    return Object.assign({ type: 'Program', sourceType: 'module', body }, config);
-}
-function comment$1(content) {
-    return {
-        type: 'Block',
-        value: content,
-    };
-}
-
 const UNDEFINED_CODE_POINTS = new Set([
     65534, 65535, 131070, 131071, 196606, 196607, 262142, 262143, 327678, 327679, 393214,
     393215, 458750, 458751, 524286, 524287, 589822, 589823, 655358, 655359, 720894,
@@ -8722,26 +8561,189 @@ function parseFragment$1(fragmentContext, html, options) {
     return parser.getFragment();
 }
 
-/*
- * 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
+({
+    HTML: NS.HTML,
+    XML: NS.XML,
+    MATHML: NS.MATHML,
+    SVG: NS.SVG,
+    XLINK: NS.XLINK,
+    XMLNS: NS.XMLNS
+});
+
+/**
+ * Determines if a given node is a template node or not
+ * @param {Node} node Node to test
+ * @return {boolean}
  */
-function isElementNode(node) {
-    return node !== null && 'tagName' in node;
+function isTemplateNode(node) {
+    return node.nodeName === 'template';
 }
-function isCommentNode(node) {
-    return node.nodeName === '#comment';
+const isElementNode = defaultTreeAdapter.isElementNode;
+const isCommentNode = defaultTreeAdapter.isCommentNode;
+defaultTreeAdapter.isDocumentTypeNode;
+const isTextNode$1 = defaultTreeAdapter.isTextNode;
+
+defaultTreeAdapter.appendChild;
+
+function isIdentifier(node) {
+    return node.type === 'Identifier';
 }
-function isTextNode$1(node) {
-    return node.nodeName === '#text';
+function isMemberExpression(node) {
+    return node.type === 'MemberExpression';
 }
-function isTemplateNode(node) {
-    return isElementNode(node) && node.tagName === 'template';
+function isArrayExpression(node) {
+    return node.type === 'ArrayExpression';
+}
+function isObjectExpression(node) {
+    return node.type === 'ObjectExpression';
+}
+function isProperty$1(node) {
+    return node.type === 'Property';
+}
+function isArrowFunctionExpression(node) {
+    return node.type === 'ArrowFunctionExpression';
+}
+function isObjectPattern(node) {
+    return node.type === 'ObjectPattern';
+}
+function isArrayPattern(node) {
+    return node.type === 'ArrayPattern';
+}
+function isRestElement(node) {
+    return node.type === 'RestElement';
+}
+function isAssignmentPattern(node) {
+    return node.type === 'AssigmentPattern';
+}
+function isUnaryExpression(node) {
+    return node.type === 'UnaryExpression';
+}
+function identifier(name, config) {
+    return Object.assign({ type: 'Identifier', name }, config);
+}
+function isLiteral(node) {
+    return node.type === 'Literal';
+}
+function memberExpression(object, property, config) {
+    return Object.assign({ type: 'MemberExpression', object,
+        property, computed: false, optional: false }, config);
+}
+function callExpression(callee, args, config) {
+    return Object.assign({ type: 'CallExpression', callee, arguments: args, optional: false }, config);
+}
+function literal$1(value, config) {
+    return Object.assign({ type: 'Literal', value }, config);
+}
+function conditionalExpression(test, consequent, alternate, config) {
+    return Object.assign({ type: 'ConditionalExpression', test,
+        consequent,
+        alternate }, config);
+}
+function unaryExpression(operator, argument, config) {
+    return Object.assign({ type: 'UnaryExpression', argument,
+        operator, prefix: true }, config);
+}
+function binaryExpression(operator, left, right, config) {
+    return Object.assign({ type: 'BinaryExpression', left,
+        operator,
+        right }, config);
+}
+function logicalExpression(operator, left, right, config) {
+    return Object.assign({ type: 'LogicalExpression', operator,
+        left,
+        right }, config);
+}
+function assignmentExpression(operator, left, right, config) {
+    return Object.assign({ type: 'AssignmentExpression', operator,
+        left,
+        right }, config);
+}
+function property$1(key, value, config) {
+    return Object.assign({ type: 'Property', key,
+        value, kind: 'init', computed: false, method: false, shorthand: false }, config);
+}
+function spreadElement(argument) {
+    return {
+        type: 'SpreadElement',
+        argument,
+    };
+}
+function assignmentProperty(key, value, config) {
+    return Object.assign({ type: 'Property', key,
+        value, kind: 'init', computed: false, method: false, shorthand: false }, config);
+}
+function objectExpression(properties, config) {
+    return Object.assign({ type: 'ObjectExpression', properties }, config);
+}
+function objectPattern(properties, config) {
+    return Object.assign({ type: 'ObjectPattern', properties }, config);
+}
+function arrayExpression(elements, config) {
+    return Object.assign({ type: 'ArrayExpression', elements }, config);
+}
+function expressionStatement(expression, config) {
+    return Object.assign({ type: 'ExpressionStatement', expression }, config);
+}
+function taggedTemplateExpression(tag, quasi) {
+    return {
+        type: 'TaggedTemplateExpression',
+        tag,
+        quasi,
+    };
+}
+function templateLiteral(quasis, expressions) {
+    return {
+        type: 'TemplateLiteral',
+        quasis,
+        expressions,
+    };
+}
+function functionExpression(id, params, body, config) {
+    return Object.assign({ type: 'FunctionExpression', id,
+        params,
+        body }, config);
+}
+function functionDeclaration(id, params, body, config) {
+    return Object.assign({ type: 'FunctionDeclaration', id,
+        params,
+        body }, config);
 }
-function getTemplateContent(templateElement) {
-    return isTemplateNode(templateElement) ? templateElement.content : undefined;
+function blockStatement(body, config) {
+    return Object.assign({ type: 'BlockStatement', body }, config);
+}
+function returnStatement(argument, config) {
+    return Object.assign({ type: 'ReturnStatement', argument }, config);
+}
+function variableDeclarator(id, init, config) {
+    return Object.assign({ type: 'VariableDeclarator', id,
+        init }, config);
+}
+function variableDeclaration(kind, declarations, config) {
+    return Object.assign({ type: 'VariableDeclaration', kind,
+        declarations }, config);
+}
+function importDeclaration(specifiers, source, config) {
+    return Object.assign({ type: 'ImportDeclaration', specifiers,
+        source }, config);
+}
+function importDefaultSpecifier(local, config) {
+    return Object.assign({ type: 'ImportDefaultSpecifier', local }, config);
+}
+function importSpecifier(imported, local, config) {
+    return Object.assign({ type: 'ImportSpecifier', imported,
+        local }, config);
+}
+function exportDefaultDeclaration(declaration, config) {
+    return Object.assign({ type: 'ExportDefaultDeclaration', declaration }, config);
+}
+function program(body, config) {
+    return Object.assign({ type: 'Program', sourceType: 'module', body }, config);
+}
+function comment$1(content) {
+    return {
+        type: 'Block',
+        value: content,
+    };
 }
 
 /*
@@ -10630,7 +10632,7 @@ class TemplateHtmlParser extends Parser {
         const textNode = {
             nodeName: '#text',
             value: token.chars,
-            sourceCodeLocation: Object.assign({}, token.location),
+            sourceCodeLocation: token.location ? Object.assign({}, token.location) : null,
             parentNode,
         };
         parentNode.childNodes.push(textNode);
@@ -11192,7 +11194,7 @@ function parseElementLocation(ctx, parse5Elm, parse5ParentLocation) {
     // creates a <tbody> element in the middle without location information. In this case, we
     // can safely skip the closing tag validation.
     let current = parse5Elm;
-    while (!location && isElementNode(current.parentNode)) {
+    while (!location && current.parentNode && isElementNode(current.parentNode)) {
         current = current.parentNode;
         location = current.sourceCodeLocation;
     }
@@ -11282,7 +11284,14 @@ function parseLwcElementAsBuiltIn(ctx, parse5Elm, _parsedAttr, parse5ElmLocation
 }
 function parseChildren(ctx, parse5Parent, parent, parse5ParentLocation) {
     var _a;
-    const children = ((_a = getTemplateContent(parse5Parent)) !== null && _a !== void 0 ? _a : parse5Parent).childNodes;
+    let container = parse5Parent;
+    // `content` isn't nullable but we need to keep the optional chaining
+    // until parse5/tools also asserts that `content` is set. It should be
+    // impossible to have nullish `content`, but templates in SVG can cause it
+    if (isTemplateNode(parse5Parent) && ((_a = parse5Parent.content) === null || _a === void 0 ? void 0 : _a.childNodes.length) > 0) {
+        container = parse5Parent.content;
+    }
+    const children = container.childNodes;
     ctx.beginSiblingScope();
     for (const child of children) {
         ctx.withErrorRecovery(() => {
@@ -11377,11 +11386,12 @@ function parseComment(parse5Comment) {
     return comment(parse5Comment.data, decodeTextContent(parse5Comment.data), location);
 }
 function getTemplateRoot(ctx, documentFragment) {
+    var _a;
     // Filter all the empty text nodes
     const validRoots = documentFragment.childNodes.filter((child) => isElementNode(child) ||
         (isTextNode$1(child) && child.value.trim().length));
     if (validRoots.length > 1) {
-        const duplicateRoot = validRoots[1].sourceCodeLocation;
+        const duplicateRoot = (_a = validRoots[1].sourceCodeLocation) !== null && _a !== void 0 ? _a : undefined;
         ctx.throw(ParserDiagnostics.MULTIPLE_ROOTS_FOUND, [], duplicateRoot ? sourceLocation(duplicateRoot) : duplicateRoot !== null && duplicateRoot !== void 0 ? duplicateRoot : undefined);
     }
     const [root] = validRoots;
@@ -13795,5 +13805,5 @@ function compile(source, config) {
 }
 
 export { ElementDirectiveName, LWCDirectiveDomMode, LWCDirectiveRenderMode, LwcTagName, RootDirectiveName, TemplateDirectiveName, compile, compile as default, parse };
-/** version: 3.7.0 */
+/** version: 3.7.2 */
 //# sourceMappingURL=index.js.map