@utrecht/web-component-library-stencil 1.0.0-alpha.16 → 1.0.0-alpha.160

package/dist/collection/node_modules/@storybook/core-common/node_modules/fork-ts-checker-webpack-plugin/lib/typescript-reporter/file-system/RealFileSystem.js

@@ -0,0 +1,179 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
+const fs_extra_1 = __importDefault(require("fs-extra"));
+/**
+ * It's an implementation of the FileSystem interface which reads and writes directly to the real file system.
+ *
+ * @param caseSensitive
+ */
+function createRealFileSystem(caseSensitive = false) {
+    // read cache
+    const existsCache = new Map();
+    const readStatsCache = new Map();
+    const readFileCache = new Map();
+    const readDirCache = new Map();
+    const realPathCache = new Map();
+    function normalizePath(path) {
+        return caseSensitive ? path_1.normalize(path) : path_1.normalize(path).toLowerCase();
+    }
+    // read methods
+    function exists(path) {
+        const normalizedPath = normalizePath(path);
+        if (!existsCache.has(normalizedPath)) {
+            existsCache.set(normalizedPath, fs_extra_1.default.existsSync(normalizedPath));
+        }
+        return !!existsCache.get(normalizedPath);
+    }
+    function readStats(path) {
+        const normalizedPath = normalizePath(path);
+        if (!readStatsCache.has(normalizedPath)) {
+            if (exists(normalizedPath)) {
+                readStatsCache.set(normalizedPath, fs_extra_1.default.statSync(normalizedPath));
+            }
+        }
+        return readStatsCache.get(normalizedPath);
+    }
+    function readFile(path, encoding) {
+        const normalizedPath = normalizePath(path);
+        if (!readFileCache.has(normalizedPath)) {
+            const stats = readStats(normalizedPath);
+            if (stats && stats.isFile()) {
+                readFileCache.set(normalizedPath, fs_extra_1.default.readFileSync(normalizedPath, { encoding: encoding }).toString());
+            }
+            else {
+                readFileCache.set(normalizedPath, undefined);
+            }
+        }
+        return readFileCache.get(normalizedPath);
+    }
+    function readDir(path) {
+        const normalizedPath = normalizePath(path);
+        if (!readDirCache.has(normalizedPath)) {
+            const stats = readStats(normalizedPath);
+            if (stats && stats.isDirectory()) {
+                readDirCache.set(normalizedPath, fs_extra_1.default.readdirSync(normalizedPath, { withFileTypes: true }));
+            }
+            else {
+                readDirCache.set(normalizedPath, []);
+            }
+        }
+        return readDirCache.get(normalizedPath) || [];
+    }
+    function getRealPath(path) {
+        const normalizedPath = normalizePath(path);
+        if (!realPathCache.has(normalizedPath)) {
+            let base = normalizedPath;
+            let nested = '';
+            while (base !== path_1.dirname(base)) {
+                if (exists(base)) {
+                    realPathCache.set(normalizedPath, normalizePath(path_1.join(fs_extra_1.default.realpathSync(base), nested)));
+                    break;
+                }
+                nested = path_1.join(path_1.basename(base), nested);
+                base = path_1.dirname(base);
+            }
+        }
+        return realPathCache.get(normalizedPath) || normalizedPath;
+    }
+    function createDir(path) {
+        const normalizedPath = normalizePath(path);
+        fs_extra_1.default.mkdirSync(normalizedPath, { recursive: true });
+        // update cache
+        existsCache.set(normalizedPath, true);
+        if (readDirCache.has(path_1.dirname(normalizedPath))) {
+            readDirCache.delete(path_1.dirname(normalizedPath));
+        }
+        if (readStatsCache.has(normalizedPath)) {
+            readStatsCache.delete(normalizedPath);
+        }
+    }
+    function writeFile(path, data) {
+        const normalizedPath = normalizePath(path);
+        if (!exists(path_1.dirname(normalizedPath))) {
+            createDir(path_1.dirname(normalizedPath));
+        }
+        fs_extra_1.default.writeFileSync(normalizedPath, data);
+        // update cache
+        existsCache.set(normalizedPath, true);
+        if (readDirCache.has(path_1.dirname(normalizedPath))) {
+            readDirCache.delete(path_1.dirname(normalizedPath));
+        }
+        if (readStatsCache.has(normalizedPath)) {
+            readStatsCache.delete(normalizedPath);
+        }
+        if (readFileCache.has(normalizedPath)) {
+            readFileCache.delete(normalizedPath);
+        }
+    }
+    function deleteFile(path) {
+        if (exists(path)) {
+            const normalizedPath = normalizePath(path);
+            fs_extra_1.default.unlinkSync(normalizedPath);
+            // update cache
+            existsCache.set(normalizedPath, false);
+            if (readDirCache.has(path_1.dirname(normalizedPath))) {
+                readDirCache.delete(path_1.dirname(normalizedPath));
+            }
+            if (readStatsCache.has(normalizedPath)) {
+                readStatsCache.delete(normalizedPath);
+            }
+            if (readFileCache.has(normalizedPath)) {
+                readFileCache.delete(normalizedPath);
+            }
+        }
+    }
+    function updateTimes(path, atime, mtime) {
+        if (exists(path)) {
+            const normalizedPath = normalizePath(path);
+            fs_extra_1.default.utimesSync(normalizePath(path), atime, mtime);
+            // update cache
+            if (readStatsCache.has(normalizedPath)) {
+                readStatsCache.delete(normalizedPath);
+            }
+        }
+    }
+    return {
+        exists(path) {
+            return exists(getRealPath(path));
+        },
+        readFile(path, encoding) {
+            return readFile(getRealPath(path), encoding);
+        },
+        readDir(path) {
+            return readDir(getRealPath(path));
+        },
+        readStats(path) {
+            return readStats(getRealPath(path));
+        },
+        realPath(path) {
+            return getRealPath(path);
+        },
+        normalizePath(path) {
+            return normalizePath(path);
+        },
+        writeFile(path, data) {
+            writeFile(getRealPath(path), data);
+        },
+        deleteFile(path) {
+            deleteFile(getRealPath(path));
+        },
+        createDir(path) {
+            createDir(getRealPath(path));
+        },
+        updateTimes(path, atime, mtime) {
+            updateTimes(getRealPath(path), atime, mtime);
+        },
+        clearCache() {
+            existsCache.clear();
+            readStatsCache.clear();
+            readFileCache.clear();
+            readDirCache.clear();
+            realPathCache.clear();
+        },
+    };
+}
+exports.createRealFileSystem = createRealFileSystem;

package/dist/collection/node_modules/@storybook/core-common/node_modules/fork-ts-checker-webpack-plugin/lib/typescript-reporter/issue/TypeScriptIssueFactory.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const os = __importStar(require("os"));
+const issue_1 = require("../../issue");
+function createIssueFromTsDiagnostic(typescript, diagnostic) {
+    let file;
+    let location;
+    if (diagnostic.file) {
+        file = diagnostic.file.fileName;
+        if (diagnostic.start && diagnostic.length) {
+            const { line: startLine, character: startCharacter, } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
+            const { line: endLine, character: endCharacter, } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start + diagnostic.length);
+            location = {
+                start: {
+                    line: startLine + 1,
+                    column: startCharacter + 1,
+                },
+                end: {
+                    line: endLine + 1,
+                    column: endCharacter + 1,
+                },
+            };
+        }
+    }
+    return {
+        origin: 'typescript',
+        code: 'TS' + String(diagnostic.code),
+        // we don't handle Suggestion and Message diagnostics
+        severity: diagnostic.category === 0 ? 'warning' : 'error',
+        message: typescript.flattenDiagnosticMessageText(diagnostic.messageText, os.EOL),
+        file,
+        location,
+    };
+}
+function createIssuesFromTsDiagnostics(typescript, diagnostics) {
+    return issue_1.deduplicateAndSortIssues(diagnostics.map((diagnostic) => createIssueFromTsDiagnostic(typescript, diagnostic)));
+}
+exports.createIssuesFromTsDiagnostics = createIssuesFromTsDiagnostics;

package/dist/collection/node_modules/@storybook/core-common/node_modules/fork-ts-checker-webpack-plugin/lib/typescript-reporter/profile/TypeScriptPerformance.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function getTypeScriptPerformance(typescript) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return typescript.performance;
+}
+function connectTypeScriptPerformance(typescript, performance) {
+    const typeScriptPerformance = getTypeScriptPerformance(typescript);
+    if (typeScriptPerformance) {
+        const { mark, measure } = typeScriptPerformance;
+        const { enable, disable } = performance;
+        typeScriptPerformance.mark = (name) => {
+            mark(name);
+            performance.mark(name);
+        };
+        typeScriptPerformance.measure = (name, startMark, endMark) => {
+            measure(name, startMark, endMark);
+            performance.measure(name, startMark, endMark);
+        };
+        return Object.assign(Object.assign({}, performance), { enable() {
+                enable();
+                typeScriptPerformance.enable();
+            },
+            disable() {
+                disable();
+                typeScriptPerformance.disable();
+            } });
+    }
+    else {
+        return performance;
+    }
+}
+exports.connectTypeScriptPerformance = connectTypeScriptPerformance;

package/dist/collection/node_modules/@storybook/core-common/node_modules/fork-ts-checker-webpack-plugin/lib/typescript-reporter/reporter/ControlledTypeScriptSystem.js

@@ -0,0 +1,231 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
+const PassiveFileSystem_1 = require("../file-system/PassiveFileSystem");
+const forwardSlash_1 = __importDefault(require("../../utils/path/forwardSlash"));
+const RealFileSystem_1 = require("../file-system/RealFileSystem");
+const MemFileSystem_1 = require("../file-system/MemFileSystem");
+function createControlledTypeScriptSystem(typescript, mode = 'readonly') {
+    let artifacts = {
+        files: [],
+        dirs: [],
+        excluded: [],
+        extensions: [],
+    };
+    let isInitialRun = true;
+    // watchers
+    const fileWatcherCallbacksMap = new Map();
+    const directoryWatcherCallbacksMap = new Map();
+    const recursiveDirectoryWatcherCallbacksMap = new Map();
+    const deletedFiles = new Map();
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const timeoutCallbacks = new Set();
+    // always use case-sensitive as normalization to lower-case can be a problem for some
+    // third-party libraries, like fsevents
+    const caseSensitive = true;
+    const realFileSystem = RealFileSystem_1.createRealFileSystem(caseSensitive);
+    const memFileSystem = MemFileSystem_1.createMemFileSystem(realFileSystem);
+    const passiveFileSystem = PassiveFileSystem_1.createPassiveFileSystem(memFileSystem, realFileSystem);
+    // based on the ts.ignorePaths
+    const ignoredPaths = ['/node_modules/.', '/.git', '/.#'];
+    function createWatcher(watchersMap, path, callback) {
+        const normalizedPath = realFileSystem.normalizePath(path);
+        const watchers = watchersMap.get(normalizedPath) || [];
+        const nextWatchers = [...watchers, callback];
+        watchersMap.set(normalizedPath, nextWatchers);
+        return {
+            close: () => {
+                const watchers = watchersMap.get(normalizedPath) || [];
+                const nextWatchers = watchers.filter((watcher) => watcher !== callback);
+                if (nextWatchers.length > 0) {
+                    watchersMap.set(normalizedPath, nextWatchers);
+                }
+                else {
+                    watchersMap.delete(normalizedPath);
+                }
+            },
+        };
+    }
+    function invokeFileWatchers(path, event) {
+        const normalizedPath = realFileSystem.normalizePath(path);
+        if (normalizedPath.endsWith('.js')) {
+            // trigger relevant .d.ts file watcher - handles the case, when we have webpack watcher
+            // that points to a symlinked package
+            invokeFileWatchers(normalizedPath.slice(0, -3) + '.d.ts', event);
+        }
+        const fileWatcherCallbacks = fileWatcherCallbacksMap.get(normalizedPath);
+        if (fileWatcherCallbacks) {
+            // typescript expects normalized paths with posix forward slash
+            fileWatcherCallbacks.forEach((fileWatcherCallback) => fileWatcherCallback(forwardSlash_1.default(normalizedPath), event));
+        }
+    }
+    function invokeDirectoryWatchers(path) {
+        const normalizedPath = realFileSystem.normalizePath(path);
+        const directory = path_1.dirname(normalizedPath);
+        if (ignoredPaths.some((ignoredPath) => forwardSlash_1.default(normalizedPath).includes(ignoredPath))) {
+            return;
+        }
+        const directoryWatcherCallbacks = directoryWatcherCallbacksMap.get(directory);
+        if (directoryWatcherCallbacks) {
+            directoryWatcherCallbacks.forEach((directoryWatcherCallback) => directoryWatcherCallback(forwardSlash_1.default(normalizedPath)));
+        }
+        recursiveDirectoryWatcherCallbacksMap.forEach((recursiveDirectoryWatcherCallbacks, watchedDirectory) => {
+            if (watchedDirectory === directory ||
+                (directory.startsWith(watchedDirectory) &&
+                    forwardSlash_1.default(directory)[watchedDirectory.length] === '/')) {
+                recursiveDirectoryWatcherCallbacks.forEach((recursiveDirectoryWatcherCallback) => recursiveDirectoryWatcherCallback(forwardSlash_1.default(normalizedPath)));
+            }
+        });
+    }
+    function isArtifact(path) {
+        return ((artifacts.dirs.some((dir) => path.includes(dir)) ||
+            artifacts.files.some((file) => path === file)) &&
+            artifacts.extensions.some((extension) => path.endsWith(extension)));
+    }
+    function getReadFileSystem(path) {
+        if ((mode === 'readonly' || mode === 'write-tsbuildinfo') && isArtifact(path)) {
+            if (isInitialRun && !memFileSystem.exists(path) && passiveFileSystem.exists(path)) {
+                // copy file to memory on initial run
+                const stats = passiveFileSystem.readStats(path);
+                if (stats === null || stats === void 0 ? void 0 : stats.isFile()) {
+                    const content = passiveFileSystem.readFile(path);
+                    if (content) {
+                        memFileSystem.writeFile(path, content);
+                        memFileSystem.updateTimes(path, stats.atime, stats.mtime);
+                    }
+                }
+            }
+            return memFileSystem;
+        }
+        return passiveFileSystem;
+    }
+    function getWriteFileSystem(path) {
+        if (mode === 'write-references' ||
+            (mode === 'write-tsbuildinfo' && path.endsWith('.tsbuildinfo')) ||
+            (mode === 'write-dts' &&
+                ['.tsbuildinfo', '.d.ts', '.d.ts.map'].some((prefix) => path.endsWith(prefix)))) {
+            return realFileSystem;
+        }
+        return passiveFileSystem;
+    }
+    const controlledSystem = Object.assign(Object.assign({}, typescript.sys), { useCaseSensitiveFileNames: caseSensitive, realpath(path) {
+            return getReadFileSystem(path).realPath(path);
+        },
+        fileExists(path) {
+            const stats = getReadFileSystem(path).readStats(path);
+            return !!stats && stats.isFile();
+        },
+        readFile(path, encoding) {
+            return getReadFileSystem(path).readFile(path, encoding);
+        },
+        getFileSize(path) {
+            const stats = getReadFileSystem(path).readStats(path);
+            return stats ? stats.size : 0;
+        },
+        writeFile(path, data) {
+            getWriteFileSystem(path).writeFile(path, data);
+            controlledSystem.invokeFileChanged(path);
+        },
+        deleteFile(path) {
+            getWriteFileSystem(path).deleteFile(path);
+            controlledSystem.invokeFileDeleted(path);
+        },
+        directoryExists(path) {
+            var _a;
+            return Boolean((_a = getReadFileSystem(path).readStats(path)) === null || _a === void 0 ? void 0 : _a.isDirectory());
+        },
+        createDirectory(path) {
+            getWriteFileSystem(path).createDir(path);
+            invokeDirectoryWatchers(path);
+        },
+        getDirectories(path) {
+            const dirents = getReadFileSystem(path).readDir(path);
+            return dirents
+                .filter((dirent) => dirent.isDirectory() ||
+                (dirent.isSymbolicLink() && controlledSystem.directoryExists(path_1.join(path, dirent.name))))
+                .map((dirent) => dirent.name);
+        },
+        getModifiedTime(path) {
+            const stats = getReadFileSystem(path).readStats(path);
+            if (stats) {
+                return stats.mtime;
+            }
+        },
+        setModifiedTime(path, date) {
+            getWriteFileSystem(path).updateTimes(path, date, date);
+            invokeDirectoryWatchers(path);
+            invokeFileWatchers(path, typescript.FileWatcherEventKind.Changed);
+        },
+        watchFile(path, callback) {
+            return createWatcher(fileWatcherCallbacksMap, path, callback);
+        },
+        watchDirectory(path, callback, recursive = false) {
+            return createWatcher(recursive ? recursiveDirectoryWatcherCallbacksMap : directoryWatcherCallbacksMap, path, callback);
+        }, 
+        // use immediate instead of timeout to avoid waiting 250ms for batching files changes
+        setTimeout: (callback, timeout, ...args) => {
+            const timeoutId = setImmediate(() => {
+                callback(...args);
+                timeoutCallbacks.delete(timeoutId);
+            });
+            timeoutCallbacks.add(timeoutId);
+            return timeoutId;
+        }, clearTimeout: (timeoutId) => {
+            clearImmediate(timeoutId);
+            timeoutCallbacks.delete(timeoutId);
+        }, waitForQueued() {
+            return __awaiter(this, void 0, void 0, function* () {
+                while (timeoutCallbacks.size > 0) {
+                    yield new Promise((resolve) => setImmediate(resolve));
+                }
+                isInitialRun = false;
+            });
+        },
+        invokeFileCreated(path) {
+            const normalizedPath = realFileSystem.normalizePath(path);
+            invokeFileWatchers(path, typescript.FileWatcherEventKind.Created);
+            invokeDirectoryWatchers(normalizedPath);
+            deletedFiles.set(normalizedPath, false);
+        },
+        invokeFileChanged(path) {
+            const normalizedPath = realFileSystem.normalizePath(path);
+            if (deletedFiles.get(normalizedPath) || !fileWatcherCallbacksMap.has(normalizedPath)) {
+                invokeFileWatchers(path, typescript.FileWatcherEventKind.Created);
+                invokeDirectoryWatchers(normalizedPath);
+                deletedFiles.set(normalizedPath, false);
+            }
+            else {
+                invokeFileWatchers(path, typescript.FileWatcherEventKind.Changed);
+            }
+        },
+        invokeFileDeleted(path) {
+            const normalizedPath = realFileSystem.normalizePath(path);
+            if (!deletedFiles.get(normalizedPath)) {
+                invokeFileWatchers(path, typescript.FileWatcherEventKind.Deleted);
+                invokeDirectoryWatchers(path);
+                deletedFiles.set(normalizedPath, true);
+            }
+        },
+        clearCache() {
+            realFileSystem.clearCache();
+            memFileSystem.clearCache();
+            passiveFileSystem.clearCache();
+        },
+        setArtifacts(nextArtifacts) {
+            artifacts = nextArtifacts;
+        } });
+    return controlledSystem;
+}
+exports.createControlledTypeScriptSystem = createControlledTypeScriptSystem;

package/dist/collection/node_modules/@storybook/core-common/node_modules/fork-ts-checker-webpack-plugin/lib/typescript-reporter/reporter/ControlledWatchCompilerHost.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function createControlledWatchCompilerHost(typescript, parsedCommandLine, system, createProgram, reportDiagnostic, reportWatchStatus, afterProgramCreate, hostExtensions = []) {
+    const baseWatchCompilerHost = typescript.createWatchCompilerHost(parsedCommandLine.fileNames, parsedCommandLine.options, system, createProgram, reportDiagnostic, reportWatchStatus, parsedCommandLine.projectReferences);
+    let controlledWatchCompilerHost = Object.assign(Object.assign({}, baseWatchCompilerHost), { createProgram(rootNames, options, compilerHost, oldProgram, configFileParsingDiagnostics, projectReferences) {
+            hostExtensions.forEach((hostExtension) => {
+                if (compilerHost && hostExtension.extendCompilerHost) {
+                    compilerHost = hostExtension.extendCompilerHost(compilerHost, parsedCommandLine);
+                }
+            });
+            return baseWatchCompilerHost.createProgram(rootNames, options, compilerHost, oldProgram, configFileParsingDiagnostics, projectReferences);
+        },
+        afterProgramCreate(program) {
+            if (afterProgramCreate) {
+                afterProgramCreate(program);
+            }
+        },
+        onWatchStatusChange() {
+            // do nothing
+        }, watchFile: system.watchFile, watchDirectory: system.watchDirectory, setTimeout: system.setTimeout, clearTimeout: system.clearTimeout, fileExists: system.fileExists, readFile: system.readFile, directoryExists: system.directoryExists, getDirectories: system.getDirectories, realpath: system.realpath });
+    hostExtensions.forEach((hostExtension) => {
+        if (hostExtension.extendWatchCompilerHost) {
+            controlledWatchCompilerHost = hostExtension.extendWatchCompilerHost(controlledWatchCompilerHost, parsedCommandLine);
+        }
+    });
+    return controlledWatchCompilerHost;
+}
+exports.createControlledWatchCompilerHost = createControlledWatchCompilerHost;

package/dist/collection/node_modules/@storybook/core-common/node_modules/fork-ts-checker-webpack-plugin/lib/typescript-reporter/reporter/ControlledWatchSolutionBuilderHost.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ControlledWatchCompilerHost_1 = require("./ControlledWatchCompilerHost");
+function createControlledWatchSolutionBuilderHost(typescript, parsedCommandLine, system, createProgram, reportDiagnostic, reportWatchStatus, reportSolutionBuilderStatus, afterProgramCreate, afterProgramEmitAndDiagnostics, hostExtensions = []) {
+    const controlledWatchCompilerHost = ControlledWatchCompilerHost_1.createControlledWatchCompilerHost(typescript, parsedCommandLine, system, createProgram, reportDiagnostic, reportWatchStatus, afterProgramCreate, hostExtensions);
+    let controlledWatchSolutionBuilderHost = Object.assign(Object.assign({}, controlledWatchCompilerHost), { reportDiagnostic(diagnostic) {
+            if (reportDiagnostic) {
+                reportDiagnostic(diagnostic);
+            }
+        },
+        reportSolutionBuilderStatus(diagnostic) {
+            if (reportSolutionBuilderStatus) {
+                reportSolutionBuilderStatus(diagnostic);
+            }
+        },
+        afterProgramEmitAndDiagnostics(program) {
+            if (afterProgramEmitAndDiagnostics) {
+                afterProgramEmitAndDiagnostics(program);
+            }
+        },
+        createDirectory(path) {
+            system.createDirectory(path);
+        },
+        writeFile(path, data) {
+            system.writeFile(path, data);
+        },
+        getModifiedTime(fileName) {
+            return system.getModifiedTime(fileName);
+        },
+        setModifiedTime(fileName, date) {
+            system.setModifiedTime(fileName, date);
+        },
+        deleteFile(fileName) {
+            system.deleteFile(fileName);
+        },
+        getParsedCommandLine(fileName) {
+            return typescript.getParsedCommandLineOfConfigFile(fileName, { skipLibCheck: true }, Object.assign(Object.assign({}, system), { onUnRecoverableConfigFileDiagnostic: (diagnostic) => {
+                    if (reportDiagnostic) {
+                        reportDiagnostic(diagnostic);
+                    }
+                } }));
+        } });
+    hostExtensions.forEach((hostExtension) => {
+        if (hostExtension.extendWatchSolutionBuilderHost) {
+            controlledWatchSolutionBuilderHost = hostExtension.extendWatchSolutionBuilderHost(controlledWatchSolutionBuilderHost, parsedCommandLine);
+        }
+    });
+    return controlledWatchSolutionBuilderHost;
+}
+exports.createControlledWatchSolutionBuilderHost = createControlledWatchSolutionBuilderHost;