@angular/language-service 13.0.3 → 13.1.0-next.3

package/bundles/language-service.js

@@ -1,5 +1,5 @@
 /**
- * @license Angular v13.0.3
+ * @license Angular v13.1.0-next.3
  * Copyright Google LLC All Rights Reserved.
  * License: MIT
  */
@@ -27,7 +27,7 @@ module.exports = function(provided) {
   return results;
 };
 
-define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', 'module', 'path', 'url'], (function (exports, ts$1, os, ts, fs$1, module, path, url) { 'use strict';
+define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', 'module', 'path', 'url'], (function (exports, ts$1, os, ts, fs$1, module, p, url) { 'use strict';
 
     function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -53,7 +53,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
     var ts__default = /*#__PURE__*/_interopDefaultLegacy(ts);
     var fs__namespace = /*#__PURE__*/_interopNamespace(fs$1);
     var module__default = /*#__PURE__*/_interopDefaultLegacy(module);
-    var path__namespace = /*#__PURE__*/_interopNamespace(path);
+    var p__namespace = /*#__PURE__*/_interopNamespace(p);
 
     /**
      * The default `FileSystem` that will always fail.
@@ -342,28 +342,28 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             process.chdir(dir);
         }
         resolve(...paths) {
-            return this.normalize(path__namespace.resolve(...paths));
+            return this.normalize(p__namespace.resolve(...paths));
         }
         dirname(file) {
-            return this.normalize(path__namespace.dirname(file));
+            return this.normalize(p__namespace.dirname(file));
         }
         join(basePath, ...paths) {
-            return this.normalize(path__namespace.join(basePath, ...paths));
+            return this.normalize(p__namespace.join(basePath, ...paths));
         }
         isRoot(path) {
             return this.dirname(path) === this.normalize(path);
         }
         isRooted(path) {
-            return path__namespace.isAbsolute(path);
+            return p__namespace.isAbsolute(path);
         }
         relative(from, to) {
-            return this.normalize(path__namespace.relative(from, to));
+            return this.normalize(p__namespace.relative(from, to));
         }
         basename(filePath, extension) {
-            return path__namespace.basename(filePath, extension);
+            return p__namespace.basename(filePath, extension);
         }
         extname(path) {
-            return path__namespace.extname(path);
+            return p__namespace.extname(path);
         }
         normalize(path) {
             // Convert backslashes to forward slashes
@@ -1112,6 +1112,624 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         return selector ? CssSelector.parse(selector).map(parserSelectorToR3Selector) : [];
     }
 
+    /**
+     * @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
+     */
+    const DASH_CASE_REGEXP = /-+([a-z0-9])/g;
+    function dashCaseToCamelCase(input) {
+        return input.replace(DASH_CASE_REGEXP, (...m) => m[1].toUpperCase());
+    }
+    function splitAtColon(input, defaultValues) {
+        return _splitAt(input, ':', defaultValues);
+    }
+    function splitAtPeriod(input, defaultValues) {
+        return _splitAt(input, '.', defaultValues);
+    }
+    function _splitAt(input, character, defaultValues) {
+        const characterIndex = input.indexOf(character);
+        if (characterIndex == -1)
+            return defaultValues;
+        return [input.slice(0, characterIndex).trim(), input.slice(characterIndex + 1).trim()];
+    }
+    function error(msg) {
+        throw new Error(`Internal Error: ${msg}`);
+    }
+    function utf8Encode(str) {
+        let encoded = [];
+        for (let index = 0; index < str.length; index++) {
+            let codePoint = str.charCodeAt(index);
+            // decode surrogate
+            // see https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
+            if (codePoint >= 0xd800 && codePoint <= 0xdbff && str.length > (index + 1)) {
+                const low = str.charCodeAt(index + 1);
+                if (low >= 0xdc00 && low <= 0xdfff) {
+                    index++;
+                    codePoint = ((codePoint - 0xd800) << 10) + low - 0xdc00 + 0x10000;
+                }
+            }
+            if (codePoint <= 0x7f) {
+                encoded.push(codePoint);
+            }
+            else if (codePoint <= 0x7ff) {
+                encoded.push(((codePoint >> 6) & 0x1F) | 0xc0, (codePoint & 0x3f) | 0x80);
+            }
+            else if (codePoint <= 0xffff) {
+                encoded.push((codePoint >> 12) | 0xe0, ((codePoint >> 6) & 0x3f) | 0x80, (codePoint & 0x3f) | 0x80);
+            }
+            else if (codePoint <= 0x1fffff) {
+                encoded.push(((codePoint >> 18) & 0x07) | 0xf0, ((codePoint >> 12) & 0x3f) | 0x80, ((codePoint >> 6) & 0x3f) | 0x80, (codePoint & 0x3f) | 0x80);
+            }
+        }
+        return encoded;
+    }
+    function stringify(token) {
+        if (typeof token === 'string') {
+            return token;
+        }
+        if (Array.isArray(token)) {
+            return '[' + token.map(stringify).join(', ') + ']';
+        }
+        if (token == null) {
+            return '' + token;
+        }
+        if (token.overriddenName) {
+            return `${token.overriddenName}`;
+        }
+        if (token.name) {
+            return `${token.name}`;
+        }
+        if (!token.toString) {
+            return 'object';
+        }
+        // WARNING: do not try to `JSON.stringify(token)` here
+        // see https://github.com/angular/angular/issues/23440
+        const res = token.toString();
+        if (res == null) {
+            return '' + res;
+        }
+        const newLineIndex = res.indexOf('\n');
+        return newLineIndex === -1 ? res : res.substring(0, newLineIndex);
+    }
+    class Version {
+        constructor(full) {
+            this.full = full;
+            const splits = full.split('.');
+            this.major = splits[0];
+            this.minor = splits[1];
+            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;
+    function newArray(size, value) {
+        const list = [];
+        for (let i = 0; i < size; i++) {
+            list.push(value);
+        }
+        return list;
+    }
+    /**
+     * Partitions a given array into 2 arrays, based on a boolean value returned by the condition
+     * function.
+     *
+     * @param arr Input array that should be partitioned
+     * @param conditionFn Condition function that is called for each item in a given array and returns a
+     * boolean value.
+     */
+    function partitionArray(arr, conditionFn) {
+        const truthy = [];
+        const falsy = [];
+        for (const item of arr) {
+            (conditionFn(item) ? truthy : falsy).push(item);
+        }
+        return [truthy, falsy];
+    }
+
+    /**
+     * @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
+     */
+    /**
+     * Represents a big integer using a buffer of its individual digits, with the least significant
+     * digit stored at the beginning of the array (little endian).
+     *
+     * For performance reasons, each instance is mutable. The addition operation can be done in-place
+     * to reduce memory pressure of allocation for the digits array.
+     */
+    class BigInteger {
+        /**
+         * Creates a big integer using its individual digits in little endian storage.
+         */
+        constructor(digits) {
+            this.digits = digits;
+        }
+        static zero() {
+            return new BigInteger([0]);
+        }
+        static one() {
+            return new BigInteger([1]);
+        }
+        /**
+         * Creates a clone of this instance.
+         */
+        clone() {
+            return new BigInteger(this.digits.slice());
+        }
+        /**
+         * Returns a new big integer with the sum of `this` and `other` as its value. This does not mutate
+         * `this` but instead returns a new instance, unlike `addToSelf`.
+         */
+        add(other) {
+            const result = this.clone();
+            result.addToSelf(other);
+            return result;
+        }
+        /**
+         * Adds `other` to the instance itself, thereby mutating its value.
+         */
+        addToSelf(other) {
+            const maxNrOfDigits = Math.max(this.digits.length, other.digits.length);
+            let carry = 0;
+            for (let i = 0; i < maxNrOfDigits; i++) {
+                let digitSum = carry;
+                if (i < this.digits.length) {
+                    digitSum += this.digits[i];
+                }
+                if (i < other.digits.length) {
+                    digitSum += other.digits[i];
+                }
+                if (digitSum >= 10) {
+                    this.digits[i] = digitSum - 10;
+                    carry = 1;
+                }
+                else {
+                    this.digits[i] = digitSum;
+                    carry = 0;
+                }
+            }
+            // Apply a remaining carry if needed.
+            if (carry > 0) {
+                this.digits[maxNrOfDigits] = 1;
+            }
+        }
+        /**
+         * Builds the decimal string representation of the big integer. As this is stored in
+         * little endian, the digits are concatenated in reverse order.
+         */
+        toString() {
+            let res = '';
+            for (let i = this.digits.length - 1; i >= 0; i--) {
+                res += this.digits[i];
+            }
+            return res;
+        }
+    }
+    /**
+     * Represents a big integer which is optimized for multiplication operations, as its power-of-twos
+     * are memoized. See `multiplyBy()` for details on the multiplication algorithm.
+     */
+    class BigIntForMultiplication {
+        constructor(value) {
+            this.powerOfTwos = [value];
+        }
+        /**
+         * Returns the big integer itself.
+         */
+        getValue() {
+            return this.powerOfTwos[0];
+        }
+        /**
+         * Computes the value for `num * b`, where `num` is a JS number and `b` is a big integer. The
+         * value for `b` is represented by a storage model that is optimized for this computation.
+         *
+         * This operation is implemented in N(log2(num)) by continuous halving of the number, where the
+         * least-significant bit (LSB) is tested in each iteration. If the bit is set, the bit's index is
+         * used as exponent into the power-of-two multiplication of `b`.
+         *
+         * As an example, consider the multiplication num=42, b=1337. In binary 42 is 0b00101010 and the
+         * algorithm unrolls into the following iterations:
+         *
+         *  Iteration | num        | LSB  | b * 2^iter | Add? | product
+         * -----------|------------|------|------------|------|--------
+         *  0         | 0b00101010 | 0    | 1337       | No   | 0
+         *  1         | 0b00010101 | 1    | 2674       | Yes  | 2674
+         *  2         | 0b00001010 | 0    | 5348       | No   | 2674
+         *  3         | 0b00000101 | 1    | 10696      | Yes  | 13370
+         *  4         | 0b00000010 | 0    | 21392      | No   | 13370
+         *  5         | 0b00000001 | 1    | 42784      | Yes  | 56154
+         *  6         | 0b00000000 | 0    | 85568      | No   | 56154
+         *
+         * The computed product of 56154 is indeed the correct result.
+         *
+         * The `BigIntForMultiplication` representation for a big integer provides memoized access to the
+         * power-of-two values to reduce the workload in computing those values.
+         */
+        multiplyBy(num) {
+            const product = BigInteger.zero();
+            this.multiplyByAndAddTo(num, product);
+            return product;
+        }
+        /**
+         * See `multiplyBy()` for details. This function allows for the computed product to be added
+         * directly to the provided result big integer.
+         */
+        multiplyByAndAddTo(num, result) {
+            for (let exponent = 0; num !== 0; num = num >>> 1, exponent++) {
+                if (num & 1) {
+                    const value = this.getMultipliedByPowerOfTwo(exponent);
+                    result.addToSelf(value);
+                }
+            }
+        }
+        /**
+         * Computes and memoizes the big integer value for `this.number * 2^exponent`.
+         */
+        getMultipliedByPowerOfTwo(exponent) {
+            // Compute the powers up until the requested exponent, where each value is computed from its
+            // predecessor. This is simple as `this.number * 2^(exponent - 1)` only has to be doubled (i.e.
+            // added to itself) to reach `this.number * 2^exponent`.
+            for (let i = this.powerOfTwos.length; i <= exponent; i++) {
+                const previousPower = this.powerOfTwos[i - 1];
+                this.powerOfTwos[i] = previousPower.add(previousPower);
+            }
+            return this.powerOfTwos[exponent];
+        }
+    }
+    /**
+     * Represents an exponentiation operation for the provided base, of which exponents are computed and
+     * memoized. The results are represented by a `BigIntForMultiplication` which is tailored for
+     * multiplication operations by memoizing the power-of-twos. This effectively results in a matrix
+     * representation that is lazily computed upon request.
+     */
+    class BigIntExponentiation {
+        constructor(base) {
+            this.base = base;
+            this.exponents = [new BigIntForMultiplication(BigInteger.one())];
+        }
+        /**
+         * Compute the value for `this.base^exponent`, resulting in a big integer that is optimized for
+         * further multiplication operations.
+         */
+        toThePowerOf(exponent) {
+            // Compute the results up until the requested exponent, where every value is computed from its
+            // predecessor. This is because `this.base^(exponent - 1)` only has to be multiplied by `base`
+            // to reach `this.base^exponent`.
+            for (let i = this.exponents.length; i <= exponent; i++) {
+                const value = this.exponents[i - 1].multiplyBy(this.base);
+                this.exponents[i] = new BigIntForMultiplication(value);
+            }
+            return this.exponents[exponent];
+        }
+    }
+
+    /**
+     * @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
+     */
+    /**
+     * Compute the message id using the XLIFF1 digest.
+     */
+    function computeDigest(message) {
+        return sha1(serializeNodes(message.nodes).join('') + `[${message.meaning}]`);
+    }
+    /**
+     * Return the message id or compute it using the XLIFF2/XMB/$localize digest.
+     */
+    function decimalDigest(message) {
+        return message.id || computeDecimalDigest(message);
+    }
+    /**
+     * Compute the message id using the XLIFF2/XMB/$localize digest.
+     */
+    function computeDecimalDigest(message) {
+        const visitor = new _SerializerIgnoreIcuExpVisitor();
+        const parts = message.nodes.map(a => a.visit(visitor, null));
+        return computeMsgId(parts.join(''), message.meaning);
+    }
+    /**
+     * Serialize the i18n ast to something xml-like in order to generate an UID.
+     *
+     * The visitor is also used in the i18n parser tests
+     *
+     * @internal
+     */
+    class _SerializerVisitor {
+        visitText(text, context) {
+            return text.value;
+        }
+        visitContainer(container, context) {
+            return `[${container.children.map(child => child.visit(this)).join(', ')}]`;
+        }
+        visitIcu(icu, context) {
+            const strCases = Object.keys(icu.cases).map((k) => `${k} {${icu.cases[k].visit(this)}}`);
+            return `{${icu.expression}, ${icu.type}, ${strCases.join(', ')}}`;
+        }
+        visitTagPlaceholder(ph, context) {
+            return ph.isVoid ?
+                `<ph tag name="${ph.startName}"/>` :
+                `<ph tag name="${ph.startName}">${ph.children.map(child => child.visit(this)).join(', ')}</ph name="${ph.closeName}">`;
+        }
+        visitPlaceholder(ph, context) {
+            return ph.value ? `<ph name="${ph.name}">${ph.value}</ph>` : `<ph name="${ph.name}"/>`;
+        }
+        visitIcuPlaceholder(ph, context) {
+            return `<ph icu name="${ph.name}">${ph.value.visit(this)}</ph>`;
+        }
+    }
+    const serializerVisitor$1 = new _SerializerVisitor();
+    function serializeNodes(nodes) {
+        return nodes.map(a => a.visit(serializerVisitor$1, null));
+    }
+    /**
+     * Serialize the i18n ast to something xml-like in order to generate an UID.
+     *
+     * Ignore the ICU expressions so that message IDs stays identical if only the expression changes.
+     *
+     * @internal
+     */
+    class _SerializerIgnoreIcuExpVisitor extends _SerializerVisitor {
+        visitIcu(icu, context) {
+            let strCases = Object.keys(icu.cases).map((k) => `${k} {${icu.cases[k].visit(this)}}`);
+            // Do not take the expression into account
+            return `{${icu.type}, ${strCases.join(', ')}}`;
+        }
+    }
+    /**
+     * Compute the SHA1 of the given string
+     *
+     * see https://csrc.nist.gov/publications/fips/fips180-4/fips-180-4.pdf
+     *
+     * WARNING: this function has not been designed not tested with security in mind.
+     *          DO NOT USE IT IN A SECURITY SENSITIVE CONTEXT.
+     */
+    function sha1(str) {
+        const utf8 = utf8Encode(str);
+        const words32 = bytesToWords32(utf8, Endian.Big);
+        const len = utf8.length * 8;
+        const w = newArray(80);
+        let a = 0x67452301, b = 0xefcdab89, c = 0x98badcfe, d = 0x10325476, e = 0xc3d2e1f0;
+        words32[len >> 5] |= 0x80 << (24 - len % 32);
+        words32[((len + 64 >> 9) << 4) + 15] = len;
+        for (let i = 0; i < words32.length; i += 16) {
+            const h0 = a, h1 = b, h2 = c, h3 = d, h4 = e;
+            for (let j = 0; j < 80; j++) {
+                if (j < 16) {
+                    w[j] = words32[i + j];
+                }
+                else {
+                    w[j] = rol32(w[j - 3] ^ w[j - 8] ^ w[j - 14] ^ w[j - 16], 1);
+                }
+                const fkVal = fk(j, b, c, d);
+                const f = fkVal[0];
+                const k = fkVal[1];
+                const temp = [rol32(a, 5), f, e, k, w[j]].reduce(add32);
+                e = d;
+                d = c;
+                c = rol32(b, 30);
+                b = a;
+                a = temp;
+            }
+            a = add32(a, h0);
+            b = add32(b, h1);
+            c = add32(c, h2);
+            d = add32(d, h3);
+            e = add32(e, h4);
+        }
+        return bytesToHexString(words32ToByteString([a, b, c, d, e]));
+    }
+    function fk(index, b, c, d) {
+        if (index < 20) {
+            return [(b & c) | (~b & d), 0x5a827999];
+        }
+        if (index < 40) {
+            return [b ^ c ^ d, 0x6ed9eba1];
+        }
+        if (index < 60) {
+            return [(b & c) | (b & d) | (c & d), 0x8f1bbcdc];
+        }
+        return [b ^ c ^ d, 0xca62c1d6];
+    }
+    /**
+     * Compute the fingerprint of the given string
+     *
+     * The output is 64 bit number encoded as a decimal string
+     *
+     * based on:
+     * https://github.com/google/closure-compiler/blob/master/src/com/google/javascript/jscomp/GoogleJsMessageIdGenerator.java
+     */
+    function fingerprint(str) {
+        const utf8 = utf8Encode(str);
+        let hi = hash32(utf8, 0);
+        let lo = hash32(utf8, 102072);
+        if (hi == 0 && (lo == 0 || lo == 1)) {
+            hi = hi ^ 0x130f9bef;
+            lo = lo ^ -0x6b5f56d8;
+        }
+        return [hi, lo];
+    }
+    function computeMsgId(msg, meaning = '') {
+        let msgFingerprint = fingerprint(msg);
+        if (meaning) {
+            const meaningFingerprint = fingerprint(meaning);
+            msgFingerprint = add64(rol64(msgFingerprint, 1), meaningFingerprint);
+        }
+        const hi = msgFingerprint[0];
+        const lo = msgFingerprint[1];
+        return wordsToDecimalString(hi & 0x7fffffff, lo);
+    }
+    function hash32(bytes, c) {
+        let a = 0x9e3779b9, b = 0x9e3779b9;
+        let i;
+        const len = bytes.length;
+        for (i = 0; i + 12 <= len; i += 12) {
+            a = add32(a, wordAt(bytes, i, Endian.Little));
+            b = add32(b, wordAt(bytes, i + 4, Endian.Little));
+            c = add32(c, wordAt(bytes, i + 8, Endian.Little));
+            const res = mix(a, b, c);
+            a = res[0], b = res[1], c = res[2];
+        }
+        a = add32(a, wordAt(bytes, i, Endian.Little));
+        b = add32(b, wordAt(bytes, i + 4, Endian.Little));
+        // the first byte of c is reserved for the length
+        c = add32(c, len);
+        c = add32(c, wordAt(bytes, i + 8, Endian.Little) << 8);
+        return mix(a, b, c)[2];
+    }
+    // clang-format off
+    function mix(a, b, c) {
+        a = sub32(a, b);
+        a = sub32(a, c);
+        a ^= c >>> 13;
+        b = sub32(b, c);
+        b = sub32(b, a);
+        b ^= a << 8;
+        c = sub32(c, a);
+        c = sub32(c, b);
+        c ^= b >>> 13;
+        a = sub32(a, b);
+        a = sub32(a, c);
+        a ^= c >>> 12;
+        b = sub32(b, c);
+        b = sub32(b, a);
+        b ^= a << 16;
+        c = sub32(c, a);
+        c = sub32(c, b);
+        c ^= b >>> 5;
+        a = sub32(a, b);
+        a = sub32(a, c);
+        a ^= c >>> 3;
+        b = sub32(b, c);
+        b = sub32(b, a);
+        b ^= a << 10;
+        c = sub32(c, a);
+        c = sub32(c, b);
+        c ^= b >>> 15;
+        return [a, b, c];
+    }
+    // clang-format on
+    // Utils
+    var Endian;
+    (function (Endian) {
+        Endian[Endian["Little"] = 0] = "Little";
+        Endian[Endian["Big"] = 1] = "Big";
+    })(Endian || (Endian = {}));
+    function add32(a, b) {
+        return add32to64(a, b)[1];
+    }
+    function add32to64(a, b) {
+        const low = (a & 0xffff) + (b & 0xffff);
+        const high = (a >>> 16) + (b >>> 16) + (low >>> 16);
+        return [high >>> 16, (high << 16) | (low & 0xffff)];
+    }
+    function add64(a, b) {
+        const ah = a[0], al = a[1];
+        const bh = b[0], bl = b[1];
+        const result = add32to64(al, bl);
+        const carry = result[0];
+        const l = result[1];
+        const h = add32(add32(ah, bh), carry);
+        return [h, l];
+    }
+    function sub32(a, b) {
+        const low = (a & 0xffff) - (b & 0xffff);
+        const high = (a >> 16) - (b >> 16) + (low >> 16);
+        return (high << 16) | (low & 0xffff);
+    }
+    // Rotate a 32b number left `count` position
+    function rol32(a, count) {
+        return (a << count) | (a >>> (32 - count));
+    }
+    // Rotate a 64b number left `count` position
+    function rol64(num, count) {
+        const hi = num[0], lo = num[1];
+        const h = (hi << count) | (lo >>> (32 - count));
+        const l = (lo << count) | (hi >>> (32 - count));
+        return [h, l];
+    }
+    function bytesToWords32(bytes, endian) {
+        const size = (bytes.length + 3) >>> 2;
+        const words32 = [];
+        for (let i = 0; i < size; i++) {
+            words32[i] = wordAt(bytes, i * 4, endian);
+        }
+        return words32;
+    }
+    function byteAt(bytes, index) {
+        return index >= bytes.length ? 0 : bytes[index];
+    }
+    function wordAt(bytes, index, endian) {
+        let word = 0;
+        if (endian === Endian.Big) {
+            for (let i = 0; i < 4; i++) {
+                word += byteAt(bytes, index + i) << (24 - 8 * i);
+            }
+        }
+        else {
+            for (let i = 0; i < 4; i++) {
+                word += byteAt(bytes, index + i) << 8 * i;
+            }
+        }
+        return word;
+    }
+    function words32ToByteString(words32) {
+        return words32.reduce((bytes, word) => bytes.concat(word32ToByteString(word)), []);
+    }
+    function word32ToByteString(word) {
+        let bytes = [];
+        for (let i = 0; i < 4; i++) {
+            bytes.push((word >>> 8 * (3 - i)) & 0xff);
+        }
+        return bytes;
+    }
+    function bytesToHexString(bytes) {
+        let hex = '';
+        for (let i = 0; i < bytes.length; i++) {
+            const b = byteAt(bytes, i);
+            hex += (b >>> 4).toString(16) + (b & 0x0f).toString(16);
+        }
+        return hex.toLowerCase();
+    }
+    /**
+     * Create a shared exponentiation pool for base-256 computations. This shared pool provides memoized
+     * power-of-256 results with memoized power-of-two computations for efficient multiplication.
+     *
+     * For our purposes, this can be safely stored as a global without memory concerns. The reason is
+     * that we encode two words, so only need the 0th (for the low word) and 4th (for the high word)
+     * exponent.
+     */
+    const base256 = new BigIntExponentiation(256);
+    /**
+     * Represents two 32-bit words as a single decimal number. This requires a big integer storage
+     * model as JS numbers are not accurate enough to represent the 64-bit number.
+     *
+     * Based on https://www.danvk.org/hex2dec.html
+     */
+    function wordsToDecimalString(hi, lo) {
+        // Encode the four bytes in lo in the lower digits of the decimal number.
+        // Note: the multiplication results in lo itself but represented by a big integer using its
+        // decimal digits.
+        const decimal = base256.toThePowerOf(0).multiplyBy(lo);
+        // Encode the four bytes in hi above the four lo bytes. lo is a maximum of (2^8)^4, which is why
+        // this multiplication factor is applied.
+        base256.toThePowerOf(4).multiplyByAndAddTo(hi, decimal);
+        return decimal.toString();
+    }
+
     /**
      * @license
      * Copyright Google LLC All Rights Reserved.
@@ -1517,16 +2135,31 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                 rawText ?? sourceSpan?.toString() ?? escapeForTemplateLiteral(escapeSlashes(text));
         }
     }
-    class MessagePiece {
+    class LiteralPiece {
         constructor(text, sourceSpan) {
             this.text = text;
             this.sourceSpan = sourceSpan;
         }
     }
-    class LiteralPiece extends MessagePiece {
-    }
-    class PlaceholderPiece extends MessagePiece {
+    class PlaceholderPiece {
+        /**
+         * Create a new instance of a `PlaceholderPiece`.
+         *
+         * @param text the name of this placeholder (e.g. `PH_1`).
+         * @param sourceSpan the location of this placeholder in its localized message the source code.
+         * @param associatedMessage reference to another message that this placeholder is associated with.
+         * The `associatedMessage` is mainly used to provide a relationship to an ICU message that has
+         * been extracted out from the message containing the placeholder.
+         */
+        constructor(text, sourceSpan, associatedMessage) {
+            this.text = text;
+            this.sourceSpan = sourceSpan;
+            this.associatedMessage = associatedMessage;
+        }
     }
+    const MEANING_SEPARATOR = '|';
+    const ID_SEPARATOR = '@@';
+    const LEGACY_ID_INDICATOR = '␟';
     class LocalizedString extends Expression {
         constructor(metaBlock, messageParts, placeHolderNames, expressions, sourceSpan) {
             super(STRING_TYPE, sourceSpan);
@@ -1554,9 +2187,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
          * @param messagePart The first part of the tagged string
          */
         serializeI18nHead() {
-            const MEANING_SEPARATOR = '|';
-            const ID_SEPARATOR = '@@';
-            const LEGACY_ID_INDICATOR = '␟';
             let metaBlock = this.metaBlock.description || '';
             if (this.metaBlock.meaning) {
                 metaBlock = `${this.metaBlock.meaning}${MEANING_SEPARATOR}${metaBlock}`;
@@ -1582,13 +2212,21 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
          * Serialize the given `placeholderName` and `messagePart` into "cooked" and "raw" strings that
          * can be used in a `$localize` tagged string.
          *
-         * @param placeholderName The placeholder name to serialize
-         * @param messagePart The following message string after this placeholder
+         * The format is `:<placeholder-name>[@@<associated-id>]:`.
+         *
+         * The `associated-id` is the message id of the (usually an ICU) message to which this placeholder
+         * refers.
+         *
+         * @param partIndex The index of the message part to serialize.
          */
         serializeI18nTemplatePart(partIndex) {
-            const placeholderName = this.placeHolderNames[partIndex - 1].text;
+            const placeholder = this.placeHolderNames[partIndex - 1];
             const messagePart = this.messageParts[partIndex];
-            return createCookedRawString(placeholderName, messagePart.text, this.getMessagePartSourceSpan(partIndex));
+            let metaBlock = placeholder.text;
+            if (placeholder.associatedMessage?.legacyIds.length === 0) {
+                metaBlock += `${ID_SEPARATOR}${computeMsgId(placeholder.associatedMessage.messageString, placeholder.associatedMessage.meaning)}`;
+            }
+            return createCookedRawString(metaBlock, messagePart.text, this.getMessagePartSourceSpan(partIndex));
         }
     }
     const escapeSlashes = (str) => str.replace(/\\/g, '\\\\');
@@ -2561,128 +3199,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
     Identifiers$1.trustConstantHtml = { name: 'ɵɵtrustConstantHtml', moduleName: CORE$1 };
     Identifiers$1.trustConstantResourceUrl = { name: 'ɵɵtrustConstantResourceUrl', moduleName: CORE$1 };
 
-    /**
-     * @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
-     */
-    const DASH_CASE_REGEXP = /-+([a-z0-9])/g;
-    function dashCaseToCamelCase(input) {
-        return input.replace(DASH_CASE_REGEXP, (...m) => m[1].toUpperCase());
-    }
-    function splitAtColon(input, defaultValues) {
-        return _splitAt(input, ':', defaultValues);
-    }
-    function splitAtPeriod(input, defaultValues) {
-        return _splitAt(input, '.', defaultValues);
-    }
-    function _splitAt(input, character, defaultValues) {
-        const characterIndex = input.indexOf(character);
-        if (characterIndex == -1)
-            return defaultValues;
-        return [input.slice(0, characterIndex).trim(), input.slice(characterIndex + 1).trim()];
-    }
-    function error(msg) {
-        throw new Error(`Internal Error: ${msg}`);
-    }
-    function utf8Encode(str) {
-        let encoded = [];
-        for (let index = 0; index < str.length; index++) {
-            let codePoint = str.charCodeAt(index);
-            // decode surrogate
-            // see https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
-            if (codePoint >= 0xd800 && codePoint <= 0xdbff && str.length > (index + 1)) {
-                const low = str.charCodeAt(index + 1);
-                if (low >= 0xdc00 && low <= 0xdfff) {
-                    index++;
-                    codePoint = ((codePoint - 0xd800) << 10) + low - 0xdc00 + 0x10000;
-                }
-            }
-            if (codePoint <= 0x7f) {
-                encoded.push(codePoint);
-            }
-            else if (codePoint <= 0x7ff) {
-                encoded.push(((codePoint >> 6) & 0x1F) | 0xc0, (codePoint & 0x3f) | 0x80);
-            }
-            else if (codePoint <= 0xffff) {
-                encoded.push((codePoint >> 12) | 0xe0, ((codePoint >> 6) & 0x3f) | 0x80, (codePoint & 0x3f) | 0x80);
-            }
-            else if (codePoint <= 0x1fffff) {
-                encoded.push(((codePoint >> 18) & 0x07) | 0xf0, ((codePoint >> 12) & 0x3f) | 0x80, ((codePoint >> 6) & 0x3f) | 0x80, (codePoint & 0x3f) | 0x80);
-            }
-        }
-        return encoded;
-    }
-    function stringify(token) {
-        if (typeof token === 'string') {
-            return token;
-        }
-        if (Array.isArray(token)) {
-            return '[' + token.map(stringify).join(', ') + ']';
-        }
-        if (token == null) {
-            return '' + token;
-        }
-        if (token.overriddenName) {
-            return `${token.overriddenName}`;
-        }
-        if (token.name) {
-            return `${token.name}`;
-        }
-        if (!token.toString) {
-            return 'object';
-        }
-        // WARNING: do not try to `JSON.stringify(token)` here
-        // see https://github.com/angular/angular/issues/23440
-        const res = token.toString();
-        if (res == null) {
-            return '' + res;
-        }
-        const newLineIndex = res.indexOf('\n');
-        return newLineIndex === -1 ? res : res.substring(0, newLineIndex);
-    }
-    class Version {
-        constructor(full) {
-            this.full = full;
-            const splits = full.split('.');
-            this.major = splits[0];
-            this.minor = splits[1];
-            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;
-    function newArray(size, value) {
-        const list = [];
-        for (let i = 0; i < size; i++) {
-            list.push(value);
-        }
-        return list;
-    }
-    /**
-     * Partitions a given array into 2 arrays, based on a boolean value returned by the condition
-     * function.
-     *
-     * @param arr Input array that should be partitioned
-     * @param conditionFn Condition function that is called for each item in a given array and returns a
-     * boolean value.
-     */
-    function partitionArray(arr, conditionFn) {
-        const truthy = [];
-        const falsy = [];
-        for (const item of arr) {
-            (conditionFn(item) ? truthy : falsy).push(item);
-        }
-        return [truthy, falsy];
-    }
-
     /**
      * @license
      * Copyright Google LLC All Rights Reserved.
@@ -3847,343 +4363,54 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             this.vars = vars;
             this.placeholders = placeholders;
             this.sourceSpan = sourceSpan;
-            this.i18n = i18n;
-        }
-        visit(visitor) {
-            return visitor.visitIcu(this);
-        }
-    }
-    class RecursiveVisitor {
-        visitElement(element) {
-            visitAll$1(this, element.attributes);
-            visitAll$1(this, element.inputs);
-            visitAll$1(this, element.outputs);
-            visitAll$1(this, element.children);
-            visitAll$1(this, element.references);
-        }
-        visitTemplate(template) {
-            visitAll$1(this, template.attributes);
-            visitAll$1(this, template.inputs);
-            visitAll$1(this, template.outputs);
-            visitAll$1(this, template.children);
-            visitAll$1(this, template.references);
-            visitAll$1(this, template.variables);
-        }
-        visitContent(content) { }
-        visitVariable(variable) { }
-        visitReference(reference) { }
-        visitTextAttribute(attribute) { }
-        visitBoundAttribute(attribute) { }
-        visitBoundEvent(attribute) { }
-        visitText(text) { }
-        visitBoundText(text) { }
-        visitIcu(icu) { }
-    }
-    function visitAll$1(visitor, nodes) {
-        const result = [];
-        if (visitor.visit) {
-            for (const node of nodes) {
-                visitor.visit(node) || node.visit(visitor);
-            }
-        }
-        else {
-            for (const node of nodes) {
-                const newNode = node.visit(visitor);
-                if (newNode) {
-                    result.push(newNode);
-                }
-            }
-        }
-        return result;
-    }
-
-    /**
-     * @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
-     */
-    class Message {
-        /**
-         * @param nodes message AST
-         * @param placeholders maps placeholder names to static content and their source spans
-         * @param placeholderToMessage maps placeholder names to messages (used for nested ICU messages)
-         * @param meaning
-         * @param description
-         * @param customId
-         */
-        constructor(nodes, placeholders, placeholderToMessage, meaning, description, customId) {
-            this.nodes = nodes;
-            this.placeholders = placeholders;
-            this.placeholderToMessage = placeholderToMessage;
-            this.meaning = meaning;
-            this.description = description;
-            this.customId = customId;
-            this.id = this.customId;
-            /** The ids to use if there are no custom id and if `i18nLegacyMessageIdFormat` is not empty */
-            this.legacyIds = [];
-            if (nodes.length) {
-                this.sources = [{
-                        filePath: nodes[0].sourceSpan.start.file.url,
-                        startLine: nodes[0].sourceSpan.start.line + 1,
-                        startCol: nodes[0].sourceSpan.start.col + 1,
-                        endLine: nodes[nodes.length - 1].sourceSpan.end.line + 1,
-                        endCol: nodes[0].sourceSpan.start.col + 1
-                    }];
-            }
-            else {
-                this.sources = [];
-            }
-        }
-    }
-    class Text$1 {
-        constructor(value, sourceSpan) {
-            this.value = value;
-            this.sourceSpan = sourceSpan;
-        }
-        visit(visitor, context) {
-            return visitor.visitText(this, context);
-        }
-    }
-    // TODO(vicb): do we really need this node (vs an array) ?
-    class Container {
-        constructor(children, sourceSpan) {
-            this.children = children;
-            this.sourceSpan = sourceSpan;
-        }
-        visit(visitor, context) {
-            return visitor.visitContainer(this, context);
-        }
-    }
-    class Icu {
-        constructor(expression, type, cases, sourceSpan) {
-            this.expression = expression;
-            this.type = type;
-            this.cases = cases;
-            this.sourceSpan = sourceSpan;
-        }
-        visit(visitor, context) {
-            return visitor.visitIcu(this, context);
-        }
-    }
-    class TagPlaceholder {
-        constructor(tag, attrs, startName, closeName, children, isVoid, 
-        // TODO sourceSpan should cover all (we need a startSourceSpan and endSourceSpan)
-        sourceSpan, startSourceSpan, endSourceSpan) {
-            this.tag = tag;
-            this.attrs = attrs;
-            this.startName = startName;
-            this.closeName = closeName;
-            this.children = children;
-            this.isVoid = isVoid;
-            this.sourceSpan = sourceSpan;
-            this.startSourceSpan = startSourceSpan;
-            this.endSourceSpan = endSourceSpan;
-        }
-        visit(visitor, context) {
-            return visitor.visitTagPlaceholder(this, context);
-        }
-    }
-    class Placeholder {
-        constructor(value, name, sourceSpan) {
-            this.value = value;
-            this.name = name;
-            this.sourceSpan = sourceSpan;
-        }
-        visit(visitor, context) {
-            return visitor.visitPlaceholder(this, context);
-        }
-    }
-    class IcuPlaceholder {
-        constructor(value, name, sourceSpan) {
-            this.value = value;
-            this.name = name;
-            this.sourceSpan = sourceSpan;
-        }
-        visit(visitor, context) {
-            return visitor.visitIcuPlaceholder(this, context);
-        }
-    }
-
-    /**
-     * @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
-     */
-    /**
-     * Represents a big integer using a buffer of its individual digits, with the least significant
-     * digit stored at the beginning of the array (little endian).
-     *
-     * For performance reasons, each instance is mutable. The addition operation can be done in-place
-     * to reduce memory pressure of allocation for the digits array.
-     */
-    class BigInteger {
-        /**
-         * Creates a big integer using its individual digits in little endian storage.
-         */
-        constructor(digits) {
-            this.digits = digits;
-        }
-        static zero() {
-            return new BigInteger([0]);
-        }
-        static one() {
-            return new BigInteger([1]);
-        }
-        /**
-         * Creates a clone of this instance.
-         */
-        clone() {
-            return new BigInteger(this.digits.slice());
-        }
-        /**
-         * Returns a new big integer with the sum of `this` and `other` as its value. This does not mutate
-         * `this` but instead returns a new instance, unlike `addToSelf`.
-         */
-        add(other) {
-            const result = this.clone();
-            result.addToSelf(other);
-            return result;
-        }
-        /**
-         * Adds `other` to the instance itself, thereby mutating its value.
-         */
-        addToSelf(other) {
-            const maxNrOfDigits = Math.max(this.digits.length, other.digits.length);
-            let carry = 0;
-            for (let i = 0; i < maxNrOfDigits; i++) {
-                let digitSum = carry;
-                if (i < this.digits.length) {
-                    digitSum += this.digits[i];
-                }
-                if (i < other.digits.length) {
-                    digitSum += other.digits[i];
-                }
-                if (digitSum >= 10) {
-                    this.digits[i] = digitSum - 10;
-                    carry = 1;
-                }
-                else {
-                    this.digits[i] = digitSum;
-                    carry = 0;
-                }
-            }
-            // Apply a remaining carry if needed.
-            if (carry > 0) {
-                this.digits[maxNrOfDigits] = 1;
-            }
-        }
-        /**
-         * Builds the decimal string representation of the big integer. As this is stored in
-         * little endian, the digits are concatenated in reverse order.
-         */
-        toString() {
-            let res = '';
-            for (let i = this.digits.length - 1; i >= 0; i--) {
-                res += this.digits[i];
-            }
-            return res;
-        }
-    }
-    /**
-     * Represents a big integer which is optimized for multiplication operations, as its power-of-twos
-     * are memoized. See `multiplyBy()` for details on the multiplication algorithm.
-     */
-    class BigIntForMultiplication {
-        constructor(value) {
-            this.powerOfTwos = [value];
-        }
-        /**
-         * Returns the big integer itself.
-         */
-        getValue() {
-            return this.powerOfTwos[0];
-        }
-        /**
-         * Computes the value for `num * b`, where `num` is a JS number and `b` is a big integer. The
-         * value for `b` is represented by a storage model that is optimized for this computation.
-         *
-         * This operation is implemented in N(log2(num)) by continuous halving of the number, where the
-         * least-significant bit (LSB) is tested in each iteration. If the bit is set, the bit's index is
-         * used as exponent into the power-of-two multiplication of `b`.
-         *
-         * As an example, consider the multiplication num=42, b=1337. In binary 42 is 0b00101010 and the
-         * algorithm unrolls into the following iterations:
-         *
-         *  Iteration | num        | LSB  | b * 2^iter | Add? | product
-         * -----------|------------|------|------------|------|--------
-         *  0         | 0b00101010 | 0    | 1337       | No   | 0
-         *  1         | 0b00010101 | 1    | 2674       | Yes  | 2674
-         *  2         | 0b00001010 | 0    | 5348       | No   | 2674
-         *  3         | 0b00000101 | 1    | 10696      | Yes  | 13370
-         *  4         | 0b00000010 | 0    | 21392      | No   | 13370
-         *  5         | 0b00000001 | 1    | 42784      | Yes  | 56154
-         *  6         | 0b00000000 | 0    | 85568      | No   | 56154
-         *
-         * The computed product of 56154 is indeed the correct result.
-         *
-         * The `BigIntForMultiplication` representation for a big integer provides memoized access to the
-         * power-of-two values to reduce the workload in computing those values.
-         */
-        multiplyBy(num) {
-            const product = BigInteger.zero();
-            this.multiplyByAndAddTo(num, product);
-            return product;
-        }
-        /**
-         * See `multiplyBy()` for details. This function allows for the computed product to be added
-         * directly to the provided result big integer.
-         */
-        multiplyByAndAddTo(num, result) {
-            for (let exponent = 0; num !== 0; num = num >>> 1, exponent++) {
-                if (num & 1) {
-                    const value = this.getMultipliedByPowerOfTwo(exponent);
-                    result.addToSelf(value);
-                }
-            }
+            this.i18n = i18n;
         }
-        /**
-         * Computes and memoizes the big integer value for `this.number * 2^exponent`.
-         */
-        getMultipliedByPowerOfTwo(exponent) {
-            // Compute the powers up until the requested exponent, where each value is computed from its
-            // predecessor. This is simple as `this.number * 2^(exponent - 1)` only has to be doubled (i.e.
-            // added to itself) to reach `this.number * 2^exponent`.
-            for (let i = this.powerOfTwos.length; i <= exponent; i++) {
-                const previousPower = this.powerOfTwos[i - 1];
-                this.powerOfTwos[i] = previousPower.add(previousPower);
-            }
-            return this.powerOfTwos[exponent];
+        visit(visitor) {
+            return visitor.visitIcu(this);
         }
     }
-    /**
-     * Represents an exponentiation operation for the provided base, of which exponents are computed and
-     * memoized. The results are represented by a `BigIntForMultiplication` which is tailored for
-     * multiplication operations by memoizing the power-of-twos. This effectively results in a matrix
-     * representation that is lazily computed upon request.
-     */
-    class BigIntExponentiation {
-        constructor(base) {
-            this.base = base;
-            this.exponents = [new BigIntForMultiplication(BigInteger.one())];
+    class RecursiveVisitor {
+        visitElement(element) {
+            visitAll$1(this, element.attributes);
+            visitAll$1(this, element.inputs);
+            visitAll$1(this, element.outputs);
+            visitAll$1(this, element.children);
+            visitAll$1(this, element.references);
         }
-        /**
-         * Compute the value for `this.base^exponent`, resulting in a big integer that is optimized for
-         * further multiplication operations.
-         */
-        toThePowerOf(exponent) {
-            // Compute the results up until the requested exponent, where every value is computed from its
-            // predecessor. This is because `this.base^(exponent - 1)` only has to be multiplied by `base`
-            // to reach `this.base^exponent`.
-            for (let i = this.exponents.length; i <= exponent; i++) {
-                const value = this.exponents[i - 1].multiplyBy(this.base);
-                this.exponents[i] = new BigIntForMultiplication(value);
+        visitTemplate(template) {
+            visitAll$1(this, template.attributes);
+            visitAll$1(this, template.inputs);
+            visitAll$1(this, template.outputs);
+            visitAll$1(this, template.children);
+            visitAll$1(this, template.references);
+            visitAll$1(this, template.variables);
+        }
+        visitContent(content) { }
+        visitVariable(variable) { }
+        visitReference(reference) { }
+        visitTextAttribute(attribute) { }
+        visitBoundAttribute(attribute) { }
+        visitBoundEvent(attribute) { }
+        visitText(text) { }
+        visitBoundText(text) { }
+        visitIcu(icu) { }
+    }
+    function visitAll$1(visitor, nodes) {
+        const result = [];
+        if (visitor.visit) {
+            for (const node of nodes) {
+                visitor.visit(node) || node.visit(visitor);
+            }
+        }
+        else {
+            for (const node of nodes) {
+                const newNode = node.visit(visitor);
+                if (newNode) {
+                    result.push(newNode);
+                }
             }
-            return this.exponents[exponent];
         }
+        return result;
     }
 
     /**
@@ -4193,313 +4420,137 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
      * 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
      */
-    /**
-     * Compute the message id using the XLIFF1 digest.
-     */
-    function computeDigest(message) {
-        return sha1(serializeNodes(message.nodes).join('') + `[${message.meaning}]`);
-    }
-    /**
-     * Return the message id or compute it using the XLIFF2/XMB/$localize digest.
-     */
-    function decimalDigest(message) {
-        return message.id || computeDecimalDigest(message);
-    }
-    /**
-     * Compute the message id using the XLIFF2/XMB/$localize digest.
-     */
-    function computeDecimalDigest(message) {
-        const visitor = new _SerializerIgnoreIcuExpVisitor();
-        const parts = message.nodes.map(a => a.visit(visitor, null));
-        return computeMsgId(parts.join(''), message.meaning);
+    class Message {
+        /**
+         * @param nodes message AST
+         * @param placeholders maps placeholder names to static content and their source spans
+         * @param placeholderToMessage maps placeholder names to messages (used for nested ICU messages)
+         * @param meaning
+         * @param description
+         * @param customId
+         */
+        constructor(nodes, placeholders, placeholderToMessage, meaning, description, customId) {
+            this.nodes = nodes;
+            this.placeholders = placeholders;
+            this.placeholderToMessage = placeholderToMessage;
+            this.meaning = meaning;
+            this.description = description;
+            this.customId = customId;
+            this.id = this.customId;
+            /** The ids to use if there are no custom id and if `i18nLegacyMessageIdFormat` is not empty */
+            this.legacyIds = [];
+            this.messageString = serializeMessage(this.nodes);
+            if (nodes.length) {
+                this.sources = [{
+                        filePath: nodes[0].sourceSpan.start.file.url,
+                        startLine: nodes[0].sourceSpan.start.line + 1,
+                        startCol: nodes[0].sourceSpan.start.col + 1,
+                        endLine: nodes[nodes.length - 1].sourceSpan.end.line + 1,
+                        endCol: nodes[0].sourceSpan.start.col + 1
+                    }];
+            }
+            else {
+                this.sources = [];
+            }
+        }
     }
-    /**
-     * Serialize the i18n ast to something xml-like in order to generate an UID.
-     *
-     * The visitor is also used in the i18n parser tests
-     *
-     * @internal
-     */
-    class _SerializerVisitor {
-        visitText(text, context) {
-            return text.value;
+    class Text$1 {
+        constructor(value, sourceSpan) {
+            this.value = value;
+            this.sourceSpan = sourceSpan;
         }
-        visitContainer(container, context) {
-            return `[${container.children.map(child => child.visit(this)).join(', ')}]`;
+        visit(visitor, context) {
+            return visitor.visitText(this, context);
         }
-        visitIcu(icu, context) {
-            const strCases = Object.keys(icu.cases).map((k) => `${k} {${icu.cases[k].visit(this)}}`);
-            return `{${icu.expression}, ${icu.type}, ${strCases.join(', ')}}`;
+    }
+    // TODO(vicb): do we really need this node (vs an array) ?
+    class Container {
+        constructor(children, sourceSpan) {
+            this.children = children;
+            this.sourceSpan = sourceSpan;
         }
-        visitTagPlaceholder(ph, context) {
-            return ph.isVoid ?
-                `<ph tag name="${ph.startName}"/>` :
-                `<ph tag name="${ph.startName}">${ph.children.map(child => child.visit(this)).join(', ')}</ph name="${ph.closeName}">`;
+        visit(visitor, context) {
+            return visitor.visitContainer(this, context);
         }
-        visitPlaceholder(ph, context) {
-            return ph.value ? `<ph name="${ph.name}">${ph.value}</ph>` : `<ph name="${ph.name}"/>`;
+    }
+    class Icu {
+        constructor(expression, type, cases, sourceSpan) {
+            this.expression = expression;
+            this.type = type;
+            this.cases = cases;
+            this.sourceSpan = sourceSpan;
         }
-        visitIcuPlaceholder(ph, context) {
-            return `<ph icu name="${ph.name}">${ph.value.visit(this)}</ph>`;
+        visit(visitor, context) {
+            return visitor.visitIcu(this, context);
         }
     }
-    const serializerVisitor$2 = new _SerializerVisitor();
-    function serializeNodes(nodes) {
-        return nodes.map(a => a.visit(serializerVisitor$2, null));
-    }
-    /**
-     * Serialize the i18n ast to something xml-like in order to generate an UID.
-     *
-     * Ignore the ICU expressions so that message IDs stays identical if only the expression changes.
-     *
-     * @internal
-     */
-    class _SerializerIgnoreIcuExpVisitor extends _SerializerVisitor {
-        visitIcu(icu, context) {
-            let strCases = Object.keys(icu.cases).map((k) => `${k} {${icu.cases[k].visit(this)}}`);
-            // Do not take the expression into account
-            return `{${icu.type}, ${strCases.join(', ')}}`;
+    class TagPlaceholder {
+        constructor(tag, attrs, startName, closeName, children, isVoid, 
+        // TODO sourceSpan should cover all (we need a startSourceSpan and endSourceSpan)
+        sourceSpan, startSourceSpan, endSourceSpan) {
+            this.tag = tag;
+            this.attrs = attrs;
+            this.startName = startName;
+            this.closeName = closeName;
+            this.children = children;
+            this.isVoid = isVoid;
+            this.sourceSpan = sourceSpan;
+            this.startSourceSpan = startSourceSpan;
+            this.endSourceSpan = endSourceSpan;
         }
-    }
-    /**
-     * Compute the SHA1 of the given string
-     *
-     * see https://csrc.nist.gov/publications/fips/fips180-4/fips-180-4.pdf
-     *
-     * WARNING: this function has not been designed not tested with security in mind.
-     *          DO NOT USE IT IN A SECURITY SENSITIVE CONTEXT.
-     */
-    function sha1(str) {
-        const utf8 = utf8Encode(str);
-        const words32 = bytesToWords32(utf8, Endian.Big);
-        const len = utf8.length * 8;
-        const w = newArray(80);
-        let a = 0x67452301, b = 0xefcdab89, c = 0x98badcfe, d = 0x10325476, e = 0xc3d2e1f0;
-        words32[len >> 5] |= 0x80 << (24 - len % 32);
-        words32[((len + 64 >> 9) << 4) + 15] = len;
-        for (let i = 0; i < words32.length; i += 16) {
-            const h0 = a, h1 = b, h2 = c, h3 = d, h4 = e;
-            for (let j = 0; j < 80; j++) {
-                if (j < 16) {
-                    w[j] = words32[i + j];
-                }
-                else {
-                    w[j] = rol32(w[j - 3] ^ w[j - 8] ^ w[j - 14] ^ w[j - 16], 1);
-                }
-                const fkVal = fk(j, b, c, d);
-                const f = fkVal[0];
-                const k = fkVal[1];
-                const temp = [rol32(a, 5), f, e, k, w[j]].reduce(add32);
-                e = d;
-                d = c;
-                c = rol32(b, 30);
-                b = a;
-                a = temp;
-            }
-            a = add32(a, h0);
-            b = add32(b, h1);
-            c = add32(c, h2);
-            d = add32(d, h3);
-            e = add32(e, h4);
+        visit(visitor, context) {
+            return visitor.visitTagPlaceholder(this, context);
         }
-        return bytesToHexString(words32ToByteString([a, b, c, d, e]));
     }
-    function fk(index, b, c, d) {
-        if (index < 20) {
-            return [(b & c) | (~b & d), 0x5a827999];
+    class Placeholder {
+        constructor(value, name, sourceSpan) {
+            this.value = value;
+            this.name = name;
+            this.sourceSpan = sourceSpan;
         }
-        if (index < 40) {
-            return [b ^ c ^ d, 0x6ed9eba1];
+        visit(visitor, context) {
+            return visitor.visitPlaceholder(this, context);
         }
-        if (index < 60) {
-            return [(b & c) | (b & d) | (c & d), 0x8f1bbcdc];
+    }
+    class IcuPlaceholder {
+        constructor(value, name, sourceSpan) {
+            this.value = value;
+            this.name = name;
+            this.sourceSpan = sourceSpan;
+        }
+        visit(visitor, context) {
+            return visitor.visitIcuPlaceholder(this, context);
         }
-        return [b ^ c ^ d, 0xca62c1d6];
     }
     /**
-     * Compute the fingerprint of the given string
-     *
-     * The output is 64 bit number encoded as a decimal string
-     *
-     * based on:
-     * https://github.com/google/closure-compiler/blob/master/src/com/google/javascript/jscomp/GoogleJsMessageIdGenerator.java
+     * Serialize the message to the Localize backtick string format that would appear in compiled code.
      */
-    function fingerprint(str) {
-        const utf8 = utf8Encode(str);
-        let hi = hash32(utf8, 0);
-        let lo = hash32(utf8, 102072);
-        if (hi == 0 && (lo == 0 || lo == 1)) {
-            hi = hi ^ 0x130f9bef;
-            lo = lo ^ -0x6b5f56d8;
-        }
-        return [hi, lo];
-    }
-    function computeMsgId(msg, meaning = '') {
-        let msgFingerprint = fingerprint(msg);
-        if (meaning) {
-            const meaningFingerprint = fingerprint(meaning);
-            msgFingerprint = add64(rol64(msgFingerprint, 1), meaningFingerprint);
-        }
-        const hi = msgFingerprint[0];
-        const lo = msgFingerprint[1];
-        return wordsToDecimalString(hi & 0x7fffffff, lo);
+    function serializeMessage(messageNodes) {
+        const visitor = new LocalizeMessageStringVisitor();
+        const str = messageNodes.map(n => n.visit(visitor)).join('');
+        return str;
     }
-    function hash32(bytes, c) {
-        let a = 0x9e3779b9, b = 0x9e3779b9;
-        let i;
-        const len = bytes.length;
-        for (i = 0; i + 12 <= len; i += 12) {
-            a = add32(a, wordAt(bytes, i, Endian.Little));
-            b = add32(b, wordAt(bytes, i + 4, Endian.Little));
-            c = add32(c, wordAt(bytes, i + 8, Endian.Little));
-            const res = mix(a, b, c);
-            a = res[0], b = res[1], c = res[2];
+    class LocalizeMessageStringVisitor {
+        visitText(text) {
+            return text.value;
         }
-        a = add32(a, wordAt(bytes, i, Endian.Little));
-        b = add32(b, wordAt(bytes, i + 4, Endian.Little));
-        // the first byte of c is reserved for the length
-        c = add32(c, len);
-        c = add32(c, wordAt(bytes, i + 8, Endian.Little) << 8);
-        return mix(a, b, c)[2];
-    }
-    // clang-format off
-    function mix(a, b, c) {
-        a = sub32(a, b);
-        a = sub32(a, c);
-        a ^= c >>> 13;
-        b = sub32(b, c);
-        b = sub32(b, a);
-        b ^= a << 8;
-        c = sub32(c, a);
-        c = sub32(c, b);
-        c ^= b >>> 13;
-        a = sub32(a, b);
-        a = sub32(a, c);
-        a ^= c >>> 12;
-        b = sub32(b, c);
-        b = sub32(b, a);
-        b ^= a << 16;
-        c = sub32(c, a);
-        c = sub32(c, b);
-        c ^= b >>> 5;
-        a = sub32(a, b);
-        a = sub32(a, c);
-        a ^= c >>> 3;
-        b = sub32(b, c);
-        b = sub32(b, a);
-        b ^= a << 10;
-        c = sub32(c, a);
-        c = sub32(c, b);
-        c ^= b >>> 15;
-        return [a, b, c];
-    }
-    // clang-format on
-    // Utils
-    var Endian;
-    (function (Endian) {
-        Endian[Endian["Little"] = 0] = "Little";
-        Endian[Endian["Big"] = 1] = "Big";
-    })(Endian || (Endian = {}));
-    function add32(a, b) {
-        return add32to64(a, b)[1];
-    }
-    function add32to64(a, b) {
-        const low = (a & 0xffff) + (b & 0xffff);
-        const high = (a >>> 16) + (b >>> 16) + (low >>> 16);
-        return [high >>> 16, (high << 16) | (low & 0xffff)];
-    }
-    function add64(a, b) {
-        const ah = a[0], al = a[1];
-        const bh = b[0], bl = b[1];
-        const result = add32to64(al, bl);
-        const carry = result[0];
-        const l = result[1];
-        const h = add32(add32(ah, bh), carry);
-        return [h, l];
-    }
-    function sub32(a, b) {
-        const low = (a & 0xffff) - (b & 0xffff);
-        const high = (a >> 16) - (b >> 16) + (low >> 16);
-        return (high << 16) | (low & 0xffff);
-    }
-    // Rotate a 32b number left `count` position
-    function rol32(a, count) {
-        return (a << count) | (a >>> (32 - count));
-    }
-    // Rotate a 64b number left `count` position
-    function rol64(num, count) {
-        const hi = num[0], lo = num[1];
-        const h = (hi << count) | (lo >>> (32 - count));
-        const l = (lo << count) | (hi >>> (32 - count));
-        return [h, l];
-    }
-    function bytesToWords32(bytes, endian) {
-        const size = (bytes.length + 3) >>> 2;
-        const words32 = [];
-        for (let i = 0; i < size; i++) {
-            words32[i] = wordAt(bytes, i * 4, endian);
+        visitContainer(container) {
+            return container.children.map(child => child.visit(this)).join('');
         }
-        return words32;
-    }
-    function byteAt(bytes, index) {
-        return index >= bytes.length ? 0 : bytes[index];
-    }
-    function wordAt(bytes, index, endian) {
-        let word = 0;
-        if (endian === Endian.Big) {
-            for (let i = 0; i < 4; i++) {
-                word += byteAt(bytes, index + i) << (24 - 8 * i);
-            }
+        visitIcu(icu) {
+            const strCases = Object.keys(icu.cases).map((k) => `${k} {${icu.cases[k].visit(this)}}`);
+            return `{${icu.expressionPlaceholder}, ${icu.type}, ${strCases.join(' ')}}`;
         }
-        else {
-            for (let i = 0; i < 4; i++) {
-                word += byteAt(bytes, index + i) << 8 * i;
-            }
+        visitTagPlaceholder(ph) {
+            const children = ph.children.map(child => child.visit(this)).join('');
+            return `{$${ph.startName}}${children}{$${ph.closeName}}`;
         }
-        return word;
-    }
-    function words32ToByteString(words32) {
-        return words32.reduce((bytes, word) => bytes.concat(word32ToByteString(word)), []);
-    }
-    function word32ToByteString(word) {
-        let bytes = [];
-        for (let i = 0; i < 4; i++) {
-            bytes.push((word >>> 8 * (3 - i)) & 0xff);
+        visitPlaceholder(ph) {
+            return `{$${ph.name}}`;
         }
-        return bytes;
-    }
-    function bytesToHexString(bytes) {
-        let hex = '';
-        for (let i = 0; i < bytes.length; i++) {
-            const b = byteAt(bytes, i);
-            hex += (b >>> 4).toString(16) + (b & 0x0f).toString(16);
+        visitIcuPlaceholder(ph) {
+            return `{$${ph.name}}`;
         }
-        return hex.toLowerCase();
-    }
-    /**
-     * Create a shared exponentiation pool for base-256 computations. This shared pool provides memoized
-     * power-of-256 results with memoized power-of-two computations for efficient multiplication.
-     *
-     * For our purposes, this can be safely stored as a global without memory concerns. The reason is
-     * that we encode two words, so only need the 0th (for the low word) and 4th (for the high word)
-     * exponent.
-     */
-    const base256 = new BigIntExponentiation(256);
-    /**
-     * Represents two 32-bit words as a single decimal number. This requires a big integer storage
-     * model as JS numbers are not accurate enough to represent the 64-bit number.
-     *
-     * Based on https://www.danvk.org/hex2dec.html
-     */
-    function wordsToDecimalString(hi, lo) {
-        // Encode the four bytes in lo in the lower digits of the decimal number.
-        // Note: the multiplication results in lo itself but represented by a big integer using its
-        // decimal digits.
-        const decimal = base256.toThePowerOf(0).multiplyBy(lo);
-        // Encode the four bytes in hi above the four lo bytes. lo is a maximum of (2^8)^4, which is why
-        // this multiplication factor is applied.
-        base256.toThePowerOf(4).multiplyByAndAddTo(hi, decimal);
-        return decimal.toString();
     }
 
     /**
@@ -16773,6 +16824,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             return new ParseTreeResult(result, this._errors);
         }
         visitElement(element) {
+            let message = undefined;
             if (hasI18nAttrs(element)) {
                 this.hasI18nMeta = true;
                 const attrs = [];
@@ -16781,11 +16833,13 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                     if (attr.name === I18N_ATTR) {
                         // root 'i18n' node attribute
                         const i18n = element.i18n || attr.value;
-                        const message = this._generateI18nMessage(element.children, i18n, setI18nRefs);
-                        // do not assign empty i18n meta
-                        if (message.nodes.length) {
-                            element.i18n = message;
+                        message = this._generateI18nMessage(element.children, i18n, setI18nRefs);
+                        if (message.nodes.length === 0) {
+                            // Ignore the message if it is empty.
+                            message = undefined;
                         }
+                        // Store the message on the element
+                        element.i18n = message;
                     }
                     else if (attr.name.startsWith(I18N_ATTR_PREFIX)) {
                         // 'i18n-*' attributes
@@ -16818,7 +16872,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                     element.attrs = attrs;
                 }
             }
-            visitAll(this, element.children, element.i18n);
+            visitAll(this, element.children, message);
             return element;
         }
         visitExpansion(expansion, currentMessage) {
@@ -16833,6 +16887,10 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                 message = this._generateI18nMessage([expansion], meta);
                 const icu = icuFromI18nMessage(message);
                 icu.name = name;
+                if (currentMessage !== null) {
+                    // Also update the placeholderToMessage map with this new message
+                    currentMessage.placeholderToMessage[name] = message;
+                }
             }
             else {
                 // ICU is a top level message, try to use metadata from container element if provided via
@@ -16869,8 +16927,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
          */
         _parseMetadata(meta) {
             return typeof meta === 'string' ? parseI18nMeta(meta) :
-                meta instanceof Message ? meta :
-                    {};
+                meta instanceof Message ? meta : {};
         }
         /**
          * Generate (or restore) message id if not specified already.
@@ -16895,9 +16952,9 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                 // `packages/compiler/src/render3/view/template.ts`).
                 // In that case we want to reuse the legacy message generated in the 1st pass (see
                 // `setI18nRefs()`).
-                const previousMessage = meta instanceof Message ? meta :
-                    meta instanceof IcuPlaceholder ? meta.previousMessage :
-                        undefined;
+                const previousMessage = meta instanceof Message ?
+                    meta :
+                    meta instanceof IcuPlaceholder ? meta.previousMessage : undefined;
                 message.legacyIds = previousMessage ? previousMessage.legacyIds : [];
             }
         }
@@ -16999,9 +17056,9 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             return this.formatPh(ph.name);
         }
     }
-    const serializerVisitor$1 = new GetMsgSerializerVisitor();
+    const serializerVisitor = new GetMsgSerializerVisitor();
     function serializeI18nMessageForGetMsg(message) {
-        return message.nodes.map(node => node.visit(serializerVisitor$1, null)).join('');
+        return message.nodes.map(node => node.visit(serializerVisitor, null)).join('');
     }
 
     function createLocalizeStatements(variable, message, params) {
@@ -17018,40 +17075,43 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
      * The result can be used for generating the `$localize` tagged template literals.
      */
     class LocalizeSerializerVisitor {
-        visitText(text, context) {
-            if (context[context.length - 1] instanceof LiteralPiece) {
+        constructor(placeholderToMessage, pieces) {
+            this.placeholderToMessage = placeholderToMessage;
+            this.pieces = pieces;
+        }
+        visitText(text) {
+            if (this.pieces[this.pieces.length - 1] instanceof LiteralPiece) {
                 // Two literal pieces in a row means that there was some comment node in-between.
-                context[context.length - 1].text += text.value;
+                this.pieces[this.pieces.length - 1].text += text.value;
             }
             else {
                 const sourceSpan = new ParseSourceSpan(text.sourceSpan.fullStart, text.sourceSpan.end, text.sourceSpan.fullStart, text.sourceSpan.details);
-                context.push(new LiteralPiece(text.value, sourceSpan));
+                this.pieces.push(new LiteralPiece(text.value, sourceSpan));
             }
         }
-        visitContainer(container, context) {
-            container.children.forEach(child => child.visit(this, context));
+        visitContainer(container) {
+            container.children.forEach(child => child.visit(this));
         }
-        visitIcu(icu, context) {
-            context.push(new LiteralPiece(serializeIcuNode(icu), icu.sourceSpan));
+        visitIcu(icu) {
+            this.pieces.push(new LiteralPiece(serializeIcuNode(icu), icu.sourceSpan));
         }
-        visitTagPlaceholder(ph, context) {
-            context.push(this.createPlaceholderPiece(ph.startName, ph.startSourceSpan ?? ph.sourceSpan));
+        visitTagPlaceholder(ph) {
+            this.pieces.push(this.createPlaceholderPiece(ph.startName, ph.startSourceSpan ?? ph.sourceSpan));
             if (!ph.isVoid) {
-                ph.children.forEach(child => child.visit(this, context));
-                context.push(this.createPlaceholderPiece(ph.closeName, ph.endSourceSpan ?? ph.sourceSpan));
+                ph.children.forEach(child => child.visit(this));
+                this.pieces.push(this.createPlaceholderPiece(ph.closeName, ph.endSourceSpan ?? ph.sourceSpan));
             }
         }
-        visitPlaceholder(ph, context) {
-            context.push(this.createPlaceholderPiece(ph.name, ph.sourceSpan));
+        visitPlaceholder(ph) {
+            this.pieces.push(this.createPlaceholderPiece(ph.name, ph.sourceSpan));
         }
-        visitIcuPlaceholder(ph, context) {
-            context.push(this.createPlaceholderPiece(ph.name, ph.sourceSpan));
+        visitIcuPlaceholder(ph) {
+            this.pieces.push(this.createPlaceholderPiece(ph.name, ph.sourceSpan, this.placeholderToMessage[ph.name]));
         }
-        createPlaceholderPiece(name, sourceSpan) {
-            return new PlaceholderPiece(formatI18nPlaceholderName(name, /* useCamelCase */ false), sourceSpan);
+        createPlaceholderPiece(name, sourceSpan, associatedMessage) {
+            return new PlaceholderPiece(formatI18nPlaceholderName(name, /* useCamelCase */ false), sourceSpan, associatedMessage);
         }
     }
-    const serializerVisitor = new LocalizeSerializerVisitor();
     /**
      * Serialize an i18n message into two arrays: messageParts and placeholders.
      *
@@ -17062,7 +17122,8 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
      */
     function serializeI18nMessageForLocalize(message) {
         const pieces = [];
-        message.nodes.forEach(node => node.visit(serializerVisitor, pieces));
+        const serializerVisitor = new LocalizeSerializerVisitor(message.placeholderToMessage, pieces);
+        message.nodes.forEach(node => node.visit(serializerVisitor));
         return processMessagePieces(pieces);
     }
     function getSourceSpan(message) {
@@ -20016,7 +20077,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
      * 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
      */
-    new Version('13.0.3');
+    new Version('13.1.0-next.3');
 
     /**
      * @license
@@ -20645,7 +20706,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
     function compileDeclareClassMetadata(metadata) {
         const definitionMap = new DefinitionMap();
         definitionMap.set('minVersion', literal$1(MINIMUM_PARTIAL_LINKER_VERSION$6));
-        definitionMap.set('version', literal$1('13.0.3'));
+        definitionMap.set('version', literal$1('13.1.0-next.3'));
         definitionMap.set('ngImport', importExpr(Identifiers$1.core));
         definitionMap.set('type', metadata.type);
         definitionMap.set('decorators', metadata.decorators);
@@ -20762,7 +20823,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
     function createDirectiveDefinitionMap(meta) {
         const definitionMap = new DefinitionMap();
         definitionMap.set('minVersion', literal$1(MINIMUM_PARTIAL_LINKER_VERSION$5));
-        definitionMap.set('version', literal$1('13.0.3'));
+        definitionMap.set('version', literal$1('13.1.0-next.3'));
         // e.g. `type: MyDirective`
         definitionMap.set('type', meta.internalType);
         // e.g. `selector: 'some-dir'`
@@ -20980,7 +21041,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
     function compileDeclareFactoryFunction(meta) {
         const definitionMap = new DefinitionMap();
         definitionMap.set('minVersion', literal$1(MINIMUM_PARTIAL_LINKER_VERSION$4));
-        definitionMap.set('version', literal$1('13.0.3'));
+        definitionMap.set('version', literal$1('13.1.0-next.3'));
         definitionMap.set('ngImport', importExpr(Identifiers$1.core));
         definitionMap.set('type', meta.internalType);
         definitionMap.set('deps', compileDependencies(meta.deps));
@@ -21022,7 +21083,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
     function createInjectableDefinitionMap(meta) {
         const definitionMap = new DefinitionMap();
         definitionMap.set('minVersion', literal$1(MINIMUM_PARTIAL_LINKER_VERSION$3));
-        definitionMap.set('version', literal$1('13.0.3'));
+        definitionMap.set('version', literal$1('13.1.0-next.3'));
         definitionMap.set('ngImport', importExpr(Identifiers$1.core));
         definitionMap.set('type', meta.internalType);
         // Only generate providedIn property if it has a non-null value
@@ -21080,7 +21141,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
     function createInjectorDefinitionMap(meta) {
         const definitionMap = new DefinitionMap();
         definitionMap.set('minVersion', literal$1(MINIMUM_PARTIAL_LINKER_VERSION$2));
-        definitionMap.set('version', literal$1('13.0.3'));
+        definitionMap.set('version', literal$1('13.1.0-next.3'));
         definitionMap.set('ngImport', importExpr(Identifiers$1.core));
         definitionMap.set('type', meta.internalType);
         definitionMap.set('providers', meta.providers);
@@ -21117,7 +21178,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
     function createNgModuleDefinitionMap(meta) {
         const definitionMap = new DefinitionMap();
         definitionMap.set('minVersion', literal$1(MINIMUM_PARTIAL_LINKER_VERSION$1));
-        definitionMap.set('version', literal$1('13.0.3'));
+        definitionMap.set('version', literal$1('13.1.0-next.3'));
         definitionMap.set('ngImport', importExpr(Identifiers$1.core));
         definitionMap.set('type', meta.internalType);
         // We only generate the keys in the metadata if the arrays contain values.
@@ -21175,7 +21236,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
     function createPipeDefinitionMap(meta) {
         const definitionMap = new DefinitionMap();
         definitionMap.set('minVersion', literal$1(MINIMUM_PARTIAL_LINKER_VERSION));
-        definitionMap.set('version', literal$1('13.0.3'));
+        definitionMap.set('version', literal$1('13.1.0-next.3'));
         definitionMap.set('ngImport', importExpr(Identifiers$1.core));
         // e.g. `type: MyPipe`
         definitionMap.set('type', meta.internalType);
@@ -21207,18 +21268,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
      * 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
      */
-    new Version('13.0.3');
-
-    /**
-     * @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
-     */
-    // In TypeScript 2.1 the spread element kind was renamed.
-    ts__default["default"].SyntaxKind.SpreadElement || ts__default["default"].SyntaxKind.SpreadElementExpression;
-    ts__default["default"].createNodeArray();
+    new Version('13.1.0-next.3');
 
     /**
      * @license
@@ -21239,6 +21289,19 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         EmitFlags[EmitFlags["All"] = 31] = "All";
     })(EmitFlags || (EmitFlags = {}));
 
+    /**
+     * @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
+     */
+    /**
+     * The currently used version of TypeScript, which can be adjusted for testing purposes using
+     * `setTypeScriptVersionForTesting` and `restoreTypeScriptVersionForTesting` below.
+     */
+    ts__default["default"].version;
+
     /**
      * @license
      * Copyright Google LLC All Rights Reserved.
@@ -21535,6 +21598,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
      * found in the LICENSE file at https://angular.io/license
      */
     const D_TS = /\.d\.ts$/i;
+    const PARSED_TS_VERSION = parseFloat(ts__default["default"].versionMajorMinor);
     function isSymbolWithValueDeclaration(symbol) {
         // If there is a value declaration set, then the `declarations` property is never undefined. We
         // still check for the property to exist as this matches with the type that `symbol` is narrowed
@@ -21648,6 +21712,19 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         }
         return redirectInfo.unredirected;
     }
+    /**
+     * Backwards-compatible version of `ts.createExportSpecifier`
+     * to handle a breaking change between 4.4 and 4.5.
+     */
+    function createExportSpecifier(propertyName, name, isTypeOnly = false) {
+        return PARSED_TS_VERSION > 4.4 ?
+            // TODO(crisbeto): the function is cast to `any` here since g3 is still on TS 4.4.
+            // Should be cleaned up when g3 has been updated.
+            ts__default["default"].createExportSpecifier(isTypeOnly, propertyName, name) :
+            // TODO(crisbeto): backwards-compatibility layer for TS 4.4.
+            // Should be cleaned up when we drop support for it.
+            ts__default["default"].createExportSpecifier(propertyName, name);
+    }
 
     /**
      * @license
@@ -22979,8 +23056,15 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                 //   import {Foo} from 'foo';
                 // or
                 //   import {Foo as Bar} from 'foo';
+                // TODO(crisbeto): the cast to `any` is here since g3 is still on TS 4.4.
+                // Should be cleaned up when g3 has been updated.
+                if (firstDecl.isTypeOnly) {
+                    // The import specifier can't be type-only (e.g. `import {type Foo} from '...')`.
+                    return typeOnlyImport(typeNode, firstDecl);
+                }
                 if (firstDecl.parent.parent.isTypeOnly) {
-                    // Type-only imports cannot be represented as value.
+                    // The import specifier can't be inside a type-only import clause
+                    // (e.g. `import type {Foo} from '...')`.
                     return typeOnlyImport(typeNode, firstDecl.parent.parent);
                 }
                 // Determine the name to import (`Foo`) from the import specifier, as the symbol names of
@@ -23048,10 +23132,10 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             reason: { kind: 1 /* NO_VALUE_DECLARATION */, typeNode, decl },
         };
     }
-    function typeOnlyImport(typeNode, importClause) {
+    function typeOnlyImport(typeNode, node) {
         return {
             kind: 2 /* UNAVAILABLE */,
-            reason: { kind: 2 /* TYPE_ONLY_IMPORT */, typeNode, importClause },
+            reason: { kind: 2 /* TYPE_ONLY_IMPORT */, typeNode, node },
         };
     }
     function unknownReference(typeNode) {
@@ -26232,9 +26316,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                     const stmt = ts__default["default"].createExportDeclaration(
                     /* decorators */ undefined, 
                     /* modifiers */ undefined, 
-                    /* exportClause */ ts__default["default"].createNamedExports([ts__default["default"].createExportSpecifier(
-                        /* propertyName */ symbolName, 
-                        /* name */ aliasName)]), 
+                    /* exportClause */ ts__default["default"].createNamedExports([createExportSpecifier(symbolName, aliasName)]), 
                     /* moduleSpecifier */ ts__default["default"].createStringLiteral(moduleName));
                     statements.push(stmt);
                 });
@@ -28476,7 +28558,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                     'Consider changing the type-only import to a regular import, or use the @Inject decorator to specify an injection token.';
                 hints = [
                     makeRelatedInformation(reason.typeNode, 'This type is imported using a type-only import, which prevents it from being usable as an injection token.'),
-                    makeRelatedInformation(reason.importClause, 'The type-only import occurs here.'),
+                    makeRelatedInformation(reason.node, 'The type-only import occurs here.'),
                 ];
                 break;
             case 4 /* NAMESPACE */:
@@ -32071,7 +32153,7 @@ Either add the @Injectable() decorator to '${provider.node.name
                         continue;
                     }
                     if (ts__default["default"].isImportDeclaration(stmt) && stmt.importClause !== undefined &&
-                        stmt.importClause.isTypeOnly) {
+                        isTypeOnlyImportClause(stmt.importClause)) {
                         // Exclude type-only imports as they are always elided, so they don't contribute to
                         // cycles.
                         continue;
@@ -32094,6 +32176,20 @@ Either add the @Injectable() decorator to '${provider.node.name
     function isLocalFile(sf) {
         return !sf.isDeclarationFile;
     }
+    function isTypeOnlyImportClause(node) {
+        // The clause itself is type-only (e.g. `import type {foo} from '...'`).
+        if (node.isTypeOnly) {
+            return true;
+        }
+        // All the specifiers in the cause are type-only (e.g. `import {type a, type b} from '...'`).
+        if (node.namedBindings !== undefined && ts__default["default"].isNamedImports(node.namedBindings) &&
+            // TODO(crisbeto): the cast to `any` is here since g3 is still on TS 4.4.
+            // Should be cleaned up when g3 has been updated.
+            node.namedBindings.elements.every(specifier => specifier.isTypeOnly)) {
+            return true;
+        }
+        return false;
+    }
     /**
      * A helper class to track which SourceFiles are being processed when searching for a path in
      * `getPath()` above.
@@ -32414,7 +32510,9 @@ Either add the @Injectable() decorator to '${provider.node.name
                 // Update the import path to point to the correct file using the ImportRewriter.
                 const rewrittenModuleSpecifier = importRewriter.rewriteSpecifier('@angular/core', sourceFilePath);
                 if (rewrittenModuleSpecifier !== stmt.moduleSpecifier.text) {
-                    transformedStatements.push(ts__default["default"].updateImportDeclaration(stmt, stmt.decorators, stmt.modifiers, stmt.importClause, ts__default["default"].createStringLiteral(rewrittenModuleSpecifier)));
+                    // TODO(crisbeto): the cast to `any` is here since g3 is still on TS 4.4.
+                    // Should be cleaned up when g3 has been updated.
+                    transformedStatements.push(ts__default["default"].updateImportDeclaration(stmt, stmt.decorators, stmt.modifiers, stmt.importClause, ts__default["default"].createStringLiteral(rewrittenModuleSpecifier), undefined));
                     // Record the identifier by which this imported module goes, so references to its symbols
                     // can be discovered later.
                     if (stmt.importClause !== undefined && stmt.importClause.namedBindings !== undefined &&
@@ -33586,6 +33684,8 @@ Either add the @Injectable() decorator to '${provider.node.name
      * marker and does not go to the filesystem for these requests, as they are known not to exist.
      */
     function createLookupResolutionHost(adapter) {
+        // TODO(crisbeto): the cast to `any` is here since g3 is still on TS 4.4.
+        // Should be cleaned up when g3 has been updated.
         return {
             directoryExists(directoryName) {
                 if (directoryName.includes(RESOURCE_MARKER)) {
@@ -33613,6 +33713,9 @@ Either add the @Injectable() decorator to '${provider.node.name
             getDirectories: adapter.getDirectories?.bind(adapter),
             realpath: adapter.realpath?.bind(adapter),
             trace: adapter.trace?.bind(adapter),
+            useCaseSensitiveFileNames: typeof adapter.useCaseSensitiveFileNames === 'function' ?
+                adapter.useCaseSensitiveFileNames.bind(adapter) :
+                adapter.useCaseSensitiveFileNames
         };
     }
 
@@ -41051,19 +41154,6 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
         return versions;
     }
 
-    /**
-     * @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
-     */
-    /**
-     * The currently used version of TypeScript, which can be adjusted for testing purposes using
-     * `setTypeScriptVersionForTesting` and `restoreTypeScriptVersionForTesting` below.
-     */
-    ts__default["default"].version;
-
     /**
      * @license
      * Copyright Google LLC All Rights Reserved.
@@ -41799,7 +41889,7 @@ https://angular.io/guide/ivy for more information.
             // same name instead. That way, we can provide go-to-definition for the pre-compiled files which
             // would generally be the desired behavior.
             if (url.endsWith('.css')) {
-                const styleUrl = path__namespace.resolve(fromFile, '..', url);
+                const styleUrl = p__namespace.resolve(fromFile, '..', url);
                 for (const ext of PRE_COMPILED_STYLE_EXTENSIONS) {
                     const precompiledFileUrl = styleUrl.replace(/\.css$/, ext);
                     if (this.fileExists(precompiledFileUrl)) {
@@ -41904,16 +41994,16 @@ https://angular.io/guide/ivy for more information.
             return this.serverHost.getCurrentDirectory();
         }
         extname(path) {
-            return path__namespace.extname(path);
+            return p__namespace.extname(path);
         }
         resolve(...paths) {
-            return path__namespace.resolve(...paths);
+            return p__namespace.resolve(...paths);
         }
         dirname(file) {
-            return path__namespace.dirname(file);
+            return p__namespace.dirname(file);
         }
         join(basePath, ...paths) {
-            return path__namespace.join(basePath, ...paths);
+            return p__namespace.join(basePath, ...paths);
         }
     }
 
@@ -45028,6 +45118,7 @@ https://angular.io/guide/ivy for more information.
         // regardless of its value in tsconfig.json.
         if (config.forceStrictTemplates === true) {
             options.strictTemplates = true;
+            options._extendedTemplateDiagnostics = true;
         }
         return options;
     }