@utrecht/web-component-library-stencil 1.0.0-alpha.162 → 1.0.0-alpha.166

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

@@ -1,179 +0,0 @@
-"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

@@ -1,45 +0,0 @@
-"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

@@ -1,33 +0,0 @@
-"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

@@ -1,231 +0,0 @@
-"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

@@ -1,28 +0,0 @@
-"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

@@ -1,50 +0,0 @@
-"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;