@angular/compiler-cli 9.0.6 → 9.0.7

package/ngcc/src/sourcemaps/segment_marker.js

@@ -23,61 +23,32 @@
      * and zero if they are at the same position.
      */
     function compareSegments(a, b) {
-        return a.line === b.line ? a.column - b.column : a.line - b.line;
+        return a.position - b.position;
     }
     exports.compareSegments = compareSegments;
-    // The `1` is to indicate a newline character between the lines.
-    // Note that in the actual contents there could be more than one character that indicates a newline
-    // - e.g. \r\n - but that is not important here since segment-markers are in line/column pairs and
-    // so differences in length due to extra `\r` characters do not affect the algorithms.
-    var NEWLINE_MARKER_OFFSET = 1;
-    /**
-     * Compute the difference between two segment markers in a source file.
-     *
-     * @param lineLengths the lengths of each line of content of the source file where we are computing
-     * the difference
-     * @param a the start marker
-     * @param b the end marker
-     * @returns the number of characters between the two segments `a` and `b`
-     */
-    function segmentDiff(lineLengths, a, b) {
-        var diff = b.column - a.column;
-        // Deal with `a` being before `b`
-        for (var lineIndex = a.line; lineIndex < b.line; lineIndex++) {
-            diff += lineLengths[lineIndex] + NEWLINE_MARKER_OFFSET;
-        }
-        // Deal with `a` being after `b`
-        for (var lineIndex = a.line - 1; lineIndex >= b.line; lineIndex--) {
-            // The `+ 1` is the newline character between the lines
-            diff -= lineLengths[lineIndex] + NEWLINE_MARKER_OFFSET;
-        }
-        return diff;
-    }
-    exports.segmentDiff = segmentDiff;
     /**
      * Return a new segment-marker that is offset by the given number of characters.
      *
-     * @param lineLengths The length of each line in the source file whose segment-marker we are
-     * offsetting.
-     * @param marker The segment to offset.
-     * @param offset The number of character to offset by.
+     * @param startOfLinePositions the position of the start of each line of content of the source file
+     * whose segment-marker we are offsetting.
+     * @param marker the segment to offset.
+     * @param offset the number of character to offset by.
      */
-    function offsetSegment(lineLengths, marker, offset) {
+    function offsetSegment(startOfLinePositions, marker, offset) {
         if (offset === 0) {
             return marker;
         }
         var line = marker.line;
-        var column = marker.column + offset;
-        while (line < lineLengths.length - 1 && column > lineLengths[line]) {
-            column -= lineLengths[line] + NEWLINE_MARKER_OFFSET;
+        var position = marker.position + offset;
+        while (line < startOfLinePositions.length - 1 && startOfLinePositions[line + 1] <= position) {
             line++;
         }
-        while (line > 0 && column < 0) {
+        while (line > 0 && startOfLinePositions[line] > position) {
             line--;
-            column += lineLengths[line] + NEWLINE_MARKER_OFFSET;
         }
-        return { line: line, column: column };
+        var column = position - startOfLinePositions[line];
+        return { line: line, column: column, position: position, next: undefined };
     }
     exports.offsetSegment = offsetSegment;
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/ngcc/src/sourcemaps/source_file.d.ts

@@ -22,7 +22,7 @@ export declare class SourceFile {
      * pure original source files).
      */
     readonly flattenedMappings: Mapping[];
-    readonly lineLengths: number[];
+    readonly startOfLinePositions: number[];
     constructor(
     /** The path to this source file. */
     sourcePath: AbsoluteFsPath, 
@@ -44,6 +44,18 @@ export declare class SourceFile {
      */
     private flattenMappings;
 }
+/**
+ *
+ * @param mappings The collection of mappings whose segment-markers we are searching.
+ * @param marker The segment-marker to match against those of the given `mappings`.
+ * @param exclusive If exclusive then we must find a mapping with a segment-marker that is
+ * exclusively earlier than the given `marker`.
+ * If not exclusive then we can return the highest mappings with an equivalent segment-marker to the
+ * given `marker`.
+ * @param lowerIndex If provided, this is used as a hint that the marker we are searching for has an
+ * index that is no lower than this.
+ */
+export declare function findLastMappingIndexBefore(mappings: Mapping[], marker: SegmentMarker, exclusive: boolean, lowerIndex: number): number;
 /**
  * A Mapping consists of two segment markers: one in the generated source and one in the original
  * source, which indicate the start of each segment. The end of a segment is indicated by the first
@@ -65,6 +77,21 @@ export declare function mergeMappings(generatedSource: SourceFile, ab: Mapping,
  * Parse the `rawMappings` into an array of parsed mappings, which reference source-files provided
  * in the `sources` parameter.
  */
-export declare function parseMappings(rawMap: RawSourceMap | null, sources: (SourceFile | null)[]): Mapping[];
-export declare function extractOriginalSegments(mappings: Mapping[]): SegmentMarker[];
-export declare function computeLineLengths(str: string): number[];
+export declare function parseMappings(rawMap: RawSourceMap | null, sources: (SourceFile | null)[], generatedSourceStartOfLinePositions: number[]): Mapping[];
+/**
+ * Extract the segment markers from the original source files in each mapping of an array of
+ * `mappings`.
+ *
+ * @param mappings The mappings whose original segments we want to extract
+ * @returns Return a map from original source-files (referenced in the `mappings`) to arrays of
+ * segment-markers sorted by their order in their source file.
+ */
+export declare function extractOriginalSegments(mappings: Mapping[]): Map<SourceFile, SegmentMarker[]>;
+/**
+ * Update the original segments of each of the given `mappings` to include a link to the next
+ * segment in the source file.
+ *
+ * @param mappings the mappings whose segments should be updated
+ */
+export declare function ensureOriginalSegmentLinks(mappings: Mapping[]): void;
+export declare function computeStartOfLinePositions(str: string): number[];

package/ngcc/src/sourcemaps/source_file.js

@@ -43,7 +43,7 @@
             this.inline = inline;
             this.sources = sources;
             this.contents = removeSourceMapComments(contents);
-            this.lineLengths = computeLineLengths(this.contents);
+            this.startOfLinePositions = computeStartOfLinePositions(this.contents);
             this.flattenedMappings = this.flattenMappings();
         }
         /**
@@ -99,17 +99,17 @@
          * source files with no transitive source maps.
          */
         SourceFile.prototype.flattenMappings = function () {
-            var mappings = parseMappings(this.rawMap, this.sources);
-            var originalSegments = extractOriginalSegments(mappings);
+            var mappings = parseMappings(this.rawMap, this.sources, this.startOfLinePositions);
+            ensureOriginalSegmentLinks(mappings);
             var flattenedMappings = [];
-            var _loop_1 = function (mappingIndex) {
+            for (var mappingIndex = 0; mappingIndex < mappings.length; mappingIndex++) {
                 var aToBmapping = mappings[mappingIndex];
                 var bSource = aToBmapping.originalSource;
                 if (bSource.flattenedMappings.length === 0) {
                     // The b source file has no mappings of its own (i.e. it is a pure original file)
                     // so just use the mapping as-is.
                     flattenedMappings.push(aToBmapping);
-                    return "continue";
+                    continue;
                 }
                 // The `incomingStart` and `incomingEnd` are the `SegmentMarker`s in `B` that represent the
                 // section of `B` source file that is being mapped to by the current `aToBmapping`.
@@ -130,10 +130,7 @@
                 // For mapping [4,2] the incoming start and end are 2 and 5 (i.e. the range c, d, e, f)
                 //
                 var incomingStart = aToBmapping.originalSegment;
-                var incomingEndIndex = originalSegments.indexOf(incomingStart) + 1;
-                var incomingEnd = incomingEndIndex < originalSegments.length ?
-                    originalSegments[incomingEndIndex] :
-                    undefined;
+                var incomingEnd = incomingStart.next;
                 // The `outgoingStartIndex` and `outgoingEndIndex` are the indices of the range of mappings
                 // that leave `b` that we are interested in merging with the aToBmapping.
                 // We actually care about all the markers from the last bToCmapping directly before the
@@ -155,35 +152,55 @@
                 // The range with `incomingStart` at 2 and `incomingEnd` at 5 has outgoing start mapping of
                 // [1,0] and outgoing end mapping of [4, 6], which also includes [4, 3].
                 //
-                var outgoingStartIndex = findLastIndex(bSource.flattenedMappings, function (mapping) { return segment_marker_1.compareSegments(mapping.generatedSegment, incomingStart) <= 0; });
+                var outgoingStartIndex = findLastMappingIndexBefore(bSource.flattenedMappings, incomingStart, false, 0);
                 if (outgoingStartIndex < 0) {
                     outgoingStartIndex = 0;
                 }
                 var outgoingEndIndex = incomingEnd !== undefined ?
-                    findLastIndex(bSource.flattenedMappings, function (mapping) { return segment_marker_1.compareSegments(mapping.generatedSegment, incomingEnd) < 0; }) :
+                    findLastMappingIndexBefore(bSource.flattenedMappings, incomingEnd, true, outgoingStartIndex) :
                     bSource.flattenedMappings.length - 1;
                 for (var bToCmappingIndex = outgoingStartIndex; bToCmappingIndex <= outgoingEndIndex; bToCmappingIndex++) {
                     var bToCmapping = bSource.flattenedMappings[bToCmappingIndex];
-                    flattenedMappings.push(mergeMappings(this_1, aToBmapping, bToCmapping));
+                    flattenedMappings.push(mergeMappings(this, aToBmapping, bToCmapping));
                 }
-            };
-            var this_1 = this;
-            for (var mappingIndex = 0; mappingIndex < mappings.length; mappingIndex++) {
-                _loop_1(mappingIndex);
             }
             return flattenedMappings;
         };
         return SourceFile;
     }());
     exports.SourceFile = SourceFile;
-    function findLastIndex(items, predicate) {
-        for (var index = items.length - 1; index >= 0; index--) {
-            if (predicate(items[index])) {
-                return index;
+    /**
+     *
+     * @param mappings The collection of mappings whose segment-markers we are searching.
+     * @param marker The segment-marker to match against those of the given `mappings`.
+     * @param exclusive If exclusive then we must find a mapping with a segment-marker that is
+     * exclusively earlier than the given `marker`.
+     * If not exclusive then we can return the highest mappings with an equivalent segment-marker to the
+     * given `marker`.
+     * @param lowerIndex If provided, this is used as a hint that the marker we are searching for has an
+     * index that is no lower than this.
+     */
+    function findLastMappingIndexBefore(mappings, marker, exclusive, lowerIndex) {
+        var upperIndex = mappings.length - 1;
+        var test = exclusive ? -1 : 0;
+        if (segment_marker_1.compareSegments(mappings[lowerIndex].generatedSegment, marker) > test) {
+            // Exit early since the marker is outside the allowed range of mappings.
+            return -1;
+        }
+        var matchingIndex = -1;
+        while (lowerIndex <= upperIndex) {
+            var index = (upperIndex + lowerIndex) >> 1;
+            if (segment_marker_1.compareSegments(mappings[index].generatedSegment, marker) <= test) {
+                matchingIndex = index;
+                lowerIndex = index + 1;
+            }
+            else {
+                upperIndex = index - 1;
             }
         }
-        return -1;
+        return matchingIndex;
     }
+    exports.findLastMappingIndexBefore = findLastMappingIndexBefore;
     /**
      * Find the index of `item` in the `items` array.
      * If it is not found, then push `item` to the end of the array and return its new index.
@@ -244,11 +261,11 @@
         // The difference between the "original segment-marker" of A->B (1*) and the "generated
         // segment-marker" of B->C (4*): `1 - 4 = -3`.
         // Since it is negative we must increment the "generated segment-marker" with `3` to give [3,2].
-        var diff = segment_marker_1.segmentDiff(ab.originalSource.lineLengths, ab.originalSegment, bc.generatedSegment);
+        var diff = segment_marker_1.compareSegments(bc.generatedSegment, ab.originalSegment);
         if (diff > 0) {
             return {
                 name: name,
-                generatedSegment: segment_marker_1.offsetSegment(generatedSource.lineLengths, ab.generatedSegment, diff),
+                generatedSegment: segment_marker_1.offsetSegment(generatedSource.startOfLinePositions, ab.generatedSegment, diff),
                 originalSource: bc.originalSource,
                 originalSegment: bc.originalSegment,
             };
@@ -258,7 +275,7 @@
                 name: name,
                 generatedSegment: ab.generatedSegment,
                 originalSource: bc.originalSource,
-                originalSegment: segment_marker_1.offsetSegment(bc.originalSource.lineLengths, bc.originalSegment, -diff),
+                originalSegment: segment_marker_1.offsetSegment(bc.originalSource.startOfLinePositions, bc.originalSegment, -diff),
             };
         }
     }
@@ -267,7 +284,7 @@
      * Parse the `rawMappings` into an array of parsed mappings, which reference source-files provided
      * in the `sources` parameter.
      */
-    function parseMappings(rawMap, sources) {
+    function parseMappings(rawMap, sources, generatedSourceStartOfLinePositions) {
         var e_2, _a;
         if (rawMap === null) {
             return [];
@@ -290,12 +307,21 @@
                         }
                         var generatedColumn = rawMapping[0];
                         var name = rawMapping.length === 5 ? rawMap.names[rawMapping[4]] : undefined;
-                        var mapping = {
-                            generatedSegment: { line: generatedLine, column: generatedColumn },
-                            originalSource: originalSource,
-                            originalSegment: { line: rawMapping[2], column: rawMapping[3] }, name: name
+                        var line = rawMapping[2];
+                        var column = rawMapping[3];
+                        var generatedSegment = {
+                            line: generatedLine,
+                            column: generatedColumn,
+                            position: generatedSourceStartOfLinePositions[generatedLine] + generatedColumn,
+                            next: undefined,
+                        };
+                        var originalSegment = {
+                            line: line,
+                            column: column,
+                            position: originalSource.startOfLinePositions[line] + column,
+                            next: undefined,
                         };
-                        mappings.push(mapping);
+                        mappings.push({ name: name, generatedSegment: generatedSegment, originalSegment: originalSegment, originalSource: originalSource });
                     }
                 }
             }
@@ -310,13 +336,71 @@
         return mappings;
     }
     exports.parseMappings = parseMappings;
+    /**
+     * Extract the segment markers from the original source files in each mapping of an array of
+     * `mappings`.
+     *
+     * @param mappings The mappings whose original segments we want to extract
+     * @returns Return a map from original source-files (referenced in the `mappings`) to arrays of
+     * segment-markers sorted by their order in their source file.
+     */
     function extractOriginalSegments(mappings) {
-        return mappings.map(function (mapping) { return mapping.originalSegment; }).sort(segment_marker_1.compareSegments);
+        var e_3, _a;
+        var originalSegments = new Map();
+        try {
+            for (var mappings_1 = tslib_1.__values(mappings), mappings_1_1 = mappings_1.next(); !mappings_1_1.done; mappings_1_1 = mappings_1.next()) {
+                var mapping = mappings_1_1.value;
+                var originalSource = mapping.originalSource;
+                if (!originalSegments.has(originalSource)) {
+                    originalSegments.set(originalSource, []);
+                }
+                var segments = originalSegments.get(originalSource);
+                segments.push(mapping.originalSegment);
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (mappings_1_1 && !mappings_1_1.done && (_a = mappings_1.return)) _a.call(mappings_1);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+        originalSegments.forEach(function (segmentMarkers) { return segmentMarkers.sort(segment_marker_1.compareSegments); });
+        return originalSegments;
     }
     exports.extractOriginalSegments = extractOriginalSegments;
+    /**
+     * Update the original segments of each of the given `mappings` to include a link to the next
+     * segment in the source file.
+     *
+     * @param mappings the mappings whose segments should be updated
+     */
+    function ensureOriginalSegmentLinks(mappings) {
+        var segmentsBySource = extractOriginalSegments(mappings);
+        segmentsBySource.forEach(function (markers) {
+            for (var i = 0; i < markers.length - 1; i++) {
+                markers[i].next = markers[i + 1];
+            }
+        });
+    }
+    exports.ensureOriginalSegmentLinks = ensureOriginalSegmentLinks;
+    function computeStartOfLinePositions(str) {
+        // The `1` is to indicate a newline character between the lines.
+        // Note that in the actual contents there could be more than one character that indicates a
+        // newline
+        // - e.g. \r\n - but that is not important here since segment-markers are in line/column pairs and
+        // so differences in length due to extra `\r` characters do not affect the algorithms.
+        var NEWLINE_MARKER_OFFSET = 1;
+        var lineLengths = computeLineLengths(str);
+        var startPositions = [0]; // First line starts at position 0
+        for (var i = 0; i < lineLengths.length - 1; i++) {
+            startPositions.push(startPositions[i] + lineLengths[i] + NEWLINE_MARKER_OFFSET);
+        }
+        return startPositions;
+    }
+    exports.computeStartOfLinePositions = computeStartOfLinePositions;
     function computeLineLengths(str) {
         return (str.split(/\r?\n/)).map(function (s) { return s.length; });
     }
-    exports.computeLineLengths = computeLineLengths;
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"source_file.js","sourceRoot":"","sources":["../../../../../../../../packages/compiler-cli/ngcc/src/sourcemaps/source_file.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nimport {removeComments, removeMapFileComments} from 'convert-source-map';\nimport {SourceMapMappings, SourceMapSegment, decode, encode} from 'sourcemap-codec';\nimport {AbsoluteFsPath, dirname, relative} from '../../../src/ngtsc/file_system';\nimport {RawSourceMap} from './raw_source_map';\nimport {SegmentMarker, compareSegments, offsetSegment, segmentDiff} from './segment_marker';\n\nexport function removeSourceMapComments(contents: string): string {\n  return removeMapFileComments(removeComments(contents)).replace(/\\n\\n$/, '\\n');\n}\n\nexport class SourceFile {\n  /**\n   * The parsed mappings that have been flattened so that any intermediate source mappings have been\n   * flattened.\n   *\n   * The result is that any source file mentioned in the flattened mappings have no source map (are\n   * pure original source files).\n   */\n  readonly flattenedMappings: Mapping[];\n  readonly lineLengths: number[];\n\n  constructor(\n      /** The path to this source file. */\n      readonly sourcePath: AbsoluteFsPath,\n      /** The contents of this source file. */\n      readonly contents: string,\n      /** The raw source map (if any) associated with this source file. */\n      readonly rawMap: RawSourceMap|null,\n      /** Whether this source file's source map was inline or external. */\n      readonly inline: boolean,\n      /** Any source files referenced by the raw source map associated with this source file. */\n      readonly sources: (SourceFile|null)[]) {\n    this.contents = removeSourceMapComments(contents);\n    this.lineLengths = computeLineLengths(this.contents);\n    this.flattenedMappings = this.flattenMappings();\n  }\n\n  /**\n   * Render the raw source map generated from the flattened mappings.\n   */\n  renderFlattenedSourceMap(): RawSourceMap {\n    const sources: SourceFile[] = [];\n    const names: string[] = [];\n\n    const mappings: SourceMapMappings = [];\n\n    for (const mapping of this.flattenedMappings) {\n      const sourceIndex = findIndexOrAdd(sources, mapping.originalSource);\n      const mappingArray: SourceMapSegment = [\n        mapping.generatedSegment.column,\n        sourceIndex,\n        mapping.originalSegment.line,\n        mapping.originalSegment.column,\n      ];\n      if (mapping.name !== undefined) {\n        const nameIndex = findIndexOrAdd(names, mapping.name);\n        mappingArray.push(nameIndex);\n      }\n\n      // Ensure a mapping line array for this mapping.\n      const line = mapping.generatedSegment.line;\n      while (line >= mappings.length) {\n        mappings.push([]);\n      }\n      // Add this mapping to the line\n      mappings[line].push(mappingArray);\n    }\n\n    const sourcePathDir = dirname(this.sourcePath);\n    const sourceMap: RawSourceMap = {\n      version: 3,\n      file: relative(sourcePathDir, this.sourcePath),\n      sources: sources.map(sf => relative(sourcePathDir, sf.sourcePath)), names,\n      mappings: encode(mappings),\n      sourcesContent: sources.map(sf => sf.contents),\n    };\n    return sourceMap;\n  }\n\n  /**\n   * Flatten the parsed mappings for this source file, so that all the mappings are to pure original\n   * source files with no transitive source maps.\n   */\n  private flattenMappings(): Mapping[] {\n    const mappings = parseMappings(this.rawMap, this.sources);\n    const originalSegments = extractOriginalSegments(mappings);\n    const flattenedMappings: Mapping[] = [];\n    for (let mappingIndex = 0; mappingIndex < mappings.length; mappingIndex++) {\n      const aToBmapping = mappings[mappingIndex];\n      const bSource = aToBmapping.originalSource;\n      if (bSource.flattenedMappings.length === 0) {\n        // The b source file has no mappings of its own (i.e. it is a pure original file)\n        // so just use the mapping as-is.\n        flattenedMappings.push(aToBmapping);\n        continue;\n      }\n\n      // The `incomingStart` and `incomingEnd` are the `SegmentMarker`s in `B` that represent the\n      // section of `B` source file that is being mapped to by the current `aToBmapping`.\n      //\n      // For example, consider the mappings from A to B:\n      //\n      // src A   src B     mapping\n      //\n      //   a ----- a       [0, 0]\n      //   b       b\n      //   f -  /- c       [4, 2]\n      //   g  \\ /  d\n      //   c -/\\   e\n      //   d    \\- f       [2, 5]\n      //   e\n      //\n      // For mapping [0,0] the incoming start and end are 0 and 2 (i.e. the range a, b, c)\n      // For mapping [4,2] the incoming start and end are 2 and 5 (i.e. the range c, d, e, f)\n      //\n      const incomingStart = aToBmapping.originalSegment;\n      const incomingEndIndex = originalSegments.indexOf(incomingStart) + 1;\n      const incomingEnd = incomingEndIndex < originalSegments.length ?\n          originalSegments[incomingEndIndex] :\n          undefined;\n\n      // The `outgoingStartIndex` and `outgoingEndIndex` are the indices of the range of mappings\n      // that leave `b` that we are interested in merging with the aToBmapping.\n      // We actually care about all the markers from the last bToCmapping directly before the\n      // `incomingStart` to the last bToCmaping directly before the `incomingEnd`, inclusive.\n      //\n      // For example, if we consider the range 2 to 5 from above (i.e. c, d, e, f) with the\n      // following mappings from B to C:\n      //\n      //   src B   src C     mapping\n      //     a\n      //     b ----- b       [1, 0]\n      //   - c       c\n      //  |  d       d\n      //  |  e ----- 1       [4, 3]\n      //   - f  \\    2\n      //         \\   3\n      //          \\- e       [4, 6]\n      //\n      // The range with `incomingStart` at 2 and `incomingEnd` at 5 has outgoing start mapping of\n      // [1,0] and outgoing end mapping of [4, 6], which also includes [4, 3].\n      //\n      let outgoingStartIndex = findLastIndex(\n          bSource.flattenedMappings,\n          mapping => compareSegments(mapping.generatedSegment, incomingStart) <= 0);\n      if (outgoingStartIndex < 0) {\n        outgoingStartIndex = 0;\n      }\n      const outgoingEndIndex = incomingEnd !== undefined ?\n          findLastIndex(\n              bSource.flattenedMappings,\n              mapping => compareSegments(mapping.generatedSegment, incomingEnd) < 0) :\n          bSource.flattenedMappings.length - 1;\n\n      for (let bToCmappingIndex = outgoingStartIndex; bToCmappingIndex <= outgoingEndIndex;\n           bToCmappingIndex++) {\n        const bToCmapping: Mapping = bSource.flattenedMappings[bToCmappingIndex];\n        flattenedMappings.push(mergeMappings(this, aToBmapping, bToCmapping));\n      }\n    }\n    return flattenedMappings;\n  }\n}\n\nfunction findLastIndex<T>(items: T[], predicate: (item: T) => boolean): number {\n  for (let index = items.length - 1; index >= 0; index--) {\n    if (predicate(items[index])) {\n      return index;\n    }\n  }\n  return -1;\n}\n\n/**\n * A Mapping consists of two segment markers: one in the generated source and one in the original\n * source, which indicate the start of each segment. The end of a segment is indicated by the first\n * segment marker of another mapping whose start is greater or equal to this one.\n *\n * It may also include a name associated with the segment being mapped.\n */\nexport interface Mapping {\n  readonly generatedSegment: SegmentMarker;\n  readonly originalSource: SourceFile;\n  readonly originalSegment: SegmentMarker;\n  readonly name?: string;\n}\n\n/**\n * Find the index of `item` in the `items` array.\n * If it is not found, then push `item` to the end of the array and return its new index.\n *\n * @param items the collection in which to look for `item`.\n * @param item the item to look for.\n * @returns the index of the `item` in the `items` array.\n */\nfunction findIndexOrAdd<T>(items: T[], item: T): number {\n  const itemIndex = items.indexOf(item);\n  if (itemIndex > -1) {\n    return itemIndex;\n  } else {\n    items.push(item);\n    return items.length - 1;\n  }\n}\n\n\n/**\n * Merge two mappings that go from A to B and B to C, to result in a mapping that goes from A to C.\n */\nexport function mergeMappings(generatedSource: SourceFile, ab: Mapping, bc: Mapping): Mapping {\n  const name = bc.name || ab.name;\n\n  // We need to modify the segment-markers of the new mapping to take into account the shifts that\n  // occur due to the combination of the two mappings.\n  // For example:\n\n  // * Simple map where the B->C starts at the same place the A->B ends:\n  //\n  // ```\n  // A: 1 2 b c d\n  //        |        A->B [2,0]\n  //        |              |\n  // B:     b c d    A->C [2,1]\n  //        |                |\n  //        |        B->C [0,1]\n  // C:   a b c d e\n  // ```\n\n  // * More complicated case where diffs of segment-markers is needed:\n  //\n  // ```\n  // A: b 1 2 c d\n  //     \\\n  //      |            A->B  [0,1*]    [0,1*]\n  //      |                   |         |+3\n  // B: a b 1 2 c d    A->C  [0,1]     [3,2]\n  //    |      /                |+1       |\n  //    |     /        B->C [0*,0]    [4*,2]\n  //    |    /\n  // C: a b c d e\n  // ```\n  //\n  // `[0,1]` mapping from A->C:\n  // The difference between the \"original segment-marker\" of A->B (1*) and the \"generated\n  // segment-marker of B->C (0*): `1 - 0 = +1`.\n  // Since it is positive we must increment the \"original segment-marker\" with `1` to give [0,1].\n  //\n  // `[3,2]` mapping from A->C:\n  // The difference between the \"original segment-marker\" of A->B (1*) and the \"generated\n  // segment-marker\" of B->C (4*): `1 - 4 = -3`.\n  // Since it is negative we must increment the \"generated segment-marker\" with `3` to give [3,2].\n\n  const diff = segmentDiff(ab.originalSource.lineLengths, ab.originalSegment, bc.generatedSegment);\n  if (diff > 0) {\n    return {\n      name,\n      generatedSegment: offsetSegment(generatedSource.lineLengths, ab.generatedSegment, diff),\n      originalSource: bc.originalSource,\n      originalSegment: bc.originalSegment,\n    };\n  } else {\n    return {\n      name,\n      generatedSegment: ab.generatedSegment,\n      originalSource: bc.originalSource,\n      originalSegment: offsetSegment(bc.originalSource.lineLengths, bc.originalSegment, -diff),\n    };\n  }\n}\n\n/**\n * Parse the `rawMappings` into an array of parsed mappings, which reference source-files provided\n * in the `sources` parameter.\n */\nexport function parseMappings(\n    rawMap: RawSourceMap | null, sources: (SourceFile | null)[]): Mapping[] {\n  if (rawMap === null) {\n    return [];\n  }\n\n  const rawMappings = decode(rawMap.mappings);\n  if (rawMappings === null) {\n    return [];\n  }\n\n  const mappings: Mapping[] = [];\n  for (let generatedLine = 0; generatedLine < rawMappings.length; generatedLine++) {\n    const generatedLineMappings = rawMappings[generatedLine];\n    for (const rawMapping of generatedLineMappings) {\n      if (rawMapping.length >= 4) {\n        const originalSource = sources[rawMapping[1] !];\n        if (originalSource === null || originalSource === undefined) {\n          // the original source is missing so ignore this mapping\n          continue;\n        }\n        const generatedColumn = rawMapping[0];\n        const name = rawMapping.length === 5 ? rawMap.names[rawMapping[4]] : undefined;\n        const mapping: Mapping = {\n          generatedSegment: {line: generatedLine, column: generatedColumn},\n          originalSource,\n          originalSegment: {line: rawMapping[2] !, column: rawMapping[3] !}, name\n        };\n        mappings.push(mapping);\n      }\n    }\n  }\n  return mappings;\n}\n\nexport function extractOriginalSegments(mappings: Mapping[]): SegmentMarker[] {\n  return mappings.map(mapping => mapping.originalSegment).sort(compareSegments);\n}\n\nexport function computeLineLengths(str: string): number[] {\n  return (str.split(/\\r?\\n/)).map(s => s.length);\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"source_file.js","sourceRoot":"","sources":["../../../../../../../../packages/compiler-cli/ngcc/src/sourcemaps/source_file.ts"],"names":[],"mappings":";;;;;;;;;;;;IAAA;;;;;;OAMG;IACH,yDAAyE;IACzE,mDAAoF;IACpF,2EAAiF;IAEjF,2FAA+E;IAE/E,SAAgB,uBAAuB,CAAC,QAAgB;QACtD,OAAO,0CAAqB,CAAC,mCAAc,CAAC,QAAQ,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;IAChF,CAAC;IAFD,0DAEC;IAED;QAWE;QACI,oCAAoC;QAC3B,UAA0B;QACnC,wCAAwC;QAC/B,QAAgB;QACzB,oEAAoE;QAC3D,MAAyB;QAClC,oEAAoE;QAC3D,MAAe;QACxB,0FAA0F;QACjF,OAA4B;YAR5B,eAAU,GAAV,UAAU,CAAgB;YAE1B,aAAQ,GAAR,QAAQ,CAAQ;YAEhB,WAAM,GAAN,MAAM,CAAmB;YAEzB,WAAM,GAAN,MAAM,CAAS;YAEf,YAAO,GAAP,OAAO,CAAqB;YACvC,IAAI,CAAC,QAAQ,GAAG,uBAAuB,CAAC,QAAQ,CAAC,CAAC;YAClD,IAAI,CAAC,oBAAoB,GAAG,2BAA2B,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;YACvE,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC,eAAe,EAAE,CAAC;QAClD,CAAC;QAED;;WAEG;QACH,6CAAwB,GAAxB;;YACE,IAAM,OAAO,GAAiB,EAAE,CAAC;YACjC,IAAM,KAAK,GAAa,EAAE,CAAC;YAE3B,IAAM,QAAQ,GAAsB,EAAE,CAAC;;gBAEvC,KAAsB,IAAA,KAAA,iBAAA,IAAI,CAAC,iBAAiB,CAAA,gBAAA,4BAAE;oBAAzC,IAAM,OAAO,WAAA;oBAChB,IAAM,WAAW,GAAG,cAAc,CAAC,OAAO,EAAE,OAAO,CAAC,cAAc,CAAC,CAAC;oBACpE,IAAM,YAAY,GAAqB;wBACrC,OAAO,CAAC,gBAAgB,CAAC,MAAM;wBAC/B,WAAW;wBACX,OAAO,CAAC,eAAe,CAAC,IAAI;wBAC5B,OAAO,CAAC,eAAe,CAAC,MAAM;qBAC/B,CAAC;oBACF,IAAI,OAAO,CAAC,IAAI,KAAK,SAAS,EAAE;wBAC9B,IAAM,SAAS,GAAG,cAAc,CAAC,KAAK,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;wBACtD,YAAY,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;qBAC9B;oBAED,gDAAgD;oBAChD,IAAM,IAAI,GAAG,OAAO,CAAC,gBAAgB,CAAC,IAAI,CAAC;oBAC3C,OAAO,IAAI,IAAI,QAAQ,CAAC,MAAM,EAAE;wBAC9B,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;qBACnB;oBACD,+BAA+B;oBAC/B,QAAQ,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;iBACnC;;;;;;;;;YAED,IAAM,aAAa,GAAG,qBAAO,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;YAC/C,IAAM,SAAS,GAAiB;gBAC9B,OAAO,EAAE,CAAC;gBACV,IAAI,EAAE,sBAAQ,CAAC,aAAa,EAAE,IAAI,CAAC,UAAU,CAAC;gBAC9C,OAAO,EAAE,OAAO,CAAC,GAAG,CAAC,UAAA,EAAE,IAAI,OAAA,sBAAQ,CAAC,aAAa,EAAE,EAAE,CAAC,UAAU,CAAC,EAAtC,CAAsC,CAAC,EAAE,KAAK,OAAA;gBACzE,QAAQ,EAAE,wBAAM,CAAC,QAAQ,CAAC;gBAC1B,cAAc,EAAE,OAAO,CAAC,GAAG,CAAC,UAAA,EAAE,IAAI,OAAA,EAAE,CAAC,QAAQ,EAAX,CAAW,CAAC;aAC/C,CAAC;YACF,OAAO,SAAS,CAAC;QACnB,CAAC;QAED;;;WAGG;QACK,oCAAe,GAAvB;YACE,IAAM,QAAQ,GAAG,aAAa,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,oBAAoB,CAAC,CAAC;YACrF,0BAA0B,CAAC,QAAQ,CAAC,CAAC;YACrC,IAAM,iBAAiB,GAAc,EAAE,CAAC;YACxC,KAAK,IAAI,YAAY,GAAG,CAAC,EAAE,YAAY,GAAG,QAAQ,CAAC,MAAM,EAAE,YAAY,EAAE,EAAE;gBACzE,IAAM,WAAW,GAAG,QAAQ,CAAC,YAAY,CAAC,CAAC;gBAC3C,IAAM,OAAO,GAAG,WAAW,CAAC,cAAc,CAAC;gBAC3C,IAAI,OAAO,CAAC,iBAAiB,CAAC,MAAM,KAAK,CAAC,EAAE;oBAC1C,iFAAiF;oBACjF,iCAAiC;oBACjC,iBAAiB,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;oBACpC,SAAS;iBACV;gBAED,2FAA2F;gBAC3F,mFAAmF;gBACnF,EAAE;gBACF,kDAAkD;gBAClD,EAAE;gBACF,4BAA4B;gBAC5B,EAAE;gBACF,2BAA2B;gBAC3B,cAAc;gBACd,2BAA2B;gBAC3B,cAAc;gBACd,cAAc;gBACd,2BAA2B;gBAC3B,MAAM;gBACN,EAAE;gBACF,oFAAoF;gBACpF,uFAAuF;gBACvF,EAAE;gBACF,IAAM,aAAa,GAAG,WAAW,CAAC,eAAe,CAAC;gBAClD,IAAM,WAAW,GAAG,aAAa,CAAC,IAAI,CAAC;gBAEvC,2FAA2F;gBAC3F,yEAAyE;gBACzE,uFAAuF;gBACvF,uFAAuF;gBACvF,EAAE;gBACF,qFAAqF;gBACrF,kCAAkC;gBAClC,EAAE;gBACF,8BAA8B;gBAC9B,QAAQ;gBACR,6BAA6B;gBAC7B,gBAAgB;gBAChB,gBAAgB;gBAChB,6BAA6B;gBAC7B,gBAAgB;gBAChB,gBAAgB;gBAChB,6BAA6B;gBAC7B,EAAE;gBACF,2FAA2F;gBAC3F,wEAAwE;gBACxE,EAAE;gBACF,IAAI,kBAAkB,GAClB,0BAA0B,CAAC,OAAO,CAAC,iBAAiB,EAAE,aAAa,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC;gBACnF,IAAI,kBAAkB,GAAG,CAAC,EAAE;oBAC1B,kBAAkB,GAAG,CAAC,CAAC;iBACxB;gBACD,IAAM,gBAAgB,GAAG,WAAW,KAAK,SAAS,CAAC,CAAC;oBAChD,0BAA0B,CACtB,OAAO,CAAC,iBAAiB,EAAE,WAAW,EAAE,IAAI,EAAE,kBAAkB,CAAC,CAAC,CAAC;oBACvE,OAAO,CAAC,iBAAiB,CAAC,MAAM,GAAG,CAAC,CAAC;gBAEzC,KAAK,IAAI,gBAAgB,GAAG,kBAAkB,EAAE,gBAAgB,IAAI,gBAAgB,EAC/E,gBAAgB,EAAE,EAAE;oBACvB,IAAM,WAAW,GAAY,OAAO,CAAC,iBAAiB,CAAC,gBAAgB,CAAC,CAAC;oBACzE,iBAAiB,CAAC,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE,WAAW,EAAE,WAAW,CAAC,CAAC,CAAC;iBACvE;aACF;YACD,OAAO,iBAAiB,CAAC;QAC3B,CAAC;QACH,iBAAC;IAAD,CAAC,AAnJD,IAmJC;IAnJY,gCAAU;IAqJvB;;;;;;;;;;OAUG;IACH,SAAgB,0BAA0B,CACtC,QAAmB,EAAE,MAAqB,EAAE,SAAkB,EAAE,UAAkB;QACpF,IAAI,UAAU,GAAG,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC;QACrC,IAAM,IAAI,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAEhC,IAAI,gCAAe,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC,gBAAgB,EAAE,MAAM,CAAC,GAAG,IAAI,EAAE;YACzE,wEAAwE;YACxE,OAAO,CAAC,CAAC,CAAC;SACX;QAED,IAAI,aAAa,GAAG,CAAC,CAAC,CAAC;QACvB,OAAO,UAAU,IAAI,UAAU,EAAE;YAC/B,IAAM,KAAK,GAAG,CAAC,UAAU,GAAG,UAAU,CAAC,IAAI,CAAC,CAAC;YAC7C,IAAI,gCAAe,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,gBAAgB,EAAE,MAAM,CAAC,IAAI,IAAI,EAAE;gBACrE,aAAa,GAAG,KAAK,CAAC;gBACtB,UAAU,GAAG,KAAK,GAAG,CAAC,CAAC;aACxB;iBAAM;gBACL,UAAU,GAAG,KAAK,GAAG,CAAC,CAAC;aACxB;SACF;QACD,OAAO,aAAa,CAAC;IACvB,CAAC;IArBD,gEAqBC;IAgBD;;;;;;;OAOG;IACH,SAAS,cAAc,CAAI,KAAU,EAAE,IAAO;QAC5C,IAAM,SAAS,GAAG,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QACtC,IAAI,SAAS,GAAG,CAAC,CAAC,EAAE;YAClB,OAAO,SAAS,CAAC;SAClB;aAAM;YACL,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACjB,OAAO,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC;SACzB;IACH,CAAC;IAGD;;OAEG;IACH,SAAgB,aAAa,CAAC,eAA2B,EAAE,EAAW,EAAE,EAAW;QACjF,IAAM,IAAI,GAAG,EAAE,CAAC,IAAI,IAAI,EAAE,CAAC,IAAI,CAAC;QAEhC,gGAAgG;QAChG,oDAAoD;QACpD,eAAe;QAEf,sEAAsE;QACtE,EAAE;QACF,MAAM;QACN,eAAe;QACf,6BAA6B;QAC7B,0BAA0B;QAC1B,6BAA6B;QAC7B,4BAA4B;QAC5B,6BAA6B;QAC7B,iBAAiB;QACjB,MAAM;QAEN,oEAAoE;QACpE,EAAE;QACF,MAAM;QACN,eAAe;QACf,QAAQ;QACR,2CAA2C;QAC3C,yCAAyC;QACzC,0CAA0C;QAC1C,yCAAyC;QACzC,0CAA0C;QAC1C,YAAY;QACZ,eAAe;QACf,MAAM;QACN,EAAE;QACF,6BAA6B;QAC7B,uFAAuF;QACvF,6CAA6C;QAC7C,+FAA+F;QAC/F,EAAE;QACF,6BAA6B;QAC7B,uFAAuF;QACvF,8CAA8C;QAC9C,gGAAgG;QAEhG,IAAM,IAAI,GAAG,gCAAe,CAAC,EAAE,CAAC,gBAAgB,EAAE,EAAE,CAAC,eAAe,CAAC,CAAC;QACtE,IAAI,IAAI,GAAG,CAAC,EAAE;YACZ,OAAO;gBACL,IAAI,MAAA;gBACJ,gBAAgB,EACZ,8BAAa,CAAC,eAAe,CAAC,oBAAoB,EAAE,EAAE,CAAC,gBAAgB,EAAE,IAAI,CAAC;gBAClF,cAAc,EAAE,EAAE,CAAC,cAAc;gBACjC,eAAe,EAAE,EAAE,CAAC,eAAe;aACpC,CAAC;SACH;aAAM;YACL,OAAO;gBACL,IAAI,MAAA;gBACJ,gBAAgB,EAAE,EAAE,CAAC,gBAAgB;gBACrC,cAAc,EAAE,EAAE,CAAC,cAAc;gBACjC,eAAe,EACX,8BAAa,CAAC,EAAE,CAAC,cAAc,CAAC,oBAAoB,EAAE,EAAE,CAAC,eAAe,EAAE,CAAC,IAAI,CAAC;aACrF,CAAC;SACH;IACH,CAAC;IA7DD,sCA6DC;IAED;;;OAGG;IACH,SAAgB,aAAa,CACzB,MAA2B,EAAE,OAA8B,EAC3D,mCAA6C;;QAC/C,IAAI,MAAM,KAAK,IAAI,EAAE;YACnB,OAAO,EAAE,CAAC;SACX;QAED,IAAM,WAAW,GAAG,wBAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QAC5C,IAAI,WAAW,KAAK,IAAI,EAAE;YACxB,OAAO,EAAE,CAAC;SACX;QAED,IAAM,QAAQ,GAAc,EAAE,CAAC;QAC/B,KAAK,IAAI,aAAa,GAAG,CAAC,EAAE,aAAa,GAAG,WAAW,CAAC,MAAM,EAAE,aAAa,EAAE,EAAE;YAC/E,IAAM,qBAAqB,GAAG,WAAW,CAAC,aAAa,CAAC,CAAC;;gBACzD,KAAyB,IAAA,yCAAA,iBAAA,qBAAqB,CAAA,CAAA,4DAAA,+FAAE;oBAA3C,IAAM,UAAU,kCAAA;oBACnB,IAAI,UAAU,CAAC,MAAM,IAAI,CAAC,EAAE;wBAC1B,IAAM,cAAc,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC,CAAG,CAAC,CAAC;wBAChD,IAAI,cAAc,KAAK,IAAI,IAAI,cAAc,KAAK,SAAS,EAAE;4BAC3D,wDAAwD;4BACxD,SAAS;yBACV;wBACD,IAAM,eAAe,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC;wBACtC,IAAM,IAAI,GAAG,UAAU,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;wBAC/E,IAAM,IAAI,GAAG,UAAU,CAAC,CAAC,CAAG,CAAC;wBAC7B,IAAM,MAAM,GAAG,UAAU,CAAC,CAAC,CAAG,CAAC;wBAC/B,IAAM,gBAAgB,GAAkB;4BACtC,IAAI,EAAE,aAAa;4BACnB,MAAM,EAAE,eAAe;4BACvB,QAAQ,EAAE,mCAAmC,CAAC,aAAa,CAAC,GAAG,eAAe;4BAC9E,IAAI,EAAE,SAAS;yBAChB,CAAC;wBACF,IAAM,eAAe,GAAkB;4BACrC,IAAI,MAAA;4BACJ,MAAM,QAAA;4BACN,QAAQ,EAAE,cAAc,CAAC,oBAAoB,CAAC,IAAI,CAAC,GAAG,MAAM;4BAC5D,IAAI,EAAE,SAAS;yBAChB,CAAC;wBACF,QAAQ,CAAC,IAAI,CAAC,EAAC,IAAI,MAAA,EAAE,gBAAgB,kBAAA,EAAE,eAAe,iBAAA,EAAE,cAAc,gBAAA,EAAC,CAAC,CAAC;qBAC1E;iBACF;;;;;;;;;SACF;QACD,OAAO,QAAQ,CAAC;IAClB,CAAC;IA3CD,sCA2CC;IAED;;;;;;;OAOG;IACH,SAAgB,uBAAuB,CAAC,QAAmB;;QACzD,IAAM,gBAAgB,GAAG,IAAI,GAAG,EAA+B,CAAC;;YAChE,KAAsB,IAAA,aAAA,iBAAA,QAAQ,CAAA,kCAAA,wDAAE;gBAA3B,IAAM,OAAO,qBAAA;gBAChB,IAAM,cAAc,GAAG,OAAO,CAAC,cAAc,CAAC;gBAC9C,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,cAAc,CAAC,EAAE;oBACzC,gBAAgB,CAAC,GAAG,CAAC,cAAc,EAAE,EAAE,CAAC,CAAC;iBAC1C;gBACD,IAAM,QAAQ,GAAG,gBAAgB,CAAC,GAAG,CAAC,cAAc,CAAG,CAAC;gBACxD,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,eAAe,CAAC,CAAC;aACxC;;;;;;;;;QACD,gBAAgB,CAAC,OAAO,CAAC,UAAA,cAAc,IAAI,OAAA,cAAc,CAAC,IAAI,CAAC,gCAAe,CAAC,EAApC,CAAoC,CAAC,CAAC;QACjF,OAAO,gBAAgB,CAAC;IAC1B,CAAC;IAZD,0DAYC;IAED;;;;;OAKG;IACH,SAAgB,0BAA0B,CAAC,QAAmB;QAC5D,IAAM,gBAAgB,GAAG,uBAAuB,CAAC,QAAQ,CAAC,CAAC;QAC3D,gBAAgB,CAAC,OAAO,CAAC,UAAA,OAAO;YAC9B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE;gBAC3C,OAAO,CAAC,CAAC,CAAC,CAAC,IAAI,GAAG,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;aAClC;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAPD,gEAOC;IAED,SAAgB,2BAA2B,CAAC,GAAW;QACrD,gEAAgE;QAChE,2FAA2F;QAC3F,UAAU;QACV,kGAAkG;QAClG,sFAAsF;QACtF,IAAM,qBAAqB,GAAG,CAAC,CAAC;QAChC,IAAM,WAAW,GAAG,kBAAkB,CAAC,GAAG,CAAC,CAAC;QAC5C,IAAM,cAAc,GAAG,CAAC,CAAC,CAAC,CAAC,CAAE,kCAAkC;QAC/D,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,WAAW,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE;YAC/C,cAAc,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,GAAG,qBAAqB,CAAC,CAAC;SACjF;QACD,OAAO,cAAc,CAAC;IACxB,CAAC;IAbD,kEAaC;IAED,SAAS,kBAAkB,CAAC,GAAW;QACrC,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,UAAA,CAAC,IAAI,OAAA,CAAC,CAAC,MAAM,EAAR,CAAQ,CAAC,CAAC;IACjD,CAAC","sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nimport {removeComments, removeMapFileComments} from 'convert-source-map';\nimport {SourceMapMappings, SourceMapSegment, decode, encode} from 'sourcemap-codec';\nimport {AbsoluteFsPath, dirname, relative} from '../../../src/ngtsc/file_system';\nimport {RawSourceMap} from './raw_source_map';\nimport {SegmentMarker, compareSegments, offsetSegment} from './segment_marker';\n\nexport function removeSourceMapComments(contents: string): string {\n  return removeMapFileComments(removeComments(contents)).replace(/\\n\\n$/, '\\n');\n}\n\nexport class SourceFile {\n  /**\n   * The parsed mappings that have been flattened so that any intermediate source mappings have been\n   * flattened.\n   *\n   * The result is that any source file mentioned in the flattened mappings have no source map (are\n   * pure original source files).\n   */\n  readonly flattenedMappings: Mapping[];\n  readonly startOfLinePositions: number[];\n\n  constructor(\n      /** The path to this source file. */\n      readonly sourcePath: AbsoluteFsPath,\n      /** The contents of this source file. */\n      readonly contents: string,\n      /** The raw source map (if any) associated with this source file. */\n      readonly rawMap: RawSourceMap|null,\n      /** Whether this source file's source map was inline or external. */\n      readonly inline: boolean,\n      /** Any source files referenced by the raw source map associated with this source file. */\n      readonly sources: (SourceFile|null)[]) {\n    this.contents = removeSourceMapComments(contents);\n    this.startOfLinePositions = computeStartOfLinePositions(this.contents);\n    this.flattenedMappings = this.flattenMappings();\n  }\n\n  /**\n   * Render the raw source map generated from the flattened mappings.\n   */\n  renderFlattenedSourceMap(): RawSourceMap {\n    const sources: SourceFile[] = [];\n    const names: string[] = [];\n\n    const mappings: SourceMapMappings = [];\n\n    for (const mapping of this.flattenedMappings) {\n      const sourceIndex = findIndexOrAdd(sources, mapping.originalSource);\n      const mappingArray: SourceMapSegment = [\n        mapping.generatedSegment.column,\n        sourceIndex,\n        mapping.originalSegment.line,\n        mapping.originalSegment.column,\n      ];\n      if (mapping.name !== undefined) {\n        const nameIndex = findIndexOrAdd(names, mapping.name);\n        mappingArray.push(nameIndex);\n      }\n\n      // Ensure a mapping line array for this mapping.\n      const line = mapping.generatedSegment.line;\n      while (line >= mappings.length) {\n        mappings.push([]);\n      }\n      // Add this mapping to the line\n      mappings[line].push(mappingArray);\n    }\n\n    const sourcePathDir = dirname(this.sourcePath);\n    const sourceMap: RawSourceMap = {\n      version: 3,\n      file: relative(sourcePathDir, this.sourcePath),\n      sources: sources.map(sf => relative(sourcePathDir, sf.sourcePath)), names,\n      mappings: encode(mappings),\n      sourcesContent: sources.map(sf => sf.contents),\n    };\n    return sourceMap;\n  }\n\n  /**\n   * Flatten the parsed mappings for this source file, so that all the mappings are to pure original\n   * source files with no transitive source maps.\n   */\n  private flattenMappings(): Mapping[] {\n    const mappings = parseMappings(this.rawMap, this.sources, this.startOfLinePositions);\n    ensureOriginalSegmentLinks(mappings);\n    const flattenedMappings: Mapping[] = [];\n    for (let mappingIndex = 0; mappingIndex < mappings.length; mappingIndex++) {\n      const aToBmapping = mappings[mappingIndex];\n      const bSource = aToBmapping.originalSource;\n      if (bSource.flattenedMappings.length === 0) {\n        // The b source file has no mappings of its own (i.e. it is a pure original file)\n        // so just use the mapping as-is.\n        flattenedMappings.push(aToBmapping);\n        continue;\n      }\n\n      // The `incomingStart` and `incomingEnd` are the `SegmentMarker`s in `B` that represent the\n      // section of `B` source file that is being mapped to by the current `aToBmapping`.\n      //\n      // For example, consider the mappings from A to B:\n      //\n      // src A   src B     mapping\n      //\n      //   a ----- a       [0, 0]\n      //   b       b\n      //   f -  /- c       [4, 2]\n      //   g  \\ /  d\n      //   c -/\\   e\n      //   d    \\- f       [2, 5]\n      //   e\n      //\n      // For mapping [0,0] the incoming start and end are 0 and 2 (i.e. the range a, b, c)\n      // For mapping [4,2] the incoming start and end are 2 and 5 (i.e. the range c, d, e, f)\n      //\n      const incomingStart = aToBmapping.originalSegment;\n      const incomingEnd = incomingStart.next;\n\n      // The `outgoingStartIndex` and `outgoingEndIndex` are the indices of the range of mappings\n      // that leave `b` that we are interested in merging with the aToBmapping.\n      // We actually care about all the markers from the last bToCmapping directly before the\n      // `incomingStart` to the last bToCmaping directly before the `incomingEnd`, inclusive.\n      //\n      // For example, if we consider the range 2 to 5 from above (i.e. c, d, e, f) with the\n      // following mappings from B to C:\n      //\n      //   src B   src C     mapping\n      //     a\n      //     b ----- b       [1, 0]\n      //   - c       c\n      //  |  d       d\n      //  |  e ----- 1       [4, 3]\n      //   - f  \\    2\n      //         \\   3\n      //          \\- e       [4, 6]\n      //\n      // The range with `incomingStart` at 2 and `incomingEnd` at 5 has outgoing start mapping of\n      // [1,0] and outgoing end mapping of [4, 6], which also includes [4, 3].\n      //\n      let outgoingStartIndex =\n          findLastMappingIndexBefore(bSource.flattenedMappings, incomingStart, false, 0);\n      if (outgoingStartIndex < 0) {\n        outgoingStartIndex = 0;\n      }\n      const outgoingEndIndex = incomingEnd !== undefined ?\n          findLastMappingIndexBefore(\n              bSource.flattenedMappings, incomingEnd, true, outgoingStartIndex) :\n          bSource.flattenedMappings.length - 1;\n\n      for (let bToCmappingIndex = outgoingStartIndex; bToCmappingIndex <= outgoingEndIndex;\n           bToCmappingIndex++) {\n        const bToCmapping: Mapping = bSource.flattenedMappings[bToCmappingIndex];\n        flattenedMappings.push(mergeMappings(this, aToBmapping, bToCmapping));\n      }\n    }\n    return flattenedMappings;\n  }\n}\n\n/**\n *\n * @param mappings The collection of mappings whose segment-markers we are searching.\n * @param marker The segment-marker to match against those of the given `mappings`.\n * @param exclusive If exclusive then we must find a mapping with a segment-marker that is\n * exclusively earlier than the given `marker`.\n * If not exclusive then we can return the highest mappings with an equivalent segment-marker to the\n * given `marker`.\n * @param lowerIndex If provided, this is used as a hint that the marker we are searching for has an\n * index that is no lower than this.\n */\nexport function findLastMappingIndexBefore(\n    mappings: Mapping[], marker: SegmentMarker, exclusive: boolean, lowerIndex: number): number {\n  let upperIndex = mappings.length - 1;\n  const test = exclusive ? -1 : 0;\n\n  if (compareSegments(mappings[lowerIndex].generatedSegment, marker) > test) {\n    // Exit early since the marker is outside the allowed range of mappings.\n    return -1;\n  }\n\n  let matchingIndex = -1;\n  while (lowerIndex <= upperIndex) {\n    const index = (upperIndex + lowerIndex) >> 1;\n    if (compareSegments(mappings[index].generatedSegment, marker) <= test) {\n      matchingIndex = index;\n      lowerIndex = index + 1;\n    } else {\n      upperIndex = index - 1;\n    }\n  }\n  return matchingIndex;\n}\n\n/**\n * A Mapping consists of two segment markers: one in the generated source and one in the original\n * source, which indicate the start of each segment. The end of a segment is indicated by the first\n * segment marker of another mapping whose start is greater or equal to this one.\n *\n * It may also include a name associated with the segment being mapped.\n */\nexport interface Mapping {\n  readonly generatedSegment: SegmentMarker;\n  readonly originalSource: SourceFile;\n  readonly originalSegment: SegmentMarker;\n  readonly name?: string;\n}\n\n/**\n * Find the index of `item` in the `items` array.\n * If it is not found, then push `item` to the end of the array and return its new index.\n *\n * @param items the collection in which to look for `item`.\n * @param item the item to look for.\n * @returns the index of the `item` in the `items` array.\n */\nfunction findIndexOrAdd<T>(items: T[], item: T): number {\n  const itemIndex = items.indexOf(item);\n  if (itemIndex > -1) {\n    return itemIndex;\n  } else {\n    items.push(item);\n    return items.length - 1;\n  }\n}\n\n\n/**\n * Merge two mappings that go from A to B and B to C, to result in a mapping that goes from A to C.\n */\nexport function mergeMappings(generatedSource: SourceFile, ab: Mapping, bc: Mapping): Mapping {\n  const name = bc.name || ab.name;\n\n  // We need to modify the segment-markers of the new mapping to take into account the shifts that\n  // occur due to the combination of the two mappings.\n  // For example:\n\n  // * Simple map where the B->C starts at the same place the A->B ends:\n  //\n  // ```\n  // A: 1 2 b c d\n  //        |        A->B [2,0]\n  //        |              |\n  // B:     b c d    A->C [2,1]\n  //        |                |\n  //        |        B->C [0,1]\n  // C:   a b c d e\n  // ```\n\n  // * More complicated case where diffs of segment-markers is needed:\n  //\n  // ```\n  // A: b 1 2 c d\n  //     \\\n  //      |            A->B  [0,1*]    [0,1*]\n  //      |                   |         |+3\n  // B: a b 1 2 c d    A->C  [0,1]     [3,2]\n  //    |      /                |+1       |\n  //    |     /        B->C [0*,0]    [4*,2]\n  //    |    /\n  // C: a b c d e\n  // ```\n  //\n  // `[0,1]` mapping from A->C:\n  // The difference between the \"original segment-marker\" of A->B (1*) and the \"generated\n  // segment-marker of B->C (0*): `1 - 0 = +1`.\n  // Since it is positive we must increment the \"original segment-marker\" with `1` to give [0,1].\n  //\n  // `[3,2]` mapping from A->C:\n  // The difference between the \"original segment-marker\" of A->B (1*) and the \"generated\n  // segment-marker\" of B->C (4*): `1 - 4 = -3`.\n  // Since it is negative we must increment the \"generated segment-marker\" with `3` to give [3,2].\n\n  const diff = compareSegments(bc.generatedSegment, ab.originalSegment);\n  if (diff > 0) {\n    return {\n      name,\n      generatedSegment:\n          offsetSegment(generatedSource.startOfLinePositions, ab.generatedSegment, diff),\n      originalSource: bc.originalSource,\n      originalSegment: bc.originalSegment,\n    };\n  } else {\n    return {\n      name,\n      generatedSegment: ab.generatedSegment,\n      originalSource: bc.originalSource,\n      originalSegment:\n          offsetSegment(bc.originalSource.startOfLinePositions, bc.originalSegment, -diff),\n    };\n  }\n}\n\n/**\n * Parse the `rawMappings` into an array of parsed mappings, which reference source-files provided\n * in the `sources` parameter.\n */\nexport function parseMappings(\n    rawMap: RawSourceMap | null, sources: (SourceFile | null)[],\n    generatedSourceStartOfLinePositions: number[]): Mapping[] {\n  if (rawMap === null) {\n    return [];\n  }\n\n  const rawMappings = decode(rawMap.mappings);\n  if (rawMappings === null) {\n    return [];\n  }\n\n  const mappings: Mapping[] = [];\n  for (let generatedLine = 0; generatedLine < rawMappings.length; generatedLine++) {\n    const generatedLineMappings = rawMappings[generatedLine];\n    for (const rawMapping of generatedLineMappings) {\n      if (rawMapping.length >= 4) {\n        const originalSource = sources[rawMapping[1] !];\n        if (originalSource === null || originalSource === undefined) {\n          // the original source is missing so ignore this mapping\n          continue;\n        }\n        const generatedColumn = rawMapping[0];\n        const name = rawMapping.length === 5 ? rawMap.names[rawMapping[4]] : undefined;\n        const line = rawMapping[2] !;\n        const column = rawMapping[3] !;\n        const generatedSegment: SegmentMarker = {\n          line: generatedLine,\n          column: generatedColumn,\n          position: generatedSourceStartOfLinePositions[generatedLine] + generatedColumn,\n          next: undefined,\n        };\n        const originalSegment: SegmentMarker = {\n          line,\n          column,\n          position: originalSource.startOfLinePositions[line] + column,\n          next: undefined,\n        };\n        mappings.push({name, generatedSegment, originalSegment, originalSource});\n      }\n    }\n  }\n  return mappings;\n}\n\n/**\n * Extract the segment markers from the original source files in each mapping of an array of\n * `mappings`.\n *\n * @param mappings The mappings whose original segments we want to extract\n * @returns Return a map from original source-files (referenced in the `mappings`) to arrays of\n * segment-markers sorted by their order in their source file.\n */\nexport function extractOriginalSegments(mappings: Mapping[]): Map<SourceFile, SegmentMarker[]> {\n  const originalSegments = new Map<SourceFile, SegmentMarker[]>();\n  for (const mapping of mappings) {\n    const originalSource = mapping.originalSource;\n    if (!originalSegments.has(originalSource)) {\n      originalSegments.set(originalSource, []);\n    }\n    const segments = originalSegments.get(originalSource) !;\n    segments.push(mapping.originalSegment);\n  }\n  originalSegments.forEach(segmentMarkers => segmentMarkers.sort(compareSegments));\n  return originalSegments;\n}\n\n/**\n * Update the original segments of each of the given `mappings` to include a link to the next\n * segment in the source file.\n *\n * @param mappings the mappings whose segments should be updated\n */\nexport function ensureOriginalSegmentLinks(mappings: Mapping[]): void {\n  const segmentsBySource = extractOriginalSegments(mappings);\n  segmentsBySource.forEach(markers => {\n    for (let i = 0; i < markers.length - 1; i++) {\n      markers[i].next = markers[i + 1];\n    }\n  });\n}\n\nexport function computeStartOfLinePositions(str: string) {\n  // The `1` is to indicate a newline character between the lines.\n  // Note that in the actual contents there could be more than one character that indicates a\n  // newline\n  // - e.g. \\r\\n - but that is not important here since segment-markers are in line/column pairs and\n  // so differences in length due to extra `\\r` characters do not affect the algorithms.\n  const NEWLINE_MARKER_OFFSET = 1;\n  const lineLengths = computeLineLengths(str);\n  const startPositions = [0];  // First line starts at position 0\n  for (let i = 0; i < lineLengths.length - 1; i++) {\n    startPositions.push(startPositions[i] + lineLengths[i] + NEWLINE_MARKER_OFFSET);\n  }\n  return startPositions;\n}\n\nfunction computeLineLengths(str: string): number[] {\n  return (str.split(/\\r?\\n/)).map(s => s.length);\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular/compiler-cli",
-  "version": "9.0.6",
+  "version": "9.0.7",
   "description": "Angular - the compiler CLI for Node.js",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -25,7 +25,7 @@
     "yargs": "13.1.0"
   },
   "peerDependencies": {
-    "@angular/compiler": "9.0.6",
+    "@angular/compiler": "9.0.7",
     "tslib": "^1.10.0",
     "typescript": ">=3.6 <3.8"
   },

package/src/version.js

@@ -22,6 +22,6 @@
      * Entry point for all public APIs of the common package.
      */
     var compiler_1 = require("@angular/compiler");
-    exports.VERSION = new compiler_1.Version('9.0.6');
+    exports.VERSION = new compiler_1.Version('9.0.7');
 });
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2NvbXBpbGVyLWNsaS9zcmMvdmVyc2lvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUc7Ozs7Ozs7Ozs7OztJQUVIOzs7O09BSUc7SUFFSCw4Q0FBMEM7SUFFN0IsUUFBQSxPQUFPLEdBQUcsSUFBSSxrQkFBTyxDQUFDLG1CQUFtQixDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIEluYy4gQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5cbi8qKlxuICogQG1vZHVsZVxuICogQGRlc2NyaXB0aW9uXG4gKiBFbnRyeSBwb2ludCBmb3IgYWxsIHB1YmxpYyBBUElzIG9mIHRoZSBjb21tb24gcGFja2FnZS5cbiAqL1xuXG5pbXBvcnQge1ZlcnNpb259IGZyb20gJ0Bhbmd1bGFyL2NvbXBpbGVyJztcblxuZXhwb3J0IGNvbnN0IFZFUlNJT04gPSBuZXcgVmVyc2lvbignMC4wLjAtUExBQ0VIT0xERVInKTtcbiJdfQ==

package/ngcc/src/execution/lock_file.d.ts

@@ -1,43 +0,0 @@
-/// <amd-module name="@angular/compiler-cli/ngcc/src/execution/lock_file" />
-import { FileSystem } from '../../../src/ngtsc/file_system';
-/**
- * The LockFile is used to prevent more than one instance of ngcc executing at the same time.
- *
- * When ngcc starts executing, it creates a file in the `compiler-cli/ngcc` folder. If it finds one
- * is already there then it fails with a suitable error message.
- * When ngcc completes executing, it removes the file so that future ngcc executions can start.
- */
-export declare class LockFile {
-    private fs;
-    lockFilePath: import("@angular/compiler-cli/src/ngtsc/file_system/src/types").BrandedPath<"AbsoluteFsPath">;
-    constructor(fs: FileSystem);
-    /**
-     * Run a function guarded by the lock file.
-     *
-     * Note that T can be a Promise. If so, we run the `remove()` call in the promise's `finally`
-     * handler. Otherwise we run the `remove()` call in the `try...finally` block.
-     *
-     * @param fn The function to run.
-     */
-    lock<T>(fn: () => T): T;
-    /**
-     * Write a lock file to disk, or error if there is already one there.
-     */
-    protected create(): void;
-    /**
-     * Remove the lock file from disk.
-     */
-    protected remove(): void;
-    protected addSignalHandlers(): void;
-    protected removeSignalHandlers(): void;
-    /**
-     * This handle needs to be defined as a property rather than a method
-     * so that it can be passed around as a bound function.
-     */
-    protected signalHandler: () => void;
-    /**
-     * This function wraps `process.exit()` which makes it easier to manage in unit tests,
-     * since it is not possible to mock out `process.exit()` when it is called from signal handlers.
-     */
-    protected exit(code: number): void;
-}