@angular/compiler-cli 8.1.0-next.3 → 8.1.2

package/src/ngtsc/file_system/src/helpers.js

@@ -0,0 +1,101 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define("@angular/compiler-cli/src/ngtsc/file_system/src/helpers", ["require", "exports", "tslib", "@angular/compiler-cli/src/ngtsc/file_system/src/invalid_file_system", "@angular/compiler-cli/src/ngtsc/file_system/src/util"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var tslib_1 = require("tslib");
+    var invalid_file_system_1 = require("@angular/compiler-cli/src/ngtsc/file_system/src/invalid_file_system");
+    var util_1 = require("@angular/compiler-cli/src/ngtsc/file_system/src/util");
+    var fs = new invalid_file_system_1.InvalidFileSystem();
+    function getFileSystem() {
+        return fs;
+    }
+    exports.getFileSystem = getFileSystem;
+    function setFileSystem(fileSystem) {
+        fs = fileSystem;
+    }
+    exports.setFileSystem = setFileSystem;
+    /**
+     * Convert the path `path` to an `AbsoluteFsPath`, throwing an error if it's not an absolute path.
+     */
+    function absoluteFrom(path) {
+        if (!fs.isRooted(path)) {
+            throw new Error("Internal Error: absoluteFrom(" + path + "): path is not absolute");
+        }
+        return fs.resolve(path);
+    }
+    exports.absoluteFrom = absoluteFrom;
+    /**
+     * Extract an `AbsoluteFsPath` from a `ts.SourceFile`.
+     */
+    function absoluteFromSourceFile(sf) {
+        return fs.resolve(sf.fileName);
+    }
+    exports.absoluteFromSourceFile = absoluteFromSourceFile;
+    /**
+    * Convert the path `path` to a `PathSegment`, throwing an error if it's not a relative path.
+    */
+    function relativeFrom(path) {
+        var normalized = util_1.normalizeSeparators(path);
+        if (fs.isRooted(normalized)) {
+            throw new Error("Internal Error: relativeFrom(" + path + "): path is not relative");
+        }
+        return normalized;
+    }
+    exports.relativeFrom = relativeFrom;
+    /**
+     * Static access to `dirname`.
+     */
+    function dirname(file) {
+        return fs.dirname(file);
+    }
+    exports.dirname = dirname;
+    /**
+     * Static access to `join`.
+     */
+    function join(basePath) {
+        var paths = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            paths[_i - 1] = arguments[_i];
+        }
+        return fs.join.apply(fs, tslib_1.__spread([basePath], paths));
+    }
+    exports.join = join;
+    /**
+     * Static access to `resolve`s.
+     */
+    function resolve(basePath) {
+        var paths = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            paths[_i - 1] = arguments[_i];
+        }
+        return fs.resolve.apply(fs, tslib_1.__spread([basePath], paths));
+    }
+    exports.resolve = resolve;
+    /** Returns true when the path provided is the root path. */
+    function isRoot(path) {
+        return fs.isRoot(path);
+    }
+    exports.isRoot = isRoot;
+    /**
+     * Static access to `relative`.
+     */
+    function relative(from, to) {
+        return fs.relative(from, to);
+    }
+    exports.relative = relative;
+    /**
+     * Static access to `basename`.
+     */
+    function basename(filePath, extension) {
+        return fs.basename(filePath, extension);
+    }
+    exports.basename = basename;
+});
+//# sourceMappingURL=data:application/json;base64,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

package/src/ngtsc/file_system/src/invalid_file_system.d.ts

@@ -0,0 +1,43 @@
+/// <amd-module name="@angular/compiler-cli/src/ngtsc/file_system/src/invalid_file_system" />
+/**
+ * @license
+ * Copyright Google Inc. 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
+ */
+import { AbsoluteFsPath, FileStats, FileSystem, PathSegment, PathString } from './types';
+/**
+ * The default `FileSystem` that will always fail.
+ *
+ * This is a way of ensuring that the developer consciously chooses and
+ * configures the `FileSystem` before using it; particularly important when
+ * considering static functions like `absoluteFrom()` which rely on
+ * the `FileSystem` under the hood.
+ */
+export declare class InvalidFileSystem implements FileSystem {
+    exists(path: AbsoluteFsPath): boolean;
+    readFile(path: AbsoluteFsPath): string;
+    writeFile(path: AbsoluteFsPath, data: string): void;
+    symlink(target: AbsoluteFsPath, path: AbsoluteFsPath): void;
+    readdir(path: AbsoluteFsPath): PathSegment[];
+    lstat(path: AbsoluteFsPath): FileStats;
+    stat(path: AbsoluteFsPath): FileStats;
+    pwd(): AbsoluteFsPath;
+    extname(path: AbsoluteFsPath | PathSegment): string;
+    copyFile(from: AbsoluteFsPath, to: AbsoluteFsPath): void;
+    moveFile(from: AbsoluteFsPath, to: AbsoluteFsPath): void;
+    mkdir(path: AbsoluteFsPath): void;
+    ensureDir(path: AbsoluteFsPath): void;
+    isCaseSensitive(): boolean;
+    resolve(...paths: string[]): AbsoluteFsPath;
+    dirname<T extends PathString>(file: T): T;
+    join<T extends PathString>(basePath: T, ...paths: string[]): T;
+    isRoot(path: AbsoluteFsPath): boolean;
+    isRooted(path: string): boolean;
+    relative<T extends PathString>(from: T, to: T): PathSegment;
+    basename(filePath: string, extension?: string): PathSegment;
+    realpath(filePath: AbsoluteFsPath): AbsoluteFsPath;
+    getDefaultLibLocation(): AbsoluteFsPath;
+    normalize<T extends PathString>(path: T): T;
+}

package/src/ngtsc/file_system/src/invalid_file_system.js

@@ -0,0 +1,66 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define("@angular/compiler-cli/src/ngtsc/file_system/src/invalid_file_system", ["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    /**
+     * The default `FileSystem` that will always fail.
+     *
+     * This is a way of ensuring that the developer consciously chooses and
+     * configures the `FileSystem` before using it; particularly important when
+     * considering static functions like `absoluteFrom()` which rely on
+     * the `FileSystem` under the hood.
+     */
+    var InvalidFileSystem = /** @class */ (function () {
+        function InvalidFileSystem() {
+        }
+        InvalidFileSystem.prototype.exists = function (path) { throw makeError(); };
+        InvalidFileSystem.prototype.readFile = function (path) { throw makeError(); };
+        InvalidFileSystem.prototype.writeFile = function (path, data) { throw makeError(); };
+        InvalidFileSystem.prototype.symlink = function (target, path) { throw makeError(); };
+        InvalidFileSystem.prototype.readdir = function (path) { throw makeError(); };
+        InvalidFileSystem.prototype.lstat = function (path) { throw makeError(); };
+        InvalidFileSystem.prototype.stat = function (path) { throw makeError(); };
+        InvalidFileSystem.prototype.pwd = function () { throw makeError(); };
+        InvalidFileSystem.prototype.extname = function (path) { throw makeError(); };
+        InvalidFileSystem.prototype.copyFile = function (from, to) { throw makeError(); };
+        InvalidFileSystem.prototype.moveFile = function (from, to) { throw makeError(); };
+        InvalidFileSystem.prototype.mkdir = function (path) { throw makeError(); };
+        InvalidFileSystem.prototype.ensureDir = function (path) { throw makeError(); };
+        InvalidFileSystem.prototype.isCaseSensitive = function () { throw makeError(); };
+        InvalidFileSystem.prototype.resolve = function () {
+            var paths = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                paths[_i] = arguments[_i];
+            }
+            throw makeError();
+        };
+        InvalidFileSystem.prototype.dirname = function (file) { throw makeError(); };
+        InvalidFileSystem.prototype.join = function (basePath) {
+            var paths = [];
+            for (var _i = 1; _i < arguments.length; _i++) {
+                paths[_i - 1] = arguments[_i];
+            }
+            throw makeError();
+        };
+        InvalidFileSystem.prototype.isRoot = function (path) { throw makeError(); };
+        InvalidFileSystem.prototype.isRooted = function (path) { throw makeError(); };
+        InvalidFileSystem.prototype.relative = function (from, to) { throw makeError(); };
+        InvalidFileSystem.prototype.basename = function (filePath, extension) { throw makeError(); };
+        InvalidFileSystem.prototype.realpath = function (filePath) { throw makeError(); };
+        InvalidFileSystem.prototype.getDefaultLibLocation = function () { throw makeError(); };
+        InvalidFileSystem.prototype.normalize = function (path) { throw makeError(); };
+        return InvalidFileSystem;
+    }());
+    exports.InvalidFileSystem = InvalidFileSystem;
+    function makeError() {
+        return new Error('FileSystem has not been configured. Please call `setFileSystem()` before calling this method.');
+    }
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW52YWxpZF9maWxlX3N5c3RlbS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2NvbXBpbGVyLWNsaS9zcmMvbmd0c2MvZmlsZV9zeXN0ZW0vc3JjL2ludmFsaWRfZmlsZV9zeXN0ZW0udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7SUFTQTs7Ozs7OztPQU9HO0lBQ0g7UUFBQTtRQXlCQSxDQUFDO1FBeEJDLGtDQUFNLEdBQU4sVUFBTyxJQUFvQixJQUFhLE1BQU0sU0FBUyxFQUFFLENBQUMsQ0FBQyxDQUFDO1FBQzVELG9DQUFRLEdBQVIsVUFBUyxJQUFvQixJQUFZLE1BQU0sU0FBUyxFQUFFLENBQUMsQ0FBQyxDQUFDO1FBQzdELHFDQUFTLEdBQVQsVUFBVSxJQUFvQixFQUFFLElBQVksSUFBVSxNQUFNLFNBQVMsRUFBRSxDQUFDLENBQUMsQ0FBQztRQUMxRSxtQ0FBTyxHQUFQLFVBQVEsTUFBc0IsRUFBRSxJQUFvQixJQUFVLE1BQU0sU0FBUyxFQUFFLENBQUMsQ0FBQyxDQUFDO1FBQ2xGLG1DQUFPLEdBQVAsVUFBUSxJQUFvQixJQUFtQixNQUFNLFNBQVMsRUFBRSxDQUFDLENBQUMsQ0FBQztRQUNuRSxpQ0FBSyxHQUFMLFVBQU0sSUFBb0IsSUFBZSxNQUFNLFNBQVMsRUFBRSxDQUFDLENBQUMsQ0FBQztRQUM3RCxnQ0FBSSxHQUFKLFVBQUssSUFBb0IsSUFBZSxNQUFNLFNBQVMsRUFBRSxDQUFDLENBQUMsQ0FBQztRQUM1RCwrQkFBRyxHQUFILGNBQXdCLE1BQU0sU0FBUyxFQUFFLENBQUMsQ0FBQyxDQUFDO1FBQzVDLG1DQUFPLEdBQVAsVUFBUSxJQUFnQyxJQUFZLE1BQU0sU0FBUyxFQUFFLENBQUMsQ0FBQyxDQUFDO1FBQ3hFLG9DQUFRLEdBQVIsVUFBUyxJQUFvQixFQUFFLEVBQWtCLElBQVUsTUFBTSxTQUFTLEVBQUUsQ0FBQyxDQUFDLENBQUM7UUFDL0Usb0NBQVEsR0FBUixVQUFTLElBQW9CLEVBQUUsRUFBa0IsSUFBVSxNQUFNLFNBQVMsRUFBRSxDQUFDLENBQUMsQ0FBQztRQUMvRSxpQ0FBSyxHQUFMLFVBQU0sSUFBb0IsSUFBVSxNQUFNLFNBQVMsRUFBRSxDQUFDLENBQUMsQ0FBQztRQUN4RCxxQ0FBUyxHQUFULFVBQVUsSUFBb0IsSUFBVSxNQUFNLFNBQVMsRUFBRSxDQUFDLENBQUMsQ0FBQztRQUM1RCwyQ0FBZSxHQUFmLGNBQTZCLE1BQU0sU0FBUyxFQUFFLENBQUMsQ0FBQyxDQUFDO1FBQ2pELG1DQUFPLEdBQVA7WUFBUSxlQUFrQjtpQkFBbEIsVUFBa0IsRUFBbEIscUJBQWtCLEVBQWxCLElBQWtCO2dCQUFsQiwwQkFBa0I7O1lBQW9CLE1BQU0sU0FBUyxFQUFFLENBQUM7UUFBQyxDQUFDO1FBQ2xFLG1DQUFPLEdBQVAsVUFBOEIsSUFBTyxJQUFPLE1BQU0sU0FBUyxFQUFFLENBQUMsQ0FBQyxDQUFDO1FBQ2hFLGdDQUFJLEdBQUosVUFBMkIsUUFBVztZQUFFLGVBQWtCO2lCQUFsQixVQUFrQixFQUFsQixxQkFBa0IsRUFBbEIsSUFBa0I7Z0JBQWxCLDhCQUFrQjs7WUFBTyxNQUFNLFNBQVMsRUFBRSxDQUFDO1FBQUMsQ0FBQztRQUNyRixrQ0FBTSxHQUFOLFVBQU8sSUFBb0IsSUFBYSxNQUFNLFNBQVMsRUFBRSxDQUFDLENBQUMsQ0FBQztRQUM1RCxvQ0FBUSxHQUFSLFVBQVMsSUFBWSxJQUFhLE1BQU0sU0FBUyxFQUFFLENBQUMsQ0FBQyxDQUFDO1FBQ3RELG9DQUFRLEdBQVIsVUFBK0IsSUFBTyxFQUFFLEVBQUssSUFBaUIsTUFBTSxTQUFTLEVBQUUsQ0FBQyxDQUFDLENBQUM7UUFDbEYsb0NBQVEsR0FBUixVQUFTLFFBQWdCLEVBQUUsU0FBa0IsSUFBaUIsTUFBTSxTQUFTLEVBQUUsQ0FBQyxDQUFDLENBQUM7UUFDbEYsb0NBQVEsR0FBUixVQUFTLFFBQXdCLElBQW9CLE1BQU0sU0FBUyxFQUFFLENBQUMsQ0FBQyxDQUFDO1FBQ3pFLGlEQUFxQixHQUFyQixjQUEwQyxNQUFNLFNBQVMsRUFBRSxDQUFDLENBQUMsQ0FBQztRQUM5RCxxQ0FBUyxHQUFULFVBQWdDLElBQU8sSUFBTyxNQUFNLFNBQVMsRUFBRSxDQUFDLENBQUMsQ0FBQztRQUNwRSx3QkFBQztJQUFELENBQUMsQUF6QkQsSUF5QkM7SUF6QlksOENBQWlCO0lBMkI5QixTQUFTLFNBQVM7UUFDaEIsT0FBTyxJQUFJLEtBQUssQ0FDWiwrRkFBK0YsQ0FBQyxDQUFDO0lBQ3ZHLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIEluYy4gQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5pbXBvcnQge0Fic29sdXRlRnNQYXRoLCBGaWxlU3RhdHMsIEZpbGVTeXN0ZW0sIFBhdGhTZWdtZW50LCBQYXRoU3RyaW5nfSBmcm9tICcuL3R5cGVzJztcblxuLyoqXG4gKiBUaGUgZGVmYXVsdCBgRmlsZVN5c3RlbWAgdGhhdCB3aWxsIGFsd2F5cyBmYWlsLlxuICpcbiAqIFRoaXMgaXMgYSB3YXkgb2YgZW5zdXJpbmcgdGhhdCB0aGUgZGV2ZWxvcGVyIGNvbnNjaW91c2x5IGNob29zZXMgYW5kXG4gKiBjb25maWd1cmVzIHRoZSBgRmlsZVN5c3RlbWAgYmVmb3JlIHVzaW5nIGl0OyBwYXJ0aWN1bGFybHkgaW1wb3J0YW50IHdoZW5cbiAqIGNvbnNpZGVyaW5nIHN0YXRpYyBmdW5jdGlvbnMgbGlrZSBgYWJzb2x1dGVGcm9tKClgIHdoaWNoIHJlbHkgb25cbiAqIHRoZSBgRmlsZVN5c3RlbWAgdW5kZXIgdGhlIGhvb2QuXG4gKi9cbmV4cG9ydCBjbGFzcyBJbnZhbGlkRmlsZVN5c3RlbSBpbXBsZW1lbnRzIEZpbGVTeXN0ZW0ge1xuICBleGlzdHMocGF0aDogQWJzb2x1dGVGc1BhdGgpOiBib29sZWFuIHsgdGhyb3cgbWFrZUVycm9yKCk7IH1cbiAgcmVhZEZpbGUocGF0aDogQWJzb2x1dGVGc1BhdGgpOiBzdHJpbmcgeyB0aHJvdyBtYWtlRXJyb3IoKTsgfVxuICB3cml0ZUZpbGUocGF0aDogQWJzb2x1dGVGc1BhdGgsIGRhdGE6IHN0cmluZyk6IHZvaWQgeyB0aHJvdyBtYWtlRXJyb3IoKTsgfVxuICBzeW1saW5rKHRhcmdldDogQWJzb2x1dGVGc1BhdGgsIHBhdGg6IEFic29sdXRlRnNQYXRoKTogdm9pZCB7IHRocm93IG1ha2VFcnJvcigpOyB9XG4gIHJlYWRkaXIocGF0aDogQWJzb2x1dGVGc1BhdGgpOiBQYXRoU2VnbWVudFtdIHsgdGhyb3cgbWFrZUVycm9yKCk7IH1cbiAgbHN0YXQocGF0aDogQWJzb2x1dGVGc1BhdGgpOiBGaWxlU3RhdHMgeyB0aHJvdyBtYWtlRXJyb3IoKTsgfVxuICBzdGF0KHBhdGg6IEFic29sdXRlRnNQYXRoKTogRmlsZVN0YXRzIHsgdGhyb3cgbWFrZUVycm9yKCk7IH1cbiAgcHdkKCk6IEFic29sdXRlRnNQYXRoIHsgdGhyb3cgbWFrZUVycm9yKCk7IH1cbiAgZXh0bmFtZShwYXRoOiBBYnNvbHV0ZUZzUGF0aHxQYXRoU2VnbWVudCk6IHN0cmluZyB7IHRocm93IG1ha2VFcnJvcigpOyB9XG4gIGNvcHlGaWxlKGZyb206IEFic29sdXRlRnNQYXRoLCB0bzogQWJzb2x1dGVGc1BhdGgpOiB2b2lkIHsgdGhyb3cgbWFrZUVycm9yKCk7IH1cbiAgbW92ZUZpbGUoZnJvbTogQWJzb2x1dGVGc1BhdGgsIHRvOiBBYnNvbHV0ZUZzUGF0aCk6IHZvaWQgeyB0aHJvdyBtYWtlRXJyb3IoKTsgfVxuICBta2RpcihwYXRoOiBBYnNvbHV0ZUZzUGF0aCk6IHZvaWQgeyB0aHJvdyBtYWtlRXJyb3IoKTsgfVxuICBlbnN1cmVEaXIocGF0aDogQWJzb2x1dGVGc1BhdGgpOiB2b2lkIHsgdGhyb3cgbWFrZUVycm9yKCk7IH1cbiAgaXNDYXNlU2Vuc2l0aXZlKCk6IGJvb2xlYW4geyB0aHJvdyBtYWtlRXJyb3IoKTsgfVxuICByZXNvbHZlKC4uLnBhdGhzOiBzdHJpbmdbXSk6IEFic29sdXRlRnNQYXRoIHsgdGhyb3cgbWFrZUVycm9yKCk7IH1cbiAgZGlybmFtZTxUIGV4dGVuZHMgUGF0aFN0cmluZz4oZmlsZTogVCk6IFQgeyB0aHJvdyBtYWtlRXJyb3IoKTsgfVxuICBqb2luPFQgZXh0ZW5kcyBQYXRoU3RyaW5nPihiYXNlUGF0aDogVCwgLi4ucGF0aHM6IHN0cmluZ1tdKTogVCB7IHRocm93IG1ha2VFcnJvcigpOyB9XG4gIGlzUm9vdChwYXRoOiBBYnNvbHV0ZUZzUGF0aCk6IGJvb2xlYW4geyB0aHJvdyBtYWtlRXJyb3IoKTsgfVxuICBpc1Jvb3RlZChwYXRoOiBzdHJpbmcpOiBib29sZWFuIHsgdGhyb3cgbWFrZUVycm9yKCk7IH1cbiAgcmVsYXRpdmU8VCBleHRlbmRzIFBhdGhTdHJpbmc+KGZyb206IFQsIHRvOiBUKTogUGF0aFNlZ21lbnQgeyB0aHJvdyBtYWtlRXJyb3IoKTsgfVxuICBiYXNlbmFtZShmaWxlUGF0aDogc3RyaW5nLCBleHRlbnNpb24/OiBzdHJpbmcpOiBQYXRoU2VnbWVudCB7IHRocm93IG1ha2VFcnJvcigpOyB9XG4gIHJlYWxwYXRoKGZpbGVQYXRoOiBBYnNvbHV0ZUZzUGF0aCk6IEFic29sdXRlRnNQYXRoIHsgdGhyb3cgbWFrZUVycm9yKCk7IH1cbiAgZ2V0RGVmYXVsdExpYkxvY2F0aW9uKCk6IEFic29sdXRlRnNQYXRoIHsgdGhyb3cgbWFrZUVycm9yKCk7IH1cbiAgbm9ybWFsaXplPFQgZXh0ZW5kcyBQYXRoU3RyaW5nPihwYXRoOiBUKTogVCB7IHRocm93IG1ha2VFcnJvcigpOyB9XG59XG5cbmZ1bmN0aW9uIG1ha2VFcnJvcigpIHtcbiAgcmV0dXJuIG5ldyBFcnJvcihcbiAgICAgICdGaWxlU3lzdGVtIGhhcyBub3QgYmVlbiBjb25maWd1cmVkLiBQbGVhc2UgY2FsbCBgc2V0RmlsZVN5c3RlbSgpYCBiZWZvcmUgY2FsbGluZyB0aGlzIG1ldGhvZC4nKTtcbn1cbiJdfQ==

package/src/ngtsc/{path → file_system}/src/logical.d.ts

@@ -1,3 +1,4 @@
+/// <amd-module name="@angular/compiler-cli/src/ngtsc/file_system/src/logical" />
 /**
  * @license
  * Copyright Google Inc. All Rights Reserved.
@@ -5,7 +6,6 @@
  * 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
  */
-/// <amd-module name="@angular/compiler-cli/src/ngtsc/path/src/logical" />
 import * as ts from 'typescript';
 import { AbsoluteFsPath, BrandedPath } from './types';
 /**
@@ -43,7 +43,7 @@ export declare class LogicalFileSystem {
      * Get the logical path in the project of a `ts.SourceFile`.
      *
      * This method is provided as a convenient alternative to calling
-     * `logicalPathOfFile(AbsoluteFsPath.fromSourceFile(sf))`.
+     * `logicalPathOfFile(absoluteFromSourceFile(sf))`.
      */
     logicalPathOfSf(sf: ts.SourceFile): LogicalProjectPath | null;
     /**

package/src/ngtsc/file_system/src/logical.js

@@ -0,0 +1,98 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define("@angular/compiler-cli/src/ngtsc/file_system/src/logical", ["require", "exports", "tslib", "@angular/compiler-cli/src/ngtsc/file_system/src/helpers", "@angular/compiler-cli/src/ngtsc/file_system/src/util"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var tslib_1 = require("tslib");
+    var helpers_1 = require("@angular/compiler-cli/src/ngtsc/file_system/src/helpers");
+    var util_1 = require("@angular/compiler-cli/src/ngtsc/file_system/src/util");
+    exports.LogicalProjectPath = {
+        /**
+         * Get the relative path between two `LogicalProjectPath`s.
+         *
+         * This will return a `PathSegment` which would be a valid module specifier to use in `from` when
+         * importing from `to`.
+         */
+        relativePathBetween: function (from, to) {
+            var relativePath = helpers_1.relative(helpers_1.dirname(helpers_1.resolve(from)), helpers_1.resolve(to));
+            if (!relativePath.startsWith('../')) {
+                relativePath = ('./' + relativePath);
+            }
+            return relativePath;
+        },
+    };
+    /**
+     * A utility class which can translate absolute paths to source files into logical paths in
+     * TypeScript's logical file system, based on the root directories of the project.
+     */
+    var LogicalFileSystem = /** @class */ (function () {
+        function LogicalFileSystem(rootDirs) {
+            /**
+             * A cache of file paths to project paths, because computation of these paths is slightly
+             * expensive.
+             */
+            this.cache = new Map();
+            // Make a copy and sort it by length in reverse order (longest first). This speeds up lookups,
+            // since there's no need to keep going through the array once a match is found.
+            this.rootDirs = rootDirs.concat([]).sort(function (a, b) { return b.length - a.length; });
+        }
+        /**
+         * Get the logical path in the project of a `ts.SourceFile`.
+         *
+         * This method is provided as a convenient alternative to calling
+         * `logicalPathOfFile(absoluteFromSourceFile(sf))`.
+         */
+        LogicalFileSystem.prototype.logicalPathOfSf = function (sf) {
+            return this.logicalPathOfFile(helpers_1.absoluteFrom(sf.fileName));
+        };
+        /**
+         * Get the logical path in the project of a source file.
+         *
+         * @returns A `LogicalProjectPath` to the source file, or `null` if the source file is not in any
+         * of the TS project's root directories.
+         */
+        LogicalFileSystem.prototype.logicalPathOfFile = function (physicalFile) {
+            var e_1, _a;
+            if (!this.cache.has(physicalFile)) {
+                var logicalFile = null;
+                try {
+                    for (var _b = tslib_1.__values(this.rootDirs), _c = _b.next(); !_c.done; _c = _b.next()) {
+                        var rootDir = _c.value;
+                        if (physicalFile.startsWith(rootDir)) {
+                            logicalFile = this.createLogicalProjectPath(physicalFile, rootDir);
+                            // The logical project does not include any special "node_modules" nested directories.
+                            if (logicalFile.indexOf('/node_modules/') !== -1) {
+                                logicalFile = null;
+                            }
+                            else {
+                                break;
+                            }
+                        }
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+                this.cache.set(physicalFile, logicalFile);
+            }
+            return this.cache.get(physicalFile);
+        };
+        LogicalFileSystem.prototype.createLogicalProjectPath = function (file, rootDir) {
+            var logicalPath = util_1.stripExtension(file.substr(rootDir.length));
+            return (logicalPath.startsWith('/') ? logicalPath : '/' + logicalPath);
+        };
+        return LogicalFileSystem;
+    }());
+    exports.LogicalFileSystem = LogicalFileSystem;
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9naWNhbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2NvbXBpbGVyLWNsaS9zcmMvbmd0c2MvZmlsZV9zeXN0ZW0vc3JjL2xvZ2ljYWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7O0lBU0EsbUZBQW1FO0lBRW5FLDZFQUFzQztJQVl6QixRQUFBLGtCQUFrQixHQUFHO1FBQ2hDOzs7OztXQUtHO1FBQ0gsbUJBQW1CLEVBQUUsVUFBUyxJQUF3QixFQUFFLEVBQXNCO1lBQzVFLElBQUksWUFBWSxHQUFHLGtCQUFRLENBQUMsaUJBQU8sQ0FBQyxpQkFBTyxDQUFDLElBQUksQ0FBQyxDQUFDLEVBQUUsaUJBQU8sQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDO1lBQ2pFLElBQUksQ0FBQyxZQUFZLENBQUMsVUFBVSxDQUFDLEtBQUssQ0FBQyxFQUFFO2dCQUNuQyxZQUFZLEdBQUcsQ0FBQyxJQUFJLEdBQUcsWUFBWSxDQUFnQixDQUFDO2FBQ3JEO1lBQ0QsT0FBTyxZQUEyQixDQUFDO1FBQ3JDLENBQUM7S0FDRixDQUFDO0lBRUY7OztPQUdHO0lBQ0g7UUFZRSwyQkFBWSxRQUEwQjtZQU50Qzs7O2VBR0c7WUFDSyxVQUFLLEdBQWlELElBQUksR0FBRyxFQUFFLENBQUM7WUFHdEUsOEZBQThGO1lBQzlGLCtFQUErRTtZQUMvRSxJQUFJLENBQUMsUUFBUSxHQUFHLFFBQVEsQ0FBQyxNQUFNLENBQUMsRUFBRSxDQUFDLENBQUMsSUFBSSxDQUFDLFVBQUMsQ0FBQyxFQUFFLENBQUMsSUFBSyxPQUFBLENBQUMsQ0FBQyxNQUFNLEdBQUcsQ0FBQyxDQUFDLE1BQU0sRUFBbkIsQ0FBbUIsQ0FBQyxDQUFDO1FBQzFFLENBQUM7UUFFRDs7Ozs7V0FLRztRQUNILDJDQUFlLEdBQWYsVUFBZ0IsRUFBaUI7WUFDL0IsT0FBTyxJQUFJLENBQUMsaUJBQWlCLENBQUMsc0JBQVksQ0FBQyxFQUFFLENBQUMsUUFBUSxDQUFDLENBQUMsQ0FBQztRQUMzRCxDQUFDO1FBRUQ7Ozs7O1dBS0c7UUFDSCw2Q0FBaUIsR0FBakIsVUFBa0IsWUFBNEI7O1lBQzVDLElBQUksQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxZQUFZLENBQUMsRUFBRTtnQkFDakMsSUFBSSxXQUFXLEdBQTRCLElBQUksQ0FBQzs7b0JBQ2hELEtBQXNCLElBQUEsS0FBQSxpQkFBQSxJQUFJLENBQUMsUUFBUSxDQUFBLGdCQUFBLDRCQUFFO3dCQUFoQyxJQUFNLE9BQU8sV0FBQTt3QkFDaEIsSUFBSSxZQUFZLENBQUMsVUFBVSxDQUFDLE9BQU8sQ0FBQyxFQUFFOzRCQUNwQyxXQUFXLEdBQUcsSUFBSSxDQUFDLHdCQUF3QixDQUFDLFlBQVksRUFBRSxPQUFPLENBQUMsQ0FBQzs0QkFDbkUsc0ZBQXNGOzRCQUN0RixJQUFJLFdBQVcsQ0FBQyxPQUFPLENBQUMsZ0JBQWdCLENBQUMsS0FBSyxDQUFDLENBQUMsRUFBRTtnQ0FDaEQsV0FBVyxHQUFHLElBQUksQ0FBQzs2QkFDcEI7aUNBQU07Z0NBQ0wsTUFBTTs2QkFDUDt5QkFDRjtxQkFDRjs7Ozs7Ozs7O2dCQUNELElBQUksQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLFlBQVksRUFBRSxXQUFXLENBQUMsQ0FBQzthQUMzQztZQUNELE9BQU8sSUFBSSxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsWUFBWSxDQUFHLENBQUM7UUFDeEMsQ0FBQztRQUVPLG9EQUF3QixHQUFoQyxVQUFpQyxJQUFvQixFQUFFLE9BQXVCO1lBRTVFLElBQU0sV0FBVyxHQUFHLHFCQUFjLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxPQUFPLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQztZQUNoRSxPQUFPLENBQUMsV0FBVyxDQUFDLFVBQVUsQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMsV0FBVyxDQUFDLENBQUMsQ0FBQyxHQUFHLEdBQUcsV0FBVyxDQUF1QixDQUFDO1FBQy9GLENBQUM7UUFDSCx3QkFBQztJQUFELENBQUMsQUExREQsSUEwREM7SUExRFksOENBQWlCIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IEdvb2dsZSBJbmMuIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuaW1wb3J0ICogYXMgdHMgZnJvbSAndHlwZXNjcmlwdCc7XG5cbmltcG9ydCB7YWJzb2x1dGVGcm9tLCBkaXJuYW1lLCByZWxhdGl2ZSwgcmVzb2x2ZX0gZnJvbSAnLi9oZWxwZXJzJztcbmltcG9ydCB7QWJzb2x1dGVGc1BhdGgsIEJyYW5kZWRQYXRoLCBQYXRoU2VnbWVudH0gZnJvbSAnLi90eXBlcyc7XG5pbXBvcnQge3N0cmlwRXh0ZW5zaW9ufSBmcm9tICcuL3V0aWwnO1xuXG5cblxuLyoqXG4gKiBBIHBhdGggdGhhdCdzIHJlbGF0aXZlIHRvIHRoZSBsb2dpY2FsIHJvb3Qgb2YgYSBUeXBlU2NyaXB0IHByb2plY3QgKG9uZSBvZiB0aGUgcHJvamVjdCdzXG4gKiByb290RGlycykuXG4gKlxuICogUGF0aHMgaW4gdGhlIHR5cGUgc3lzdGVtIHVzZSBQT1NJWCBmb3JtYXQuXG4gKi9cbmV4cG9ydCB0eXBlIExvZ2ljYWxQcm9qZWN0UGF0aCA9IEJyYW5kZWRQYXRoPCdMb2dpY2FsUHJvamVjdFBhdGgnPjtcblxuZXhwb3J0IGNvbnN0IExvZ2ljYWxQcm9qZWN0UGF0aCA9IHtcbiAgLyoqXG4gICAqIEdldCB0aGUgcmVsYXRpdmUgcGF0aCBiZXR3ZWVuIHR3byBgTG9naWNhbFByb2plY3RQYXRoYHMuXG4gICAqXG4gICAqIFRoaXMgd2lsbCByZXR1cm4gYSBgUGF0aFNlZ21lbnRgIHdoaWNoIHdvdWxkIGJlIGEgdmFsaWQgbW9kdWxlIHNwZWNpZmllciB0byB1c2UgaW4gYGZyb21gIHdoZW5cbiAgICogaW1wb3J0aW5nIGZyb20gYHRvYC5cbiAgICovXG4gIHJlbGF0aXZlUGF0aEJldHdlZW46IGZ1bmN0aW9uKGZyb206IExvZ2ljYWxQcm9qZWN0UGF0aCwgdG86IExvZ2ljYWxQcm9qZWN0UGF0aCk6IFBhdGhTZWdtZW50IHtcbiAgICBsZXQgcmVsYXRpdmVQYXRoID0gcmVsYXRpdmUoZGlybmFtZShyZXNvbHZlKGZyb20pKSwgcmVzb2x2ZSh0bykpO1xuICAgIGlmICghcmVsYXRpdmVQYXRoLnN0YXJ0c1dpdGgoJy4uLycpKSB7XG4gICAgICByZWxhdGl2ZVBhdGggPSAoJy4vJyArIHJlbGF0aXZlUGF0aCkgYXMgUGF0aFNlZ21lbnQ7XG4gICAgfVxuICAgIHJldHVybiByZWxhdGl2ZVBhdGggYXMgUGF0aFNlZ21lbnQ7XG4gIH0sXG59O1xuXG4vKipcbiAqIEEgdXRpbGl0eSBjbGFzcyB3aGljaCBjYW4gdHJhbnNsYXRlIGFic29sdXRlIHBhdGhzIHRvIHNvdXJjZSBmaWxlcyBpbnRvIGxvZ2ljYWwgcGF0aHMgaW5cbiAqIFR5cGVTY3JpcHQncyBsb2dpY2FsIGZpbGUgc3lzdGVtLCBiYXNlZCBvbiB0aGUgcm9vdCBkaXJlY3RvcmllcyBvZiB0aGUgcHJvamVjdC5cbiAqL1xuZXhwb3J0IGNsYXNzIExvZ2ljYWxGaWxlU3lzdGVtIHtcbiAgLyoqXG4gICAqIFRoZSByb290IGRpcmVjdG9yaWVzIG9mIHRoZSBwcm9qZWN0LCBzb3J0ZWQgd2l0aCB0aGUgbG9uZ2VzdCBwYXRoIGZpcnN0LlxuICAgKi9cbiAgcHJpdmF0ZSByb290RGlyczogQWJzb2x1dGVGc1BhdGhbXTtcblxuICAvKipcbiAgICogQSBjYWNoZSBvZiBmaWxlIHBhdGhzIHRvIHByb2plY3QgcGF0aHMsIGJlY2F1c2UgY29tcHV0YXRpb24gb2YgdGhlc2UgcGF0aHMgaXMgc2xpZ2h0bHlcbiAgICogZXhwZW5zaXZlLlxuICAgKi9cbiAgcHJpdmF0ZSBjYWNoZTogTWFwPEFic29sdXRlRnNQYXRoLCBMb2dpY2FsUHJvamVjdFBhdGh8bnVsbD4gPSBuZXcgTWFwKCk7XG5cbiAgY29uc3RydWN0b3Iocm9vdERpcnM6IEFic29sdXRlRnNQYXRoW10pIHtcbiAgICAvLyBNYWtlIGEgY29weSBhbmQgc29ydCBpdCBieSBsZW5ndGggaW4gcmV2ZXJzZSBvcmRlciAobG9uZ2VzdCBmaXJzdCkuIFRoaXMgc3BlZWRzIHVwIGxvb2t1cHMsXG4gICAgLy8gc2luY2UgdGhlcmUncyBubyBuZWVkIHRvIGtlZXAgZ29pbmcgdGhyb3VnaCB0aGUgYXJyYXkgb25jZSBhIG1hdGNoIGlzIGZvdW5kLlxuICAgIHRoaXMucm9vdERpcnMgPSByb290RGlycy5jb25jYXQoW10pLnNvcnQoKGEsIGIpID0+IGIubGVuZ3RoIC0gYS5sZW5ndGgpO1xuICB9XG5cbiAgLyoqXG4gICAqIEdldCB0aGUgbG9naWNhbCBwYXRoIGluIHRoZSBwcm9qZWN0IG9mIGEgYHRzLlNvdXJjZUZpbGVgLlxuICAgKlxuICAgKiBUaGlzIG1ldGhvZCBpcyBwcm92aWRlZCBhcyBhIGNvbnZlbmllbnQgYWx0ZXJuYXRpdmUgdG8gY2FsbGluZ1xuICAgKiBgbG9naWNhbFBhdGhPZkZpbGUoYWJzb2x1dGVGcm9tU291cmNlRmlsZShzZikpYC5cbiAgICovXG4gIGxvZ2ljYWxQYXRoT2ZTZihzZjogdHMuU291cmNlRmlsZSk6IExvZ2ljYWxQcm9qZWN0UGF0aHxudWxsIHtcbiAgICByZXR1cm4gdGhpcy5sb2dpY2FsUGF0aE9mRmlsZShhYnNvbHV0ZUZyb20oc2YuZmlsZU5hbWUpKTtcbiAgfVxuXG4gIC8qKlxuICAgKiBHZXQgdGhlIGxvZ2ljYWwgcGF0aCBpbiB0aGUgcHJvamVjdCBvZiBhIHNvdXJjZSBmaWxlLlxuICAgKlxuICAgKiBAcmV0dXJucyBBIGBMb2dpY2FsUHJvamVjdFBhdGhgIHRvIHRoZSBzb3VyY2UgZmlsZSwgb3IgYG51bGxgIGlmIHRoZSBzb3VyY2UgZmlsZSBpcyBub3QgaW4gYW55XG4gICAqIG9mIHRoZSBUUyBwcm9qZWN0J3Mgcm9vdCBkaXJlY3Rvcmllcy5cbiAgICovXG4gIGxvZ2ljYWxQYXRoT2ZGaWxlKHBoeXNpY2FsRmlsZTogQWJzb2x1dGVGc1BhdGgpOiBMb2dpY2FsUHJvamVjdFBhdGh8bnVsbCB7XG4gICAgaWYgKCF0aGlzLmNhY2hlLmhhcyhwaHlzaWNhbEZpbGUpKSB7XG4gICAgICBsZXQgbG9naWNhbEZpbGU6IExvZ2ljYWxQcm9qZWN0UGF0aHxudWxsID0gbnVsbDtcbiAgICAgIGZvciAoY29uc3Qgcm9vdERpciBvZiB0aGlzLnJvb3REaXJzKSB7XG4gICAgICAgIGlmIChwaHlzaWNhbEZpbGUuc3RhcnRzV2l0aChyb290RGlyKSkge1xuICAgICAgICAgIGxvZ2ljYWxGaWxlID0gdGhpcy5jcmVhdGVMb2dpY2FsUHJvamVjdFBhdGgocGh5c2ljYWxGaWxlLCByb290RGlyKTtcbiAgICAgICAgICAvLyBUaGUgbG9naWNhbCBwcm9qZWN0IGRvZXMgbm90IGluY2x1ZGUgYW55IHNwZWNpYWwgXCJub2RlX21vZHVsZXNcIiBuZXN0ZWQgZGlyZWN0b3JpZXMuXG4gICAgICAgICAgaWYgKGxvZ2ljYWxGaWxlLmluZGV4T2YoJy9ub2RlX21vZHVsZXMvJykgIT09IC0xKSB7XG4gICAgICAgICAgICBsb2dpY2FsRmlsZSA9IG51bGw7XG4gICAgICAgICAgfSBlbHNlIHtcbiAgICAgICAgICAgIGJyZWFrO1xuICAgICAgICAgIH1cbiAgICAgICAgfVxuICAgICAgfVxuICAgICAgdGhpcy5jYWNoZS5zZXQocGh5c2ljYWxGaWxlLCBsb2dpY2FsRmlsZSk7XG4gICAgfVxuICAgIHJldHVybiB0aGlzLmNhY2hlLmdldChwaHlzaWNhbEZpbGUpICE7XG4gIH1cblxuICBwcml2YXRlIGNyZWF0ZUxvZ2ljYWxQcm9qZWN0UGF0aChmaWxlOiBBYnNvbHV0ZUZzUGF0aCwgcm9vdERpcjogQWJzb2x1dGVGc1BhdGgpOlxuICAgICAgTG9naWNhbFByb2plY3RQYXRoIHtcbiAgICBjb25zdCBsb2dpY2FsUGF0aCA9IHN0cmlwRXh0ZW5zaW9uKGZpbGUuc3Vic3RyKHJvb3REaXIubGVuZ3RoKSk7XG4gICAgcmV0dXJuIChsb2dpY2FsUGF0aC5zdGFydHNXaXRoKCcvJykgPyBsb2dpY2FsUGF0aCA6ICcvJyArIGxvZ2ljYWxQYXRoKSBhcyBMb2dpY2FsUHJvamVjdFBhdGg7XG4gIH1cbn1cbiJdfQ==

package/src/ngtsc/file_system/src/node_js_file_system.d.ts

@@ -0,0 +1,32 @@
+/// <amd-module name="@angular/compiler-cli/src/ngtsc/file_system/src/node_js_file_system" />
+import { AbsoluteFsPath, FileStats, FileSystem, PathSegment, PathString } from './types';
+/**
+ * A wrapper around the Node.js file-system (i.e the `fs` package).
+ */
+export declare class NodeJSFileSystem implements FileSystem {
+    private _caseSensitive;
+    exists(path: AbsoluteFsPath): boolean;
+    readFile(path: AbsoluteFsPath): string;
+    writeFile(path: AbsoluteFsPath, data: string): void;
+    symlink(target: AbsoluteFsPath, path: AbsoluteFsPath): void;
+    readdir(path: AbsoluteFsPath): PathSegment[];
+    lstat(path: AbsoluteFsPath): FileStats;
+    stat(path: AbsoluteFsPath): FileStats;
+    pwd(): AbsoluteFsPath;
+    copyFile(from: AbsoluteFsPath, to: AbsoluteFsPath): void;
+    moveFile(from: AbsoluteFsPath, to: AbsoluteFsPath): void;
+    mkdir(path: AbsoluteFsPath): void;
+    ensureDir(path: AbsoluteFsPath): void;
+    isCaseSensitive(): boolean;
+    resolve(...paths: string[]): AbsoluteFsPath;
+    dirname<T extends string>(file: T): T;
+    join<T extends string>(basePath: T, ...paths: string[]): T;
+    isRoot(path: AbsoluteFsPath): boolean;
+    isRooted(path: string): boolean;
+    relative<T extends PathString>(from: T, to: T): PathSegment;
+    basename(filePath: string, extension?: string): PathSegment;
+    extname(path: AbsoluteFsPath | PathSegment): string;
+    realpath(path: AbsoluteFsPath): AbsoluteFsPath;
+    getDefaultLibLocation(): AbsoluteFsPath;
+    normalize<T extends string>(path: T): T;
+}

package/src/ngtsc/file_system/src/node_js_file_system.js

@@ -0,0 +1,102 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define("@angular/compiler-cli/src/ngtsc/file_system/src/node_js_file_system", ["require", "exports", "tslib", "fs", "path", "@angular/compiler-cli/src/ngtsc/file_system/src/helpers"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var tslib_1 = require("tslib");
+    /**
+     * @license
+     * Copyright Google Inc. 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
+     */
+    /// <reference types="node" />
+    var fs = require("fs");
+    var p = require("path");
+    var helpers_1 = require("@angular/compiler-cli/src/ngtsc/file_system/src/helpers");
+    /**
+     * A wrapper around the Node.js file-system (i.e the `fs` package).
+     */
+    var NodeJSFileSystem = /** @class */ (function () {
+        function NodeJSFileSystem() {
+            this._caseSensitive = undefined;
+        }
+        NodeJSFileSystem.prototype.exists = function (path) { return fs.existsSync(path); };
+        NodeJSFileSystem.prototype.readFile = function (path) { return fs.readFileSync(path, 'utf8'); };
+        NodeJSFileSystem.prototype.writeFile = function (path, data) {
+            return fs.writeFileSync(path, data, 'utf8');
+        };
+        NodeJSFileSystem.prototype.symlink = function (target, path) { fs.symlinkSync(target, path); };
+        NodeJSFileSystem.prototype.readdir = function (path) { return fs.readdirSync(path); };
+        NodeJSFileSystem.prototype.lstat = function (path) { return fs.lstatSync(path); };
+        NodeJSFileSystem.prototype.stat = function (path) { return fs.statSync(path); };
+        NodeJSFileSystem.prototype.pwd = function () { return this.normalize(process.cwd()); };
+        NodeJSFileSystem.prototype.copyFile = function (from, to) { fs.copyFileSync(from, to); };
+        NodeJSFileSystem.prototype.moveFile = function (from, to) { fs.renameSync(from, to); };
+        NodeJSFileSystem.prototype.mkdir = function (path) { fs.mkdirSync(path); };
+        NodeJSFileSystem.prototype.ensureDir = function (path) {
+            var parents = [];
+            while (!this.isRoot(path) && !this.exists(path)) {
+                parents.push(path);
+                path = this.dirname(path);
+            }
+            while (parents.length) {
+                this.mkdir(parents.pop());
+            }
+        };
+        NodeJSFileSystem.prototype.isCaseSensitive = function () {
+            if (this._caseSensitive === undefined) {
+                this._caseSensitive = this.exists(togglePathCase(__filename));
+            }
+            return this._caseSensitive;
+        };
+        NodeJSFileSystem.prototype.resolve = function () {
+            var paths = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                paths[_i] = arguments[_i];
+            }
+            return this.normalize(p.resolve.apply(p, tslib_1.__spread(paths)));
+        };
+        NodeJSFileSystem.prototype.dirname = function (file) { return this.normalize(p.dirname(file)); };
+        NodeJSFileSystem.prototype.join = function (basePath) {
+            var paths = [];
+            for (var _i = 1; _i < arguments.length; _i++) {
+                paths[_i - 1] = arguments[_i];
+            }
+            return this.normalize(p.join.apply(p, tslib_1.__spread([basePath], paths)));
+        };
+        NodeJSFileSystem.prototype.isRoot = function (path) { return this.dirname(path) === this.normalize(path); };
+        NodeJSFileSystem.prototype.isRooted = function (path) { return p.isAbsolute(path); };
+        NodeJSFileSystem.prototype.relative = function (from, to) {
+            return helpers_1.relativeFrom(this.normalize(p.relative(from, to)));
+        };
+        NodeJSFileSystem.prototype.basename = function (filePath, extension) {
+            return p.basename(filePath, extension);
+        };
+        NodeJSFileSystem.prototype.extname = function (path) { return p.extname(path); };
+        NodeJSFileSystem.prototype.realpath = function (path) { return this.resolve(fs.realpathSync(path)); };
+        NodeJSFileSystem.prototype.getDefaultLibLocation = function () {
+            return this.resolve(require.resolve('typescript'), '..');
+        };
+        NodeJSFileSystem.prototype.normalize = function (path) {
+            // Convert backslashes to forward slashes
+            return path.replace(/\\/g, '/');
+        };
+        return NodeJSFileSystem;
+    }());
+    exports.NodeJSFileSystem = NodeJSFileSystem;
+    /**
+     * Toggle the case of each character in a file path.
+     */
+    function togglePathCase(str) {
+        return helpers_1.absoluteFrom(str.replace(/\w/g, function (ch) { return ch.toUpperCase() === ch ? ch.toLowerCase() : ch.toUpperCase(); }));
+    }
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"node_js_file_system.js","sourceRoot":"","sources":["../../../../../../../../../packages/compiler-cli/src/ngtsc/file_system/src/node_js_file_system.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 */\n/// <reference types=\"node\" />\nimport * as fs from 'fs';\nimport * as p from 'path';\nimport {absoluteFrom, relativeFrom} from './helpers';\nimport {AbsoluteFsPath, FileStats, FileSystem, PathSegment, PathString} from './types';\n\n/**\n * A wrapper around the Node.js file-system (i.e the `fs` package).\n */\nexport class NodeJSFileSystem implements FileSystem {\n  private _caseSensitive: boolean|undefined = undefined;\n  exists(path: AbsoluteFsPath): boolean { return fs.existsSync(path); }\n  readFile(path: AbsoluteFsPath): string { return fs.readFileSync(path, 'utf8'); }\n  writeFile(path: AbsoluteFsPath, data: string): void {\n    return fs.writeFileSync(path, data, 'utf8');\n  }\n  symlink(target: AbsoluteFsPath, path: AbsoluteFsPath): void { fs.symlinkSync(target, path); }\n  readdir(path: AbsoluteFsPath): PathSegment[] { return fs.readdirSync(path) as PathSegment[]; }\n  lstat(path: AbsoluteFsPath): FileStats { return fs.lstatSync(path); }\n  stat(path: AbsoluteFsPath): FileStats { return fs.statSync(path); }\n  pwd(): AbsoluteFsPath { return this.normalize(process.cwd()) as AbsoluteFsPath; }\n  copyFile(from: AbsoluteFsPath, to: AbsoluteFsPath): void { fs.copyFileSync(from, to); }\n  moveFile(from: AbsoluteFsPath, to: AbsoluteFsPath): void { fs.renameSync(from, to); }\n  mkdir(path: AbsoluteFsPath): void { fs.mkdirSync(path); }\n  ensureDir(path: AbsoluteFsPath): void {\n    const parents: AbsoluteFsPath[] = [];\n    while (!this.isRoot(path) && !this.exists(path)) {\n      parents.push(path);\n      path = this.dirname(path);\n    }\n    while (parents.length) {\n      this.mkdir(parents.pop() !);\n    }\n  }\n  isCaseSensitive(): boolean {\n    if (this._caseSensitive === undefined) {\n      this._caseSensitive = this.exists(togglePathCase(__filename));\n    }\n    return this._caseSensitive;\n  }\n  resolve(...paths: string[]): AbsoluteFsPath {\n    return this.normalize(p.resolve(...paths)) as AbsoluteFsPath;\n  }\n\n  dirname<T extends string>(file: T): T { return this.normalize(p.dirname(file)) as T; }\n  join<T extends string>(basePath: T, ...paths: string[]): T {\n    return this.normalize(p.join(basePath, ...paths)) as T;\n  }\n  isRoot(path: AbsoluteFsPath): boolean { return this.dirname(path) === this.normalize(path); }\n  isRooted(path: string): boolean { return p.isAbsolute(path); }\n  relative<T extends PathString>(from: T, to: T): PathSegment {\n    return relativeFrom(this.normalize(p.relative(from, to)));\n  }\n  basename(filePath: string, extension?: string): PathSegment {\n    return p.basename(filePath, extension) as PathSegment;\n  }\n  extname(path: AbsoluteFsPath|PathSegment): string { return p.extname(path); }\n  realpath(path: AbsoluteFsPath): AbsoluteFsPath { return this.resolve(fs.realpathSync(path)); }\n  getDefaultLibLocation(): AbsoluteFsPath {\n    return this.resolve(require.resolve('typescript'), '..');\n  }\n  normalize<T extends string>(path: T): T {\n    // Convert backslashes to forward slashes\n    return path.replace(/\\\\/g, '/') as T;\n  }\n}\n\n/**\n * Toggle the case of each character in a file path.\n */\nfunction togglePathCase(str: string): AbsoluteFsPath {\n  return absoluteFrom(\n      str.replace(/\\w/g, ch => ch.toUpperCase() === ch ? ch.toLowerCase() : ch.toUpperCase()));\n}\n"]}

package/src/ngtsc/file_system/src/types.d.ts

@@ -0,0 +1,69 @@
+/**
+ * @license
+ * Copyright Google Inc. 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
+ */
+/// <amd-module name="@angular/compiler-cli/src/ngtsc/file_system/src/types" />
+/**
+ * A `string` representing a specific type of path, with a particular brand `B`.
+ *
+ * A `string` is not assignable to a `BrandedPath`, but a `BrandedPath` is assignable to a `string`.
+ * Two `BrandedPath`s with different brands are not mutually assignable.
+ */
+export declare type BrandedPath<B extends string> = string & {
+    _brand: B;
+};
+/**
+ * A fully qualified path in the file system, in POSIX form.
+ */
+export declare type AbsoluteFsPath = BrandedPath<'AbsoluteFsPath'>;
+/**
+ * A path that's relative to another (unspecified) root.
+ *
+ * This does not necessarily have to refer to a physical file.
+ */
+export declare type PathSegment = BrandedPath<'PathSegment'>;
+/**
+ * A basic interface to abstract the underlying file-system.
+ *
+ * This makes it easier to provide mock file-systems in unit tests,
+ * but also to create clever file-systems that have features such as caching.
+ */
+export interface FileSystem {
+    exists(path: AbsoluteFsPath): boolean;
+    readFile(path: AbsoluteFsPath): string;
+    writeFile(path: AbsoluteFsPath, data: string): void;
+    symlink(target: AbsoluteFsPath, path: AbsoluteFsPath): void;
+    readdir(path: AbsoluteFsPath): PathSegment[];
+    lstat(path: AbsoluteFsPath): FileStats;
+    stat(path: AbsoluteFsPath): FileStats;
+    pwd(): AbsoluteFsPath;
+    extname(path: AbsoluteFsPath | PathSegment): string;
+    copyFile(from: AbsoluteFsPath, to: AbsoluteFsPath): void;
+    moveFile(from: AbsoluteFsPath, to: AbsoluteFsPath): void;
+    mkdir(path: AbsoluteFsPath): void;
+    ensureDir(path: AbsoluteFsPath): void;
+    isCaseSensitive(): boolean;
+    isRoot(path: AbsoluteFsPath): boolean;
+    isRooted(path: string): boolean;
+    resolve(...paths: string[]): AbsoluteFsPath;
+    dirname<T extends PathString>(file: T): T;
+    join<T extends PathString>(basePath: T, ...paths: string[]): T;
+    relative<T extends PathString>(from: T, to: T): PathSegment;
+    basename(filePath: string, extension?: string): PathSegment;
+    realpath(filePath: AbsoluteFsPath): AbsoluteFsPath;
+    getDefaultLibLocation(): AbsoluteFsPath;
+    normalize<T extends PathString>(path: T): T;
+}
+export declare type PathString = string | AbsoluteFsPath | PathSegment;
+/**
+ * Information about an object in the FileSystem.
+ * This is analogous to the `fs.Stats` class in Node.js.
+ */
+export interface FileStats {
+    isFile(): boolean;
+    isDirectory(): boolean;
+    isSymbolicLink(): boolean;
+}

package/src/ngtsc/file_system/src/types.js

@@ -0,0 +1,20 @@
+/**
+ * @license
+ * Copyright Google Inc. 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
+ */
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define("@angular/compiler-cli/src/ngtsc/file_system/src/types", ["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/src/ngtsc/{path → file_system}/src/util.d.ts

@@ -1,3 +1,4 @@
+/// <amd-module name="@angular/compiler-cli/src/ngtsc/file_system/src/util" />
 /**
  * @license
  * Copyright Google Inc. All Rights Reserved.
@@ -5,7 +6,8 @@
  * 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
  */
-/// <amd-module name="@angular/compiler-cli/src/ngtsc/path/src/util" />
+import * as ts from 'typescript';
+import { AbsoluteFsPath } from './types';
 /**
  * Convert Windows-style separators to POSIX separators.
  */
@@ -14,7 +16,4 @@ export declare function normalizeSeparators(path: string): string;
  * Remove a .ts, .d.ts, or .js extension from a file name.
  */
 export declare function stripExtension(path: string): string;
-/**
- * Returns true if the normalized path is an absolute path.
- */
-export declare function isAbsolutePath(path: string): boolean;
+export declare function getSourceFileOrError(program: ts.Program, fileName: AbsoluteFsPath): ts.SourceFile;