@angular/compiler 14.0.0-next.12 → 14.0.0-next.15

package/fesm2015/compiler.mjs

@@ -1,5 +1,5 @@
 /**
- * @license Angular v14.0.0-next.12
+ * @license Angular v14.0.0-next.15
  * (c) 2010-2022 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -756,13 +756,13 @@ class Version {
         this.patch = splits.slice(2).join('.');
     }
 }
-const __window = typeof window !== 'undefined' && window;
-const __self = typeof self !== 'undefined' && typeof WorkerGlobalScope !== 'undefined' &&
-    self instanceof WorkerGlobalScope && self;
-const __global = typeof global !== 'undefined' && global;
-// Check __global first, because in Node tests both __global and __window may be defined and _global
-// should be __global in that case.
-const _global = __global || __window || __self;
+// Check `global` first, because in Node tests both `global` and `window` may be defined and our
+// `_global` variable should point to the NodeJS `global` in that case. Note: Typeof/Instanceof
+// checks are considered side-effects in Terser. We explicitly mark this as side-effect free:
+// https://github.com/terser/terser/issues/250.
+const _global = ( /* @__PURE__ */(() => (typeof global !== 'undefined' && global) || (typeof window !== 'undefined' && window) ||
+    (typeof self !== 'undefined' && typeof WorkerGlobalScope !== 'undefined' &&
+        self instanceof WorkerGlobalScope && self))());
 function newArray(size, value) {
     const list = [];
     for (let i = 0; i < size; i++) {
@@ -2924,6 +2924,7 @@ Identifiers.contentQuery = { name: 'ɵɵcontentQuery', moduleName: CORE };
 Identifiers.NgOnChangesFeature = { name: 'ɵɵNgOnChangesFeature', moduleName: CORE };
 Identifiers.InheritDefinitionFeature = { name: 'ɵɵInheritDefinitionFeature', moduleName: CORE };
 Identifiers.CopyDefinitionFeature = { name: 'ɵɵCopyDefinitionFeature', moduleName: CORE };
+Identifiers.StandaloneFeature = { name: 'ɵɵStandaloneFeature', moduleName: CORE };
 Identifiers.ProvidersFeature = { name: 'ɵɵProvidersFeature', moduleName: CORE };
 Identifiers.listener = { name: 'ɵɵlistener', moduleName: CORE };
 Identifiers.getInheritedFactory = {
@@ -4795,7 +4796,7 @@ function assembleBoundTextPlaceholders(meta, bindingStartIndex = 0, contextId =
  * @param useCamelCase whether to camelCase the placeholder name when formatting.
  * @returns A new map of formatted placeholder names to expressions.
  */
-function i18nFormatPlaceholderNames(params = {}, useCamelCase) {
+function formatI18nPlaceholderNamesInMap(params = {}, useCamelCase) {
     const _params = {};
     if (params && Object.keys(params).length) {
         Object.keys(params).forEach(key => _params[formatI18nPlaceholderName(key, useCamelCase)] = params[key]);
@@ -4878,6 +4879,12 @@ const IMPLICIT_REFERENCE = '$implicit';
 const NON_BINDABLE_ATTR = 'ngNonBindable';
 /** Name for the variable keeping track of the context returned by `ɵɵrestoreView`. */
 const RESTORED_VIEW_CONTEXT_NAME = 'restoredCtx';
+/**
+ * Maximum length of a single instruction chain. Because our output AST uses recursion, we're
+ * limited in how many expressions we can nest before we reach the call stack limit. This
+ * length is set very conservatively in order to reduce the chance of problems.
+ */
+const MAX_CHAIN_LENGTH = 500;
 /** Instructions that support chaining. */
 const CHAINABLE_INSTRUCTIONS = new Set([
     Identifiers.element,
@@ -5104,15 +5111,17 @@ function getInstructionStatements(instructions) {
     const statements = [];
     let pendingExpression = null;
     let pendingExpressionType = null;
+    let chainLength = 0;
     for (const current of instructions) {
         const resolvedParams = (_a = (typeof current.paramsOrFn === 'function' ? current.paramsOrFn() : current.paramsOrFn)) !== null && _a !== void 0 ? _a : [];
         const params = Array.isArray(resolvedParams) ? resolvedParams : [resolvedParams];
         // If the current instruction is the same as the previous one
         // and it can be chained, add another call to the chain.
-        if (pendingExpressionType === current.reference &&
+        if (chainLength < MAX_CHAIN_LENGTH && pendingExpressionType === current.reference &&
             CHAINABLE_INSTRUCTIONS.has(pendingExpressionType)) {
             // We'll always have a pending expression when there's a pending expression type.
             pendingExpression = pendingExpression.callFn(params, pendingExpression.sourceSpan);
+            chainLength++;
         }
         else {
             if (pendingExpression !== null) {
@@ -5120,6 +5129,7 @@ function getInstructionStatements(instructions) {
             }
             pendingExpression = invokeInstruction(current.span, current.reference, params);
             pendingExpressionType = current.reference;
+            chainLength = 0;
         }
     }
     // Since the current instruction adds the previous one to the statements,
@@ -6153,9 +6163,24 @@ function createPipeType(metadata) {
     return new ExpressionType(importExpr(Identifiers.PipeDeclaration, [
         typeWithParameters(metadata.type.type, metadata.typeArgumentCount),
         new ExpressionType(new LiteralExpr(metadata.pipeName)),
+        new ExpressionType(new LiteralExpr(metadata.isStandalone)),
     ]));
 }
 
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+var R3TemplateDependencyKind;
+(function (R3TemplateDependencyKind) {
+    R3TemplateDependencyKind[R3TemplateDependencyKind["Directive"] = 0] = "Directive";
+    R3TemplateDependencyKind[R3TemplateDependencyKind["Pipe"] = 1] = "Pipe";
+    R3TemplateDependencyKind[R3TemplateDependencyKind["NgModule"] = 2] = "NgModule";
+})(R3TemplateDependencyKind || (R3TemplateDependencyKind = {}));
+
 /**
  * @license
  * Copyright Google LLC All Rights Reserved.
@@ -7653,7 +7678,26 @@ class BuiltinFunctionCall extends Call {
  * found in the LICENSE file at https://angular.io/license
  */
 /**
- * This file is a port of shadowCSS from webcomponents.js to TypeScript.
+ * The following set contains all keywords that can be used in the animation css shorthand
+ * property and is used during the scoping of keyframes to make sure such keywords
+ * are not modified.
+ */
+const animationKeywords = new Set([
+    // global values
+    'inherit', 'initial', 'revert', 'unset',
+    // animation-direction
+    'alternate', 'alternate-reverse', 'normal', 'reverse',
+    // animation-fill-mode
+    'backwards', 'both', 'forwards', 'none',
+    // animation-play-state
+    'paused', 'running',
+    // animation-timing-function
+    'ease', 'ease-in', 'ease-in-out', 'ease-out', 'linear', 'step-start', 'step-end',
+    // `steps()` function
+    'end', 'jump-both', 'jump-end', 'jump-none', 'jump-start', 'start'
+]);
+/**
+ * The following class is a port of shadowCSS from webcomponents.js to TypeScript.
  *
  * Please make sure to keep to edits in sync with the source file.
  *
@@ -7779,6 +7823,21 @@ class BuiltinFunctionCall extends Call {
 class ShadowCss {
     constructor() {
         this.strictStyling = true;
+        /**
+         * Regular expression used to extrapolate the possible keyframes from an
+         * animation declaration (with possibly multiple animation definitions)
+         *
+         * The regular expression can be divided in three parts
+         *  - (^|\s+)
+         *    simply captures how many (if any) leading whitespaces are present
+         *  - (?:(?:(['"])((?:\\\\|\\\2|(?!\2).)+)\2)|(-?[A-Za-z][\w\-]*))
+         *    captures two different possible keyframes, ones which are quoted or ones which are valid css
+         * idents (custom properties excluded)
+         *  - (?=[,\s;]|$)
+         *    simply matches the end of the possible keyframe, valid endings are: a comma, a space, a
+         * semicolon or the end of the string
+         */
+        this._animationDeclarationKeyframesRe = /(^|\s+)(?:(?:(['"])((?:\\\\|\\\2|(?!\2).)+)\2)|(-?[A-Za-z][\w\-]*))(?=[,\s]|$)/g;
     }
     /*
      * Shim some cssText with the given selector. Returns cssText that can
@@ -7799,6 +7858,140 @@ class ShadowCss {
         cssText = this._insertPolyfillDirectivesInCssText(cssText);
         return this._insertPolyfillRulesInCssText(cssText);
     }
+    /**
+     * Process styles to add scope to keyframes.
+     *
+     * Modify both the names of the keyframes defined in the component styles and also the css
+     * animation rules using them.
+     *
+     * Animation rules using keyframes defined elsewhere are not modified to allow for globally
+     * defined keyframes.
+     *
+     * For example, we convert this css:
+     *
+     * ```
+     * .box {
+     *   animation: box-animation 1s forwards;
+     * }
+     *
+     * @keyframes box-animation {
+     *   to {
+     *     background-color: green;
+     *   }
+     * }
+     * ```
+     *
+     * to this:
+     *
+     * ```
+     * .box {
+     *   animation: scopeName_box-animation 1s forwards;
+     * }
+     *
+     * @keyframes scopeName_box-animation {
+     *   to {
+     *     background-color: green;
+     *   }
+     * }
+     * ```
+     *
+     * @param cssText the component's css text that needs to be scoped.
+     * @param scopeSelector the component's scope selector.
+     *
+     * @returns the scoped css text.
+     */
+    _scopeKeyframesRelatedCss(cssText, scopeSelector) {
+        const unscopedKeyframesSet = new Set();
+        const scopedKeyframesCssText = processRules(cssText, rule => this._scopeLocalKeyframeDeclarations(rule, scopeSelector, unscopedKeyframesSet));
+        return processRules(scopedKeyframesCssText, rule => this._scopeAnimationRule(rule, scopeSelector, unscopedKeyframesSet));
+    }
+    /**
+     * Scopes local keyframes names, returning the updated css rule and it also
+     * adds the original keyframe name to a provided set to collect all keyframes names
+     * so that it can later be used to scope the animation rules.
+     *
+     * For example, it takes a rule such as:
+     *
+     * ```
+     * @keyframes box-animation {
+     *   to {
+     *     background-color: green;
+     *   }
+     * }
+     * ```
+     *
+     * and returns:
+     *
+     * ```
+     * @keyframes scopeName_box-animation {
+     *   to {
+     *     background-color: green;
+     *   }
+     * }
+     * ```
+     * and as a side effect it adds "box-animation" to the `unscopedKeyframesSet` set
+     *
+     * @param cssRule the css rule to process.
+     * @param scopeSelector the component's scope selector.
+     * @param unscopedKeyframesSet the set of unscoped keyframes names (which can be
+     * modified as a side effect)
+     *
+     * @returns the css rule modified with the scoped keyframes name.
+     */
+    _scopeLocalKeyframeDeclarations(rule, scopeSelector, unscopedKeyframesSet) {
+        return Object.assign(Object.assign({}, rule), { selector: rule.selector.replace(/(^@(?:-webkit-)?keyframes(?:\s+))(['"]?)(.+)\2(\s*)$/, (_, start, quote, keyframeName, endSpaces) => {
+                unscopedKeyframesSet.add(unescapeQuotes(keyframeName, quote));
+                return `${start}${quote}${scopeSelector}_${keyframeName}${quote}${endSpaces}`;
+            }) });
+    }
+    /**
+     * Function used to scope a keyframes name (obtained from an animation declaration)
+     * using an existing set of unscopedKeyframes names to discern if the scoping needs to be
+     * performed (keyframes names of keyframes not defined in the component's css need not to be
+     * scoped).
+     *
+     * @param keyframe the keyframes name to check.
+     * @param scopeSelector the component's scope selector.
+     * @param unscopedKeyframesSet the set of unscoped keyframes names.
+     *
+     * @returns the scoped name of the keyframe, or the original name is the name need not to be
+     * scoped.
+     */
+    _scopeAnimationKeyframe(keyframe, scopeSelector, unscopedKeyframesSet) {
+        return keyframe.replace(/^(\s*)(['"]?)(.+?)\2(\s*)$/, (_, spaces1, quote, name, spaces2) => {
+            name = `${unscopedKeyframesSet.has(unescapeQuotes(name, quote)) ? scopeSelector + '_' : ''}${name}`;
+            return `${spaces1}${quote}${name}${quote}${spaces2}`;
+        });
+    }
+    /**
+     * Scope an animation rule so that the keyframes mentioned in such rule
+     * are scoped if defined in the component's css and left untouched otherwise.
+     *
+     * It can scope values of both the 'animation' and 'animation-name' properties.
+     *
+     * @param rule css rule to scope.
+     * @param scopeSelector the component's scope selector.
+     * @param unscopedKeyframesSet the set of unscoped keyframes names.
+     *
+     * @returns the updated css rule.
+     **/
+    _scopeAnimationRule(rule, scopeSelector, unscopedKeyframesSet) {
+        let content = rule.content.replace(/((?:^|\s+)(?:-webkit-)?animation(?:\s*):(?:\s*))([^;]+)/g, (_, start, animationDeclarations) => start +
+            animationDeclarations.replace(this._animationDeclarationKeyframesRe, (original, leadingSpaces, quote = '', quotedName, nonQuotedName) => {
+                if (quotedName) {
+                    return `${leadingSpaces}${this._scopeAnimationKeyframe(`${quote}${quotedName}${quote}`, scopeSelector, unscopedKeyframesSet)}`;
+                }
+                else {
+                    return animationKeywords.has(nonQuotedName) ?
+                        original :
+                        `${leadingSpaces}${this._scopeAnimationKeyframe(nonQuotedName, scopeSelector, unscopedKeyframesSet)}`;
+                }
+            }));
+        content = content.replace(/((?:^|\s+)(?:-webkit-)?animation-name(?:\s*):(?:\s*))([^;]+)/g, (_match, start, commaSeparatedKeyframes) => `${start}${commaSeparatedKeyframes.split(',')
+            .map((keyframe) => this._scopeAnimationKeyframe(keyframe, scopeSelector, unscopedKeyframesSet))
+            .join(',')}`);
+        return Object.assign(Object.assign({}, rule), { content });
+    }
     /*
      * Process styles to convert native ShadowDOM rules that will trip
      * up the css parser; we rely on decorating the stylesheet with inert rules.
@@ -7857,6 +8050,7 @@ class ShadowCss {
         cssText = this._convertColonHostContext(cssText);
         cssText = this._convertShadowDOMSelectors(cssText);
         if (scopeSelector) {
+            cssText = this._scopeKeyframesRelatedCss(cssText, scopeSelector);
             cssText = this._scopeSelectors(cssText, scopeSelector, hostSelector);
         }
         cssText = cssText + '\n' + unscopedRules;
@@ -8229,11 +8423,14 @@ function extractCommentsWithHash(input) {
     return input.match(_commentWithHashRe) || [];
 }
 const BLOCK_PLACEHOLDER = '%BLOCK%';
-const QUOTE_PLACEHOLDER = '%QUOTED%';
 const _ruleRe = /(\s*)([^;\{\}]+?)(\s*)((?:{%BLOCK%}?\s*;?)|(?:\s*;))/g;
-const _quotedRe = /%QUOTED%/g;
 const CONTENT_PAIRS = new Map([['{', '}']]);
-const QUOTE_PAIRS = new Map([[`"`, `"`], [`'`, `'`]]);
+const COMMA_IN_PLACEHOLDER = '%COMMA_IN_PLACEHOLDER%';
+const SEMI_IN_PLACEHOLDER = '%SEMI_IN_PLACEHOLDER%';
+const COLON_IN_PLACEHOLDER = '%COLON_IN_PLACEHOLDER%';
+const _cssCommaInPlaceholderReGlobal = new RegExp(COMMA_IN_PLACEHOLDER, 'g');
+const _cssSemiInPlaceholderReGlobal = new RegExp(SEMI_IN_PLACEHOLDER, 'g');
+const _cssColonInPlaceholderReGlobal = new RegExp(COLON_IN_PLACEHOLDER, 'g');
 class CssRule {
     constructor(selector, content) {
         this.selector = selector;
@@ -8241,12 +8438,10 @@ class CssRule {
     }
 }
 function processRules(input, ruleCallback) {
-    const inputWithEscapedQuotes = escapeBlocks(input, QUOTE_PAIRS, QUOTE_PLACEHOLDER);
-    const inputWithEscapedBlocks = escapeBlocks(inputWithEscapedQuotes.escapedString, CONTENT_PAIRS, BLOCK_PLACEHOLDER);
+    const escaped = escapeInStrings(input);
+    const inputWithEscapedBlocks = escapeBlocks(escaped, CONTENT_PAIRS, BLOCK_PLACEHOLDER);
     let nextBlockIndex = 0;
-    let nextQuoteIndex = 0;
-    return inputWithEscapedBlocks.escapedString
-        .replace(_ruleRe, (...m) => {
+    const escapedResult = inputWithEscapedBlocks.escapedString.replace(_ruleRe, (...m) => {
         const selector = m[2];
         let content = '';
         let suffix = m[4];
@@ -8258,8 +8453,8 @@ function processRules(input, ruleCallback) {
         }
         const rule = ruleCallback(new CssRule(selector, content));
         return `${m[1]}${rule.selector}${m[3]}${contentPrefix}${rule.content}${suffix}`;
-    })
-        .replace(_quotedRe, () => inputWithEscapedQuotes.blocks[nextQuoteIndex++]);
+    });
+    return unescapeInStrings(escapedResult);
 }
 class StringWithEscapedBlocks {
     constructor(escapedString, blocks) {
@@ -8310,6 +8505,112 @@ function escapeBlocks(input, charPairs, placeholder) {
     }
     return new StringWithEscapedBlocks(resultParts.join(''), escapedBlocks);
 }
+/**
+ * Object containing as keys characters that should be substituted by placeholders
+ * when found in strings during the css text parsing, and as values the respective
+ * placeholders
+ */
+const ESCAPE_IN_STRING_MAP = {
+    ';': SEMI_IN_PLACEHOLDER,
+    ',': COMMA_IN_PLACEHOLDER,
+    ':': COLON_IN_PLACEHOLDER
+};
+/**
+ * Parse the provided css text and inside strings (meaning, inside pairs of unescaped single or
+ * double quotes) replace specific characters with their respective placeholders as indicated
+ * by the `ESCAPE_IN_STRING_MAP` map.
+ *
+ * For example convert the text
+ *  `animation: "my-anim:at\"ion" 1s;`
+ * to
+ *  `animation: "my-anim%COLON_IN_PLACEHOLDER%at\"ion" 1s;`
+ *
+ * This is necessary in order to remove the meaning of some characters when found inside strings
+ * (for example `;` indicates the end of a css declaration, `,` the sequence of values and `:` the
+ * division between property and value during a declaration, none of these meanings apply when such
+ * characters are within strings and so in order to prevent parsing issues they need to be replaced
+ * with placeholder text for the duration of the css manipulation process).
+ *
+ * @param input the original css text.
+ *
+ * @returns the css text with specific characters in strings replaced by placeholders.
+ **/
+function escapeInStrings(input) {
+    let result = input;
+    let currentQuoteChar = null;
+    for (let i = 0; i < result.length; i++) {
+        const char = result[i];
+        if (char === '\\') {
+            i++;
+        }
+        else {
+            if (currentQuoteChar !== null) {
+                // index i is inside a quoted sub-string
+                if (char === currentQuoteChar) {
+                    currentQuoteChar = null;
+                }
+                else {
+                    const placeholder = ESCAPE_IN_STRING_MAP[char];
+                    if (placeholder) {
+                        result = `${result.substr(0, i)}${placeholder}${result.substr(i + 1)}`;
+                        i += placeholder.length - 1;
+                    }
+                }
+            }
+            else if (char === '\'' || char === '"') {
+                currentQuoteChar = char;
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Replace in a string all occurrences of keys in the `ESCAPE_IN_STRING_MAP` map with their
+ * original representation, this is simply used to revert the changes applied by the
+ * escapeInStrings function.
+ *
+ * For example it reverts the text:
+ *  `animation: "my-anim%COLON_IN_PLACEHOLDER%at\"ion" 1s;`
+ * to it's original form of:
+ *  `animation: "my-anim:at\"ion" 1s;`
+ *
+ * Note: For the sake of simplicity this function does not check that the placeholders are
+ * actually inside strings as it would anyway be extremely unlikely to find them outside of strings.
+ *
+ * @param input the css text containing the placeholders.
+ *
+ * @returns the css text without the placeholders.
+ */
+function unescapeInStrings(input) {
+    let result = input.replace(_cssCommaInPlaceholderReGlobal, ',');
+    result = result.replace(_cssSemiInPlaceholderReGlobal, ';');
+    result = result.replace(_cssColonInPlaceholderReGlobal, ':');
+    return result;
+}
+/**
+ * Unescape all quotes present in a string, but only if the string was actually already
+ * quoted.
+ *
+ * This generates a "canonical" representation of strings which can be used to match strings
+ * which would otherwise only differ because of differently escaped quotes.
+ *
+ * For example it converts the string (assumed to be quoted):
+ *  `this \\"is\\" a \\'\\\\'test`
+ * to:
+ *  `this "is" a '\\\\'test`
+ * (note that the latter backslashes are not removed as they are not actually escaping the single
+ * quote)
+ *
+ *
+ * @param input the string possibly containing escaped quotes.
+ * @param isQuoted boolean indicating whether the string was quoted inside a bigger string (if not
+ * then it means that it doesn't represent an inner string and thus no unescaping is required)
+ *
+ * @returns the string in the "canonical" representation without escaped quotes.
+ */
+function unescapeQuotes(str, isQuoted) {
+    return !isQuoted ? str : str.replace(/((?:^|[^\\])(?:\\\\)*)\\(?=['"])/g, '$1');
+}
 /**
  * Combine the `contextSelectors` with the `hostMarker` and the `otherSelectors`
  * to create a selector that matches the same as `:host-context()`.
@@ -16763,11 +17064,64 @@ function i18nMetaToJSDoc(meta) {
 
 /** Closure uses `goog.getMsg(message)` to lookup translations */
 const GOOG_GET_MSG = 'goog.getMsg';
-function createGoogleGetMsgStatements(variable$1, message, closureVar, params) {
+/**
+ * Generates a `goog.getMsg()` statement and reassignment. The template:
+ *
+ * ```html
+ * <div i18n>Sent from {{ sender }} to <span class="receiver">{{ receiver }}</span></div>
+ * ```
+ *
+ * Generates:
+ *
+ * ```typescript
+ * const MSG_FOO = goog.getMsg(
+ *   // Message template.
+ *   'Sent from {$interpolation} to {$startTagSpan}{$interpolation_1}{$closeTagSpan}.',
+ *   // Placeholder values, set to magic strings which get replaced by the Angular runtime.
+ *   {
+ *     'interpolation': '\uFFFD0\uFFFD',
+ *     'startTagSpan': '\uFFFD1\uFFFD',
+ *     'interpolation_1': '\uFFFD2\uFFFD',
+ *     'closeTagSpan': '\uFFFD3\uFFFD',
+ *   },
+ *   // Options bag.
+ *   {
+ *     // Maps each placeholder to the original Angular source code which generates it's value.
+ *     original_code: {
+ *       'interpolation': '{{ sender }}',
+ *       'startTagSpan': '<span class="receiver">',
+ *       'interploation_1': '{{ receiver }}',
+ *       'closeTagSpan': '</span>',
+ *     },
+ *   },
+ * );
+ * const I18N_0 = MSG_FOO;
+ * ```
+ */
+function createGoogleGetMsgStatements(variable$1, message, closureVar, placeholderValues) {
     const messageString = serializeI18nMessageForGetMsg(message);
     const args = [literal(messageString)];
-    if (Object.keys(params).length) {
-        args.push(mapLiteral(params, true));
+    if (Object.keys(placeholderValues).length) {
+        // Message template parameters containing the magic strings replaced by the Angular runtime with
+        // real data, e.g. `{'interpolation': '\uFFFD0\uFFFD'}`.
+        args.push(mapLiteral(formatI18nPlaceholderNamesInMap(placeholderValues, true /* useCamelCase */), true /* quoted */));
+        // Message options object, which contains original source code for placeholders (as they are
+        // present in a template, e.g.
+        // `{original_code: {'interpolation': '{{ name }}', 'startTagSpan': '<span>'}}`.
+        args.push(mapLiteral({
+            original_code: literalMap(Object.keys(placeholderValues)
+                .map((param) => ({
+                key: formatI18nPlaceholderName(param),
+                quoted: true,
+                value: message.placeholders[param] ?
+                    // Get source span for typical placeholder if it exists.
+                    literal(message.placeholders[param].sourceSpan.toString()) :
+                    // Otherwise must be an ICU expression, get it's source span.
+                    literal(message.placeholderToMessage[param]
+                        .nodes.map((node) => node.sourceSpan.toString())
+                        .join('')),
+            }))),
+        }));
     }
     // /**
     //  * @desc description of message
@@ -17721,7 +18075,7 @@ class TemplateDefinitionBuilder {
         // - all ICU vars (such as `VAR_SELECT` or `VAR_PLURAL`) are replaced with correct values
         const transformFn = (raw) => {
             const params = Object.assign(Object.assign({}, vars), placeholders);
-            const formatted = i18nFormatPlaceholderNames(params, /* useCamelCase */ false);
+            const formatted = formatI18nPlaceholderNamesInMap(params, /* useCamelCase */ false);
             return invokeInstruction(null, Identifiers.i18nPostprocess, [raw, mapLiteral(formatted, true)]);
         };
         // in case the whole i18n message is a single ICU - we do not need to
@@ -18642,7 +18996,7 @@ const NG_I18N_CLOSURE_MODE = 'ngI18nClosureMode';
 function getTranslationDeclStmts(message, variable, closureVar, params = {}, transformFn) {
     const statements = [
         declareI18nVariable(variable),
-        ifStmt(createClosureModeGuard(), createGoogleGetMsgStatements(variable, message, closureVar, i18nFormatPlaceholderNames(params, /* useCamelCase */ true)), createLocalizeStatements(variable, message, i18nFormatPlaceholderNames(params, /* useCamelCase */ false))),
+        ifStmt(createClosureModeGuard(), createGoogleGetMsgStatements(variable, message, closureVar, params), createLocalizeStatements(variable, message, formatI18nPlaceholderNamesInMap(params, /* useCamelCase */ false))),
     ];
     if (transformFn) {
         statements.push(new ExpressionStatement(variable.set(transformFn(variable))));
@@ -18736,6 +19090,10 @@ function addFeatures(definitionMap, meta) {
     if (meta.lifecycle.usesOnChanges) {
         features.push(importExpr(Identifiers.NgOnChangesFeature));
     }
+    // TODO: better way of differentiating component vs directive metadata.
+    if (meta.hasOwnProperty('template') && meta.isStandalone) {
+        features.push(importExpr(Identifiers.StandaloneFeature));
+    }
     if (features.length) {
         definitionMap.set('features', literalArr(features));
     }
@@ -18799,17 +19157,8 @@ function compileComponentFromMetadata(meta, constantPool, bindingParser) {
         definitionMap.set('consts', constsExpr);
     }
     definitionMap.set('template', templateFunctionExpression);
-    // e.g. `directives: [MyDirective]`
-    if (meta.directives.length > 0) {
-        const directivesList = literalArr(meta.directives.map(dir => dir.type));
-        const directivesExpr = compileDeclarationList(directivesList, meta.declarationListEmitMode);
-        definitionMap.set('directives', directivesExpr);
-    }
-    // e.g. `pipes: [MyPipe]`
-    if (meta.pipes.size > 0) {
-        const pipesList = literalArr(Array.from(meta.pipes.values()));
-        const pipesExpr = compileDeclarationList(pipesList, meta.declarationListEmitMode);
-        definitionMap.set('pipes', pipesExpr);
+    if (meta.declarations.length > 0) {
+        definitionMap.set('dependencies', compileDeclarationList(literalArr(meta.declarations.map(decl => decl.type)), meta.declarationListEmitMode));
     }
     if (meta.encapsulation === null) {
         meta.encapsulation = ViewEncapsulation.Emulated;
@@ -18847,8 +19196,9 @@ function compileComponentFromMetadata(meta, constantPool, bindingParser) {
  * to be consumed by upstream compilations.
  */
 function createComponentType(meta) {
-    const typeParams = createDirectiveTypeParams(meta);
+    const typeParams = createBaseDirectiveTypeParams(meta);
     typeParams.push(stringArrayAsType(meta.template.ngContentSelectors));
+    typeParams.push(expressionType(literal(meta.isStandalone)));
     return expressionType(importExpr(Identifiers.ComponentDeclaration, typeParams));
 }
 /**
@@ -18939,7 +19289,7 @@ function stringArrayAsType(arr) {
     return arr.length > 0 ? expressionType(literalArr(arr.map(value => literal(value)))) :
         NONE_TYPE;
 }
-function createDirectiveTypeParams(meta) {
+function createBaseDirectiveTypeParams(meta) {
     // On the type side, remove newlines from the selector as it will need to fit into a TypeScript
     // string literal, which must be on one line.
     const selectorForType = meta.selector !== null ? meta.selector.replace(/\n/g, '') : null;
@@ -18957,7 +19307,11 @@ function createDirectiveTypeParams(meta) {
  * to be consumed by upstream compilations.
  */
 function createDirectiveType(meta) {
-    const typeParams = createDirectiveTypeParams(meta);
+    const typeParams = createBaseDirectiveTypeParams(meta);
+    // Directives have no NgContentSelectors slot, but instead express a `never` type
+    // so that future fields align.
+    typeParams.push(NONE_TYPE);
+    typeParams.push(expressionType(literal(meta.isStandalone)));
     return expressionType(importExpr(Identifiers.DirectiveDeclaration, typeParams));
 }
 // Define and update any view queries
@@ -19320,10 +19674,10 @@ class CompilerFacadeImpl {
             internalType: new WrappedNodeExpr(facade.type),
             typeArgumentCount: facade.typeArgumentCount,
             providedIn: computeProvidedIn(facade.providedIn),
-            useClass: convertToProviderExpression(facade, USE_CLASS),
-            useFactory: wrapExpression(facade, USE_FACTORY),
-            useValue: convertToProviderExpression(facade, USE_VALUE),
-            useExisting: convertToProviderExpression(facade, USE_EXISTING),
+            useClass: convertToProviderExpression(facade, 'useClass'),
+            useFactory: wrapExpression(facade, 'useFactory'),
+            useValue: convertToProviderExpression(facade, 'useValue'),
+            useExisting: convertToProviderExpression(facade, 'useExisting'),
             deps: (_a = facade.deps) === null || _a === void 0 ? void 0 : _a.map(convertR3DependencyMetadata),
         }, 
         /* resolveForwardRefs */ true);
@@ -19337,10 +19691,10 @@ class CompilerFacadeImpl {
             internalType: new WrappedNodeExpr(facade.type),
             typeArgumentCount: 0,
             providedIn: computeProvidedIn(facade.providedIn),
-            useClass: convertToProviderExpression(facade, USE_CLASS),
-            useFactory: wrapExpression(facade, USE_FACTORY),
-            useValue: convertToProviderExpression(facade, USE_VALUE),
-            useExisting: convertToProviderExpression(facade, USE_EXISTING),
+            useClass: convertToProviderExpression(facade, 'useClass'),
+            useFactory: wrapExpression(facade, 'useFactory'),
+            useValue: convertToProviderExpression(facade, 'useValue'),
+            useExisting: convertToProviderExpression(facade, 'useExisting'),
             deps: (_a = facade.deps) === null || _a === void 0 ? void 0 : _a.map(convertR3DeclareDependencyMetadata),
         }, 
         /* resolveForwardRefs */ true);
@@ -19402,7 +19756,7 @@ class CompilerFacadeImpl {
         // Parse the template and check for errors.
         const { template, interpolation } = parseJitTemplate(facade.template, facade.name, sourceMapUrl, facade.preserveWhitespaces, facade.interpolation);
         // Compile the component metadata, including template, into an expression.
-        const meta = Object.assign(Object.assign(Object.assign({}, facade), convertDirectiveFacadeToMetadata(facade)), { selector: facade.selector || this.elementSchemaRegistry.getDefaultComponentElementName(), template, declarationListEmitMode: 0 /* Direct */, styles: [...facade.styles, ...template.styles], encapsulation: facade.encapsulation, interpolation, changeDetection: facade.changeDetection, animations: facade.animations != null ? new WrappedNodeExpr(facade.animations) : null, viewProviders: facade.viewProviders != null ? new WrappedNodeExpr(facade.viewProviders) :
+        const meta = Object.assign(Object.assign(Object.assign({}, facade), convertDirectiveFacadeToMetadata(facade)), { selector: facade.selector || this.elementSchemaRegistry.getDefaultComponentElementName(), template, declarations: facade.declarations.map(convertDeclarationFacadeToMetadata), declarationListEmitMode: 0 /* Direct */, styles: [...facade.styles, ...template.styles], encapsulation: facade.encapsulation, interpolation, changeDetection: facade.changeDetection, animations: facade.animations != null ? new WrappedNodeExpr(facade.animations) : null, viewProviders: facade.viewProviders != null ? new WrappedNodeExpr(facade.viewProviders) :
                 null, relativeContextFilePath: '', i18nUseExternalIds: true });
         const jitExpressionSourceMap = `ng:///${facade.name}.js`;
         return this.compileComponentFromMeta(angularCoreEnv, jitExpressionSourceMap, meta);
@@ -19465,10 +19819,6 @@ class CompilerFacadeImpl {
         return res['$def'];
     }
 }
-const USE_CLASS = Object.keys({ useClass: null })[0];
-const USE_FACTORY = Object.keys({ useFactory: null })[0];
-const USE_VALUE = Object.keys({ useValue: null })[0];
-const USE_EXISTING = Object.keys({ useExisting: null })[0];
 function convertToR3QueryMetadata(facade) {
     return Object.assign(Object.assign({}, facade), { predicate: convertQueryPredicate(facade.predicate), read: facade.read ? new WrappedNodeExpr(facade.read) : null, static: facade.static, emitDistinctChangesOnly: facade.emitDistinctChangesOnly });
 }
@@ -19555,19 +19905,43 @@ function convertOpaqueValuesToExpressions(obj) {
     }
     return result;
 }
-function convertDeclareComponentFacadeToMetadata(declaration, typeSourceSpan, sourceMapUrl) {
-    var _a, _b, _c, _d, _e, _f;
-    const { template, interpolation } = parseJitTemplate(declaration.template, declaration.type.name, sourceMapUrl, (_a = declaration.preserveWhitespaces) !== null && _a !== void 0 ? _a : false, declaration.interpolation);
-    return Object.assign(Object.assign({}, convertDeclareDirectiveFacadeToMetadata(declaration, typeSourceSpan)), { template, styles: (_b = declaration.styles) !== null && _b !== void 0 ? _b : [], directives: ((_c = declaration.components) !== null && _c !== void 0 ? _c : [])
-            .concat((_d = declaration.directives) !== null && _d !== void 0 ? _d : [])
-            .map(convertUsedDirectiveDeclarationToMetadata), pipes: convertUsedPipesToMetadata(declaration.pipes), viewProviders: declaration.viewProviders !== undefined ?
-            new WrappedNodeExpr(declaration.viewProviders) :
-            null, animations: declaration.animations !== undefined ? new WrappedNodeExpr(declaration.animations) :
-            null, changeDetection: (_e = declaration.changeDetection) !== null && _e !== void 0 ? _e : ChangeDetectionStrategy.Default, encapsulation: (_f = declaration.encapsulation) !== null && _f !== void 0 ? _f : ViewEncapsulation.Emulated, interpolation, declarationListEmitMode: 2 /* ClosureResolved */, relativeContextFilePath: '', i18nUseExternalIds: true });
-}
-function convertUsedDirectiveDeclarationToMetadata(declaration) {
+function convertDeclareComponentFacadeToMetadata(decl, typeSourceSpan, sourceMapUrl) {
+    var _a, _b, _c, _d;
+    const { template, interpolation } = parseJitTemplate(decl.template, decl.type.name, sourceMapUrl, (_a = decl.preserveWhitespaces) !== null && _a !== void 0 ? _a : false, decl.interpolation);
+    const declarations = [];
+    if (decl.dependencies) {
+        for (const innerDep of decl.dependencies) {
+            switch (innerDep.kind) {
+                case 'directive':
+                case 'component':
+                    declarations.push(convertDirectiveDeclarationToMetadata(innerDep));
+                    break;
+                case 'pipe':
+                    declarations.push(convertPipeDeclarationToMetadata(innerDep));
+                    break;
+            }
+        }
+    }
+    else if (decl.components || decl.directives || decl.pipes) {
+        // Existing declarations on NPM may not be using the new `dependencies` merged field, and may
+        // have separate fields for dependencies instead. Unify them for JIT compilation.
+        decl.components &&
+            declarations.push(...decl.components.map(dir => convertDirectiveDeclarationToMetadata(dir, /* isComponent */ true)));
+        decl.directives &&
+            declarations.push(...decl.directives.map(dir => convertDirectiveDeclarationToMetadata(dir)));
+        decl.pipes && declarations.push(...convertPipeMapToMetadata(decl.pipes));
+    }
+    return Object.assign(Object.assign({}, convertDeclareDirectiveFacadeToMetadata(decl, typeSourceSpan)), { template, styles: (_b = decl.styles) !== null && _b !== void 0 ? _b : [], declarations, viewProviders: decl.viewProviders !== undefined ? new WrappedNodeExpr(decl.viewProviders) :
+            null, animations: decl.animations !== undefined ? new WrappedNodeExpr(decl.animations) : null, changeDetection: (_c = decl.changeDetection) !== null && _c !== void 0 ? _c : ChangeDetectionStrategy.Default, encapsulation: (_d = decl.encapsulation) !== null && _d !== void 0 ? _d : ViewEncapsulation.Emulated, interpolation, declarationListEmitMode: 2 /* ClosureResolved */, relativeContextFilePath: '', i18nUseExternalIds: true });
+}
+function convertDeclarationFacadeToMetadata(declaration) {
+    return Object.assign(Object.assign({}, declaration), { type: new WrappedNodeExpr(declaration.type) });
+}
+function convertDirectiveDeclarationToMetadata(declaration, isComponent = null) {
     var _a, _b, _c;
     return {
+        kind: R3TemplateDependencyKind.Directive,
+        isComponent: isComponent || declaration.kind === 'component',
         selector: declaration.selector,
         type: new WrappedNodeExpr(declaration.type),
         inputs: (_a = declaration.inputs) !== null && _a !== void 0 ? _a : [],
@@ -19575,16 +19949,24 @@ function convertUsedDirectiveDeclarationToMetadata(declaration) {
         exportAs: (_c = declaration.exportAs) !== null && _c !== void 0 ? _c : null,
     };
 }
-function convertUsedPipesToMetadata(declaredPipes) {
-    const pipes = new Map();
-    if (declaredPipes === undefined) {
-        return pipes;
-    }
-    for (const pipeName of Object.keys(declaredPipes)) {
-        const pipeType = declaredPipes[pipeName];
-        pipes.set(pipeName, new WrappedNodeExpr(pipeType));
+function convertPipeMapToMetadata(pipes) {
+    if (!pipes) {
+        return [];
     }
-    return pipes;
+    return Object.keys(pipes).map(name => {
+        return {
+            kind: R3TemplateDependencyKind.Pipe,
+            name,
+            type: new WrappedNodeExpr(pipes[name]),
+        };
+    });
+}
+function convertPipeDeclarationToMetadata(pipe) {
+    return {
+        kind: R3TemplateDependencyKind.Pipe,
+        name: pipe.name,
+        type: new WrappedNodeExpr(pipe.type),
+    };
 }
 function parseJitTemplate(template, typeName, sourceMapUrl, preserveWhitespaces, interpolation) {
     const interpolationConfig = interpolation ? InterpolationConfig.fromArray(interpolation) : DEFAULT_INTERPOLATION_CONFIG;
@@ -19733,7 +20115,7 @@ function publishFacade(global) {
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-const VERSION = new Version('14.0.0-next.12');
+const VERSION = new Version('14.0.0-next.15');
 
 /**
  * @license
@@ -21760,7 +22142,7 @@ const MINIMUM_PARTIAL_LINKER_VERSION$6 = '12.0.0';
 function compileDeclareClassMetadata(metadata) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$6));
-    definitionMap.set('version', literal('14.0.0-next.12'));
+    definitionMap.set('version', literal('14.0.0-next.15'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', metadata.type);
     definitionMap.set('decorators', metadata.decorators);
@@ -21877,9 +22259,12 @@ function compileDeclareDirectiveFromMetadata(meta) {
 function createDirectiveDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$5));
-    definitionMap.set('version', literal('14.0.0-next.12'));
+    definitionMap.set('version', literal('14.0.0-next.15'));
     // e.g. `type: MyDirective`
     definitionMap.set('type', meta.internalType);
+    if (meta.isStandalone) {
+        definitionMap.set('isStandalone', literal(meta.isStandalone));
+    }
     // e.g. `selector: 'some-dir'`
     if (meta.selector !== null) {
         definitionMap.set('selector', literal(meta.selector));
@@ -21984,9 +22369,7 @@ function createComponentDefinitionMap(meta, template, templateInfo) {
         definitionMap.set('isInline', literal(true));
     }
     definitionMap.set('styles', toOptionalLiteralArray(meta.styles, literal));
-    definitionMap.set('components', compileUsedDirectiveMetadata(meta, directive => directive.isComponent === true));
-    definitionMap.set('directives', compileUsedDirectiveMetadata(meta, directive => directive.isComponent !== true));
-    definitionMap.set('pipes', compileUsedPipeMetadata(meta));
+    definitionMap.set('dependencies', compileUsedDependenciesMetadata(meta));
     definitionMap.set('viewProviders', meta.viewProviders);
     definitionMap.set('animations', meta.animations);
     if (meta.changeDetection !== undefined) {
@@ -22042,43 +22425,35 @@ function computeEndLocation(file, contents) {
     } while (lineStart !== -1);
     return new ParseLocation(file, length, line, length - lastLineStart);
 }
-/**
- * Compiles the directives as registered in the component metadata into an array literal of the
- * individual directives. If the component does not use any directives, then null is returned.
- */
-function compileUsedDirectiveMetadata(meta, predicate) {
+function compileUsedDependenciesMetadata(meta) {
     const wrapType = meta.declarationListEmitMode !== 0 /* Direct */ ?
         generateForwardRef :
         (expr) => expr;
-    const directives = meta.directives.filter(predicate);
-    return toOptionalLiteralArray(directives, directive => {
-        const dirMeta = new DefinitionMap();
-        dirMeta.set('type', wrapType(directive.type));
-        dirMeta.set('selector', literal(directive.selector));
-        dirMeta.set('inputs', toOptionalLiteralArray(directive.inputs, literal));
-        dirMeta.set('outputs', toOptionalLiteralArray(directive.outputs, literal));
-        dirMeta.set('exportAs', toOptionalLiteralArray(directive.exportAs, literal));
-        return dirMeta.toLiteralMap();
+    return toOptionalLiteralArray(meta.declarations, decl => {
+        switch (decl.kind) {
+            case R3TemplateDependencyKind.Directive:
+                const dirMeta = new DefinitionMap();
+                dirMeta.set('kind', literal(decl.isComponent ? 'component' : 'directive'));
+                dirMeta.set('type', wrapType(decl.type));
+                dirMeta.set('selector', literal(decl.selector));
+                dirMeta.set('inputs', toOptionalLiteralArray(decl.inputs, literal));
+                dirMeta.set('outputs', toOptionalLiteralArray(decl.outputs, literal));
+                dirMeta.set('exportAs', toOptionalLiteralArray(decl.exportAs, literal));
+                return dirMeta.toLiteralMap();
+            case R3TemplateDependencyKind.Pipe:
+                const pipeMeta = new DefinitionMap();
+                pipeMeta.set('kind', literal('pipe'));
+                pipeMeta.set('type', wrapType(decl.type));
+                pipeMeta.set('name', literal(decl.name));
+                return pipeMeta.toLiteralMap();
+            case R3TemplateDependencyKind.NgModule:
+                const ngModuleMeta = new DefinitionMap();
+                ngModuleMeta.set('kind', literal('ngmodule'));
+                ngModuleMeta.set('type', wrapType(decl.type));
+                return ngModuleMeta.toLiteralMap();
+        }
     });
 }
-/**
- * Compiles the pipes as registered in the component metadata into an object literal, where the
- * pipe's name is used as key and a reference to its type as value. If the component does not use
- * any pipes, then null is returned.
- */
-function compileUsedPipeMetadata(meta) {
-    if (meta.pipes.size === 0) {
-        return null;
-    }
-    const wrapType = meta.declarationListEmitMode !== 0 /* Direct */ ?
-        generateForwardRef :
-        (expr) => expr;
-    const entries = [];
-    for (const [name, pipe] of meta.pipes) {
-        entries.push({ key: name, value: wrapType(pipe), quoted: true });
-    }
-    return literalMap(entries);
-}
 
 /**
  * @license
@@ -22098,7 +22473,7 @@ const MINIMUM_PARTIAL_LINKER_VERSION$4 = '12.0.0';
 function compileDeclareFactoryFunction(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$4));
-    definitionMap.set('version', literal('14.0.0-next.12'));
+    definitionMap.set('version', literal('14.0.0-next.15'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.internalType);
     definitionMap.set('deps', compileDependencies(meta.deps));
@@ -22140,7 +22515,7 @@ function compileDeclareInjectableFromMetadata(meta) {
 function createInjectableDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$3));
-    definitionMap.set('version', literal('14.0.0-next.12'));
+    definitionMap.set('version', literal('14.0.0-next.15'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.internalType);
     // Only generate providedIn property if it has a non-null value
@@ -22198,7 +22573,7 @@ function compileDeclareInjectorFromMetadata(meta) {
 function createInjectorDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$2));
-    definitionMap.set('version', literal('14.0.0-next.12'));
+    definitionMap.set('version', literal('14.0.0-next.15'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.internalType);
     definitionMap.set('providers', meta.providers);
@@ -22235,7 +22610,7 @@ function compileDeclareNgModuleFromMetadata(meta) {
 function createNgModuleDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$1));
-    definitionMap.set('version', literal('14.0.0-next.12'));
+    definitionMap.set('version', literal('14.0.0-next.15'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.internalType);
     // We only generate the keys in the metadata if the arrays contain values.
@@ -22293,10 +22668,13 @@ function compileDeclarePipeFromMetadata(meta) {
 function createPipeDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION));
-    definitionMap.set('version', literal('14.0.0-next.12'));
+    definitionMap.set('version', literal('14.0.0-next.15'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     // e.g. `type: MyPipe`
     definitionMap.set('type', meta.internalType);
+    if (meta.isStandalone) {
+        definitionMap.set('isStandalone', literal(meta.isStandalone));
+    }
     // e.g. `name: "myPipe"`
     definitionMap.set('name', literal(meta.pipeName));
     if (meta.pure === false) {
@@ -22343,5 +22721,5 @@ publishFacade(_global);
  * found in the LICENSE file at https://angular.io/license
  */
 
-export { AST, ASTWithName, ASTWithSource, AbsoluteSourceSpan, ArrayType, AstMemoryEfficientTransformer, AstTransformer, Attribute, Binary, BinaryOperator, BinaryOperatorExpr, BindingPipe, BoundElementProperty, BuiltinType, BuiltinTypeName, CUSTOM_ELEMENTS_SCHEMA, Call, Chain, ChangeDetectionStrategy, CommaExpr, Comment, CompilerConfig, Conditional, ConditionalExpr, ConstantPool, CssSelector, DEFAULT_INTERPOLATION_CONFIG, DYNAMIC_TYPE, DeclareFunctionStmt, DeclareVarStmt, DomElementSchemaRegistry, EOF, Element, ElementSchemaRegistry, EmitterVisitorContext, EmptyExpr, Expansion, ExpansionCase, Expression, ExpressionBinding, ExpressionStatement, ExpressionType, ExternalExpr, ExternalReference, FactoryTarget$1 as FactoryTarget, FunctionExpr, HtmlParser, HtmlTagDefinition, I18NHtmlParser, IfStmt, ImplicitReceiver, InstantiateExpr, Interpolation, InterpolationConfig, InvokeFunctionExpr, JSDocComment, JitEvaluator, KeyedRead, KeyedWrite, LeadingComment, Lexer, LiteralArray, LiteralArrayExpr, LiteralExpr, LiteralMap, LiteralMapExpr, LiteralPrimitive, LocalizedString, MapType, MessageBundle, NONE_TYPE, NO_ERRORS_SCHEMA, NodeWithI18n, NonNullAssert, NotExpr, ParseError, ParseErrorLevel, ParseLocation, ParseSourceFile, ParseSourceSpan, ParseSpan, ParseTreeResult, ParsedEvent, ParsedProperty, ParsedPropertyType, ParsedVariable, Parser$1 as Parser, ParserError, PrefixNot, PropertyRead, PropertyWrite, R3BoundTarget, Identifiers as R3Identifiers, R3SelectorScopeMode, R3TargetBinder, ReadKeyExpr, ReadPropExpr, ReadVarExpr, RecursiveAstVisitor, RecursiveVisitor, ResourceLoader, ReturnStatement, STRING_TYPE, SafeCall, SafeKeyedRead, SafePropertyRead, SelectorContext, SelectorListContext, SelectorMatcher, Serializer, SplitInterpolation, Statement, StmtModifier, TagContentType, TaggedTemplateExpr, TemplateBindingParseResult, TemplateLiteral, TemplateLiteralElement, Text, ThisReceiver, BoundAttribute as TmplAstBoundAttribute, BoundEvent as TmplAstBoundEvent, BoundText as TmplAstBoundText, Content as TmplAstContent, Element$1 as TmplAstElement, Icu$1 as TmplAstIcu, RecursiveVisitor$1 as TmplAstRecursiveVisitor, Reference as TmplAstReference, Template as TmplAstTemplate, Text$3 as TmplAstText, TextAttribute as TmplAstTextAttribute, Variable as TmplAstVariable, Token, TokenType, TreeError, Type, TypeModifier, TypeofExpr, Unary, UnaryOperator, UnaryOperatorExpr, VERSION, VariableBinding, Version, ViewEncapsulation, WrappedNodeExpr, WriteKeyExpr, WritePropExpr, WriteVarExpr, Xliff, Xliff2, Xmb, XmlParser, Xtb, _ParseAST, compileClassMetadata, compileComponentFromMetadata, compileDeclareClassMetadata, compileDeclareComponentFromMetadata, compileDeclareDirectiveFromMetadata, compileDeclareFactoryFunction, compileDeclareInjectableFromMetadata, compileDeclareInjectorFromMetadata, compileDeclareNgModuleFromMetadata, compileDeclarePipeFromMetadata, compileDirectiveFromMetadata, compileFactoryFunction, compileInjectable, compileInjector, compileNgModule, compilePipeFromMetadata, computeMsgId, core, createInjectableType, createMayBeForwardRefExpression, devOnlyGuardedExpression, emitDistinctChangesOnlyDefaultValue, getHtmlTagDefinition, getNsPrefix, getSafePropertyAccessString, identifierName, isIdentifier, isNgContainer, isNgContent, isNgTemplate, jsDocComment, leadingComment, literalMap, makeBindingParser, mergeNsAndName, output_ast as outputAst, parseHostBindings, parseTemplate, preserveWhitespacesDefault, publishFacade, r3JitTypeSourceSpan, sanitizeIdentifier, splitNsName, verifyHostBindings, visitAll };
+export { AST, ASTWithName, ASTWithSource, AbsoluteSourceSpan, ArrayType, AstMemoryEfficientTransformer, AstTransformer, Attribute, Binary, BinaryOperator, BinaryOperatorExpr, BindingPipe, BoundElementProperty, BuiltinType, BuiltinTypeName, CUSTOM_ELEMENTS_SCHEMA, Call, Chain, ChangeDetectionStrategy, CommaExpr, Comment, CompilerConfig, Conditional, ConditionalExpr, ConstantPool, CssSelector, DEFAULT_INTERPOLATION_CONFIG, DYNAMIC_TYPE, DeclareFunctionStmt, DeclareVarStmt, DomElementSchemaRegistry, EOF, Element, ElementSchemaRegistry, EmitterVisitorContext, EmptyExpr, Expansion, ExpansionCase, Expression, ExpressionBinding, ExpressionStatement, ExpressionType, ExternalExpr, ExternalReference, FactoryTarget$1 as FactoryTarget, FunctionExpr, HtmlParser, HtmlTagDefinition, I18NHtmlParser, IfStmt, ImplicitReceiver, InstantiateExpr, Interpolation, InterpolationConfig, InvokeFunctionExpr, JSDocComment, JitEvaluator, KeyedRead, KeyedWrite, LeadingComment, Lexer, LiteralArray, LiteralArrayExpr, LiteralExpr, LiteralMap, LiteralMapExpr, LiteralPrimitive, LocalizedString, MapType, MessageBundle, NONE_TYPE, NO_ERRORS_SCHEMA, NodeWithI18n, NonNullAssert, NotExpr, ParseError, ParseErrorLevel, ParseLocation, ParseSourceFile, ParseSourceSpan, ParseSpan, ParseTreeResult, ParsedEvent, ParsedProperty, ParsedPropertyType, ParsedVariable, Parser$1 as Parser, ParserError, PrefixNot, PropertyRead, PropertyWrite, R3BoundTarget, Identifiers as R3Identifiers, R3SelectorScopeMode, R3TargetBinder, R3TemplateDependencyKind, ReadKeyExpr, ReadPropExpr, ReadVarExpr, RecursiveAstVisitor, RecursiveVisitor, ResourceLoader, ReturnStatement, STRING_TYPE, SafeCall, SafeKeyedRead, SafePropertyRead, SelectorContext, SelectorListContext, SelectorMatcher, Serializer, SplitInterpolation, Statement, StmtModifier, TagContentType, TaggedTemplateExpr, TemplateBindingParseResult, TemplateLiteral, TemplateLiteralElement, Text, ThisReceiver, BoundAttribute as TmplAstBoundAttribute, BoundEvent as TmplAstBoundEvent, BoundText as TmplAstBoundText, Content as TmplAstContent, Element$1 as TmplAstElement, Icu$1 as TmplAstIcu, RecursiveVisitor$1 as TmplAstRecursiveVisitor, Reference as TmplAstReference, Template as TmplAstTemplate, Text$3 as TmplAstText, TextAttribute as TmplAstTextAttribute, Variable as TmplAstVariable, Token, TokenType, TreeError, Type, TypeModifier, TypeofExpr, Unary, UnaryOperator, UnaryOperatorExpr, VERSION, VariableBinding, Version, ViewEncapsulation, WrappedNodeExpr, WriteKeyExpr, WritePropExpr, WriteVarExpr, Xliff, Xliff2, Xmb, XmlParser, Xtb, _ParseAST, compileClassMetadata, compileComponentFromMetadata, compileDeclareClassMetadata, compileDeclareComponentFromMetadata, compileDeclareDirectiveFromMetadata, compileDeclareFactoryFunction, compileDeclareInjectableFromMetadata, compileDeclareInjectorFromMetadata, compileDeclareNgModuleFromMetadata, compileDeclarePipeFromMetadata, compileDirectiveFromMetadata, compileFactoryFunction, compileInjectable, compileInjector, compileNgModule, compilePipeFromMetadata, computeMsgId, core, createInjectableType, createMayBeForwardRefExpression, devOnlyGuardedExpression, emitDistinctChangesOnlyDefaultValue, getHtmlTagDefinition, getNsPrefix, getSafePropertyAccessString, identifierName, isIdentifier, isNgContainer, isNgContent, isNgTemplate, jsDocComment, leadingComment, literalMap, makeBindingParser, mergeNsAndName, output_ast as outputAst, parseHostBindings, parseTemplate, preserveWhitespacesDefault, publishFacade, r3JitTypeSourceSpan, sanitizeIdentifier, splitNsName, verifyHostBindings, visitAll };
 //# sourceMappingURL=compiler.mjs.map