up n_m

node_modules/fork-ts-checker-webpack-plugin/lib/ForkTsCheckerWebpackPlugin.d.ts

@@ -0,0 +1,29 @@
+import webpack from 'webpack';
+import { ForkTsCheckerWebpackPluginOptions } from './ForkTsCheckerWebpackPluginOptions';
+import { Pool } from './utils/async/pool';
+declare class ForkTsCheckerWebpackPlugin implements webpack.Plugin {
+    /**
+     * Current version of the plugin
+     */
+    static readonly version: string;
+    /**
+     * Default pools for the plugin concurrency limit
+     */
+    static readonly issuesPool: Pool;
+    static readonly dependenciesPool: Pool;
+    /**
+     * @deprecated Use ForkTsCheckerWebpackPlugin.issuesPool instead
+     */
+    static get pool(): Pool;
+    private readonly options;
+    constructor(options?: ForkTsCheckerWebpackPluginOptions);
+    static getCompilerHooks(compiler: webpack.Compiler): {
+        start: import("tapable").AsyncSeriesWaterfallHook<import("./reporter/FilesChange").FilesChange, webpack.compilation.Compilation, any>;
+        waiting: import("tapable").SyncHook<webpack.compilation.Compilation, any, any>;
+        canceled: import("tapable").SyncHook<webpack.compilation.Compilation, any, any>;
+        error: import("tapable").SyncHook<Error, webpack.compilation.Compilation, any>;
+        issues: import("tapable").SyncWaterfallHook<import("./issue/Issue").Issue[], webpack.compilation.Compilation | undefined, void>;
+    };
+    apply(compiler: webpack.Compiler): void;
+}
+export { ForkTsCheckerWebpackPlugin };

node_modules/fork-ts-checker-webpack-plugin/lib/ForkTsCheckerWebpackPlugin.js

@@ -0,0 +1,84 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const schema_utils_1 = __importDefault(require("schema-utils"));
+const cosmiconfig_1 = require("cosmiconfig");
+const deepmerge_1 = __importDefault(require("deepmerge"));
+const ForkTsCheckerWebpackPluginOptions_json_1 = __importDefault(require("./ForkTsCheckerWebpackPluginOptions.json"));
+const ForkTsCheckerWebpackPluginConfiguration_1 = require("./ForkTsCheckerWebpackPluginConfiguration");
+const ForkTsCheckerWebpackPluginState_1 = require("./ForkTsCheckerWebpackPluginState");
+const reporter_1 = require("./reporter");
+const TypeScriptSupport_1 = require("./typescript-reporter/TypeScriptSupport");
+const TypeScriptReporterRpcClient_1 = require("./typescript-reporter/reporter/TypeScriptReporterRpcClient");
+const assertEsLintSupport_1 = require("./eslint-reporter/assertEsLintSupport");
+const EsLintReporterRpcClient_1 = require("./eslint-reporter/reporter/EsLintReporterRpcClient");
+const tapStartToConnectAndRunReporter_1 = require("./hooks/tapStartToConnectAndRunReporter");
+const tapStopToDisconnectReporter_1 = require("./hooks/tapStopToDisconnectReporter");
+const tapAfterCompileToAddDependencies_1 = require("./hooks/tapAfterCompileToAddDependencies");
+const tapErrorToLogMessage_1 = require("./hooks/tapErrorToLogMessage");
+const pluginHooks_1 = require("./hooks/pluginHooks");
+const tapAfterEnvironmentToPatchWatching_1 = require("./hooks/tapAfterEnvironmentToPatchWatching");
+const pool_1 = require("./utils/async/pool");
+const os_1 = __importDefault(require("os"));
+class ForkTsCheckerWebpackPlugin {
+    constructor(options = {}) {
+        const explorerSync = cosmiconfig_1.cosmiconfigSync('fork-ts-checker');
+        const { config: externalOptions } = explorerSync.search() || {};
+        // first validate options directly passed to the constructor
+        const configuration = { name: 'ForkTsCheckerWebpackPlugin' };
+        schema_utils_1.default(ForkTsCheckerWebpackPluginOptions_json_1.default, options, configuration);
+        this.options = deepmerge_1.default(externalOptions || {}, options || {});
+        // then validate merged options
+        schema_utils_1.default(ForkTsCheckerWebpackPluginOptions_json_1.default, this.options, configuration);
+    }
+    /**
+     * @deprecated Use ForkTsCheckerWebpackPlugin.issuesPool instead
+     */
+    static get pool() {
+        // for backward compatibility
+        return ForkTsCheckerWebpackPlugin.issuesPool;
+    }
+    static getCompilerHooks(compiler) {
+        return pluginHooks_1.getForkTsCheckerWebpackPluginHooks(compiler);
+    }
+    apply(compiler) {
+        const configuration = ForkTsCheckerWebpackPluginConfiguration_1.createForkTsCheckerWebpackPluginConfiguration(compiler, this.options);
+        const state = ForkTsCheckerWebpackPluginState_1.createForkTsCheckerWebpackPluginState();
+        const issuesReporters = [];
+        const dependenciesReporters = [];
+        if (configuration.typescript.enabled) {
+            TypeScriptSupport_1.assertTypeScriptSupport(configuration.typescript);
+            issuesReporters.push(TypeScriptReporterRpcClient_1.createTypeScriptReporterRpcClient(configuration.typescript));
+            dependenciesReporters.push(TypeScriptReporterRpcClient_1.createTypeScriptReporterRpcClient(configuration.typescript));
+        }
+        if (configuration.eslint.enabled) {
+            assertEsLintSupport_1.assertEsLintSupport(configuration.eslint);
+            issuesReporters.push(EsLintReporterRpcClient_1.createEsLintReporterRpcClient(configuration.eslint));
+            dependenciesReporters.push(EsLintReporterRpcClient_1.createEsLintReporterRpcClient(configuration.eslint));
+        }
+        if (issuesReporters.length) {
+            const issuesReporter = reporter_1.createAggregatedReporter(reporter_1.composeReporterRpcClients(issuesReporters));
+            const dependenciesReporter = reporter_1.createAggregatedReporter(reporter_1.composeReporterRpcClients(dependenciesReporters));
+            tapAfterEnvironmentToPatchWatching_1.tapAfterEnvironmentToPatchWatching(compiler, state);
+            tapStartToConnectAndRunReporter_1.tapStartToConnectAndRunReporter(compiler, issuesReporter, dependenciesReporter, configuration, state);
+            tapAfterCompileToAddDependencies_1.tapAfterCompileToAddDependencies(compiler, configuration, state);
+            tapStopToDisconnectReporter_1.tapStopToDisconnectReporter(compiler, issuesReporter, dependenciesReporter, state);
+            tapErrorToLogMessage_1.tapErrorToLogMessage(compiler, configuration);
+        }
+        else {
+            throw new Error(`ForkTsCheckerWebpackPlugin is configured to not use any issue reporter. It's probably a configuration issue.`);
+        }
+    }
+}
+exports.ForkTsCheckerWebpackPlugin = ForkTsCheckerWebpackPlugin;
+/**
+ * Current version of the plugin
+ */
+ForkTsCheckerWebpackPlugin.version = '6.5.3'; // will be replaced by the @semantic-release/exec
+/**
+ * Default pools for the plugin concurrency limit
+ */
+ForkTsCheckerWebpackPlugin.issuesPool = pool_1.createPool(Math.max(1, os_1.default.cpus().length));
+ForkTsCheckerWebpackPlugin.dependenciesPool = pool_1.createPool(Math.max(1, os_1.default.cpus().length));

node_modules/fork-ts-checker-webpack-plugin/lib/ForkTsCheckerWebpackPluginConfiguration.d.ts

@@ -0,0 +1,17 @@
+import webpack from 'webpack';
+import { ForkTsCheckerWebpackPluginOptions } from './ForkTsCheckerWebpackPluginOptions';
+import { IssueConfiguration } from './issue/IssueConfiguration';
+import { FormatterConfiguration } from './formatter';
+import { TypeScriptReporterConfiguration } from './typescript-reporter/TypeScriptReporterConfiguration';
+import { EsLintReporterConfiguration } from './eslint-reporter/EsLintReporterConfiguration';
+import { LoggerConfiguration } from './logger/LoggerConfiguration';
+interface ForkTsCheckerWebpackPluginConfiguration {
+    async: boolean;
+    typescript: TypeScriptReporterConfiguration;
+    eslint: EsLintReporterConfiguration;
+    issue: IssueConfiguration;
+    formatter: FormatterConfiguration;
+    logger: LoggerConfiguration;
+}
+declare function createForkTsCheckerWebpackPluginConfiguration(compiler: webpack.Compiler, options?: ForkTsCheckerWebpackPluginOptions): ForkTsCheckerWebpackPluginConfiguration;
+export { ForkTsCheckerWebpackPluginConfiguration, createForkTsCheckerWebpackPluginConfiguration };

node_modules/fork-ts-checker-webpack-plugin/lib/ForkTsCheckerWebpackPluginConfiguration.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const IssueConfiguration_1 = require("./issue/IssueConfiguration");
+const formatter_1 = require("./formatter");
+const TypeScriptReporterConfiguration_1 = require("./typescript-reporter/TypeScriptReporterConfiguration");
+const EsLintReporterConfiguration_1 = require("./eslint-reporter/EsLintReporterConfiguration");
+const LoggerConfiguration_1 = require("./logger/LoggerConfiguration");
+function createForkTsCheckerWebpackPluginConfiguration(compiler, options = {}) {
+    return {
+        async: options.async === undefined ? compiler.options.mode === 'development' : options.async,
+        typescript: TypeScriptReporterConfiguration_1.createTypeScriptReporterConfiguration(compiler, options.typescript),
+        eslint: EsLintReporterConfiguration_1.createEsLintReporterConfiguration(compiler, options.eslint),
+        issue: IssueConfiguration_1.createIssueConfiguration(compiler, options.issue),
+        formatter: formatter_1.createFormatterConfiguration(options.formatter),
+        logger: LoggerConfiguration_1.createLoggerConfiguration(compiler, options.logger),
+    };
+}
+exports.createForkTsCheckerWebpackPluginConfiguration = createForkTsCheckerWebpackPluginConfiguration;

node_modules/fork-ts-checker-webpack-plugin/lib/ForkTsCheckerWebpackPluginOptions.d.ts

@@ -0,0 +1,14 @@
+import { TypeScriptReporterOptions } from './typescript-reporter/TypeScriptReporterOptions';
+import { EsLintReporterOptions } from './eslint-reporter/EsLintReporterOptions';
+import { IssueOptions } from './issue/IssueOptions';
+import { FormatterOptions } from './formatter';
+import LoggerOptions from './logger/LoggerOptions';
+interface ForkTsCheckerWebpackPluginOptions {
+    async?: boolean;
+    typescript?: TypeScriptReporterOptions;
+    eslint?: EsLintReporterOptions;
+    formatter?: FormatterOptions;
+    issue?: IssueOptions;
+    logger?: LoggerOptions;
+}
+export { ForkTsCheckerWebpackPluginOptions };

node_modules/fork-ts-checker-webpack-plugin/lib/ForkTsCheckerWebpackPluginOptions.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

node_modules/fork-ts-checker-webpack-plugin/lib/ForkTsCheckerWebpackPluginOptions.json

@@ -0,0 +1,297 @@
+{
+    "$schema": "http://json-schema.org/draft-07/schema#",
+    "type": "object",
+    "properties": {
+        "async": {
+            "type": "boolean",
+            "description": "When true, plugin will not block compilation to finish issues checking"
+        },
+        "typescript": {
+            "$ref": "#/definitions/TypeScriptReporterOptions"
+        },
+        "eslint": {
+            "$ref": "#/definitions/EsLintReporterOptions"
+        },
+        "formatter": {
+            "$ref": "#/definitions/FormatterOptions"
+        },
+        "issue": {
+            "$ref": "#/definitions/IssueOptions"
+        },
+        "logger": {
+            "$ref": "#/definitions/LoggerOptions"
+        }
+    },
+    "additionalProperties": false,
+    "definitions": {
+        "Formatter": {
+            "instanceof": "Function"
+        },
+        "ComplexFormatterPreferences": {
+            "type": "object",
+            "properties": {
+                "type": {
+                    "$ref": "#/definitions/FormatterType"
+                },
+                "options": {
+                    "type": "object",
+                    "additionalProperties": true
+                }
+            },
+            "required": ["type"]
+        },
+        "FormatterType": {
+            "type": "string",
+            "enum": ["basic", "codeframe"]
+        },
+        "IssueMatch": {
+            "type": "object",
+            "properties": {
+                "origin": {
+                    "type": "string",
+                    "enum": ["typescript", "eslint"]
+                },
+                "severity": {
+                    "type": "string",
+                    "enum": ["error", "warning"]
+                },
+                "code": {
+                    "type": "string"
+                },
+                "file": {
+                    "type": "string"
+                }
+            }
+        },
+        "IssuePredicate": {
+            "instanceof": "Function"
+        },
+        "IssuePredicateOption": {
+            "oneOf": [
+                {
+                    "$ref": "#/definitions/IssuePredicate"
+                },
+                {
+                    "$ref": "#/definitions/IssueMatch"
+                },
+                {
+                    "type": "array",
+                    "items": {
+                        "oneOf": [
+                            {
+                                "$ref": "#/definitions/IssuePredicate"
+                            },
+                            {
+                                "$ref": "#/definitions/IssueMatch"
+                            }
+                        ]
+                    }
+                }
+            ]
+        },
+        "LoggerType": {
+            "type": "string",
+            "enum": ["console", "webpack-infrastructure", "silent"]
+        },
+        "Logger": {
+            "type": "object",
+            "properties": {
+                "error": {
+                    "instanceof": "Function"
+                },
+                "info": {
+                    "instanceof": "Function"
+                },
+                "log": {
+                    "instanceof": "Function"
+                }
+            }
+        },
+        "TypeScriptReporterOptions": {
+            "oneOf": [
+                {
+                    "type": "boolean",
+                    "description": "Enable TypeScript reporter."
+                },
+                {
+                    "type": "object",
+                    "properties": {
+                        "enabled": {
+                            "type": "boolean",
+                            "description": "Enable TypeScript reporter."
+                        },
+                        "memoryLimit": {
+                            "type": "number",
+                            "description": "Memory limit for TypeScript reporter process."
+                        },
+                        "configFile": {
+                            "type": "string",
+                            "description": "Path to tsconfig.json. By default plugin uses context or process.cwd() to localize tsconfig.json file."
+                        },
+                        "context": {
+                            "type": "string",
+                            "description": "The base path for finding files specified in the tsconfig.json. Same as context option from the ts-loader."
+                        },
+                        "build": {
+                            "type": "boolean",
+                            "description": "The equivalent of the `--build` flag from the `tsc`."
+                        },
+                        "mode": {
+                            "type": "string",
+                            "enum": ["readonly", "write-tsbuildinfo", "write-dts", "write-references"],
+                            "description": "`readonly` keeps all emitted files in memory, `write-tsbuildinfo` which writes only .tsbuildinfo files, `write-dts` writes .tsbuildinfo and type definition files, and `write-references` which writes both .tsbuildinfo and referenced projects output"
+                        },
+                        "compilerOptions": {
+                            "type": "object",
+                            "description": "Custom compilerOptions to be passed to the TypeScript compiler.",
+                            "additionalProperties": true
+                        },
+                        "diagnosticOptions": {
+                            "type": "object",
+                            "description": "Types of diagnostics to be reported.",
+                            "properties": {
+                                "syntactic": {
+                                    "type": "boolean"
+                                },
+                                "semantic": {
+                                    "type": "boolean"
+                                },
+                                "declaration": {
+                                    "type": "boolean"
+                                },
+                                "global": {
+                                    "type": "boolean"
+                                }
+                            }
+                        },
+                        "extensions": {
+                            "type": "object",
+                            "properties": {
+                                "vue": {
+                                    "$ref": "#/definitions/TypeScriptVueExtensionOptions"
+                                }
+                            }
+                        },
+                        "profile": {
+                            "type": "boolean",
+                            "description": "Measures and prints timings related to the TypeScript performance."
+                        },
+                        "typescriptPath": {
+                            "type": "string",
+                            "description": "If supplied this is a custom path where TypeScript can be found."
+                        }
+                    }
+                }
+            ]
+        },
+        "TypeScriptVueExtensionOptions": {
+            "oneOf": [
+                {
+                    "type": "boolean",
+                    "description": "Enable TypeScript Vue extension."
+                },
+                {
+                    "type": "object",
+                    "properties": {
+                        "enabled": {
+                            "type": "boolean",
+                            "description": "Enable TypeScript Vue extension."
+                        },
+                        "compiler": {
+                            "type": "string",
+                            "description": "Custom vue-template-compiler package"
+                        }
+                    }
+                }
+            ]
+        },
+        "EsLintReporterOptions": {
+            "type": "object",
+            "properties": {
+                "files": {
+                    "oneOf": [
+                        {
+                            "type": "array",
+                            "items": {
+                                "type": "string"
+                            },
+                            "minItems": 1,
+                            "uniqueItems": true
+                        },
+                        {
+                            "type": "string"
+                        }
+                    ],
+                    "description": "List of glob patterns or files to be linted."
+                },
+                "enabled": {
+                    "type": "boolean",
+                    "description": "Enable EsLint reporter."
+                },
+                "memoryLimit": {
+                    "type": "number",
+                    "description": "Memory limit for EsLint reporter process."
+                },
+                "options": {
+                    "type": "object",
+                    "description": "Custom options to be passed to the EsLint engine.",
+                    "additionalProperties": true
+                }
+            },
+            "required": ["files"]
+        },
+        "FormatterOptions": {
+            "oneOf": [
+                {
+                    "$ref": "#/definitions/FormatterType"
+                },
+                {
+                    "$ref": "#/definitions/ComplexFormatterPreferences"
+                },
+                {
+                    "$ref": "#/definitions/Formatter"
+                }
+            ]
+        },
+        "IssueOptions": {
+            "type": "object",
+            "properties": {
+                "include": {
+                    "$ref": "#/definitions/IssuePredicateOption"
+                },
+                "exclude": {
+                    "$ref": "#/definitions/IssuePredicateOption"
+                }
+            }
+        },
+        "LoggerOptions": {
+            "type": "object",
+            "properties": {
+                "infrastructure": {
+                    "oneOf": [
+                        {
+                            "$ref": "#/definitions/LoggerType"
+                        },
+                        {
+                            "$ref": "#/definitions/Logger"
+                        }
+                    ]
+                },
+                "issues": {
+                    "oneOf": [
+                        {
+                            "$ref": "#/definitions/LoggerType"
+                        },
+                        {
+                            "$ref": "#/definitions/Logger"
+                        }
+                    ]
+                },
+                "devServer": {
+                    "type": "boolean",
+                    "description": "Enable reporting to Webpack Dev Server."
+                }
+            }
+        }
+    }
+}

node_modules/fork-ts-checker-webpack-plugin/lib/ForkTsCheckerWebpackPluginState.d.ts

@@ -0,0 +1,15 @@
+import { Tap } from 'tapable';
+import { FilesMatch, Report } from './reporter';
+import { Issue } from './issue';
+interface ForkTsCheckerWebpackPluginState {
+    issuesReportPromise: Promise<Report | undefined>;
+    dependenciesReportPromise: Promise<Report | undefined>;
+    issuesPromise: Promise<Issue[] | undefined>;
+    dependenciesPromise: Promise<FilesMatch | undefined>;
+    lastDependencies: FilesMatch | undefined;
+    watching: boolean;
+    initialized: boolean;
+    webpackDevServerDoneTap: Tap | undefined;
+}
+declare function createForkTsCheckerWebpackPluginState(): ForkTsCheckerWebpackPluginState;
+export { ForkTsCheckerWebpackPluginState, createForkTsCheckerWebpackPluginState };

node_modules/fork-ts-checker-webpack-plugin/lib/ForkTsCheckerWebpackPluginState.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function createForkTsCheckerWebpackPluginState() {
+    return {
+        issuesReportPromise: Promise.resolve(undefined),
+        dependenciesReportPromise: Promise.resolve(undefined),
+        issuesPromise: Promise.resolve(undefined),
+        dependenciesPromise: Promise.resolve(undefined),
+        lastDependencies: undefined,
+        watching: false,
+        initialized: false,
+        webpackDevServerDoneTap: undefined,
+    };
+}
+exports.createForkTsCheckerWebpackPluginState = createForkTsCheckerWebpackPluginState;

node_modules/fork-ts-checker-webpack-plugin/lib/error/OperationCanceledError.d.ts

@@ -0,0 +1,4 @@
+declare class OperationCanceledError extends Error {
+    readonly canceled = true;
+}
+export { OperationCanceledError };

node_modules/fork-ts-checker-webpack-plugin/lib/error/OperationCanceledError.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class OperationCanceledError extends Error {
+    constructor() {
+        super(...arguments);
+        this.canceled = true;
+    }
+}
+exports.OperationCanceledError = OperationCanceledError;

node_modules/fork-ts-checker-webpack-plugin/lib/eslint-reporter/EsLintReporterConfiguration.d.ts

@@ -0,0 +1,11 @@
+import webpack from 'webpack';
+import { EsLintReporterOptions } from './EsLintReporterOptions';
+import { CLIEngineOptions } from './types/eslint';
+interface EsLintReporterConfiguration {
+    enabled: boolean;
+    memoryLimit: number;
+    options: CLIEngineOptions;
+    files: string[];
+}
+declare function createEsLintReporterConfiguration(compiler: webpack.Compiler, options: EsLintReporterOptions | undefined): EsLintReporterConfiguration;
+export { EsLintReporterConfiguration, createEsLintReporterConfiguration };

node_modules/fork-ts-checker-webpack-plugin/lib/eslint-reporter/EsLintReporterConfiguration.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
+function castToArray(value) {
+    if (!value) {
+        return [];
+    }
+    else if (!Array.isArray(value)) {
+        return [value];
+    }
+    else {
+        return value;
+    }
+}
+function createEsLintReporterConfiguration(compiler, options) {
+    const filesPatterns = (typeof options === 'object' ? castToArray(options.files) : []).map((filesPattern) => 
+    // ensure that `filesPattern` is an absolute path
+    path_1.isAbsolute(filesPattern)
+        ? filesPattern
+        : path_1.join(compiler.options.context || process.cwd(), filesPattern));
+    return Object.assign(Object.assign({ enabled: !!options &&
+            typeof options !== 'boolean' &&
+            filesPatterns.length > 0 && // enable by default if files are provided
+            options.enabled !== false, memoryLimit: 2048 }, (typeof options === 'object' ? options : {})), { files: filesPatterns, options: Object.assign({ cwd: compiler.options.context || process.cwd(), extensions: ['.ts', '.tsx', '.js', '.jsx'] }, (typeof options === 'object' ? options.options || {} : {})) });
+}
+exports.createEsLintReporterConfiguration = createEsLintReporterConfiguration;

node_modules/fork-ts-checker-webpack-plugin/lib/eslint-reporter/EsLintReporterOptions.d.ts

@@ -0,0 +1,8 @@
+import { CLIEngineOptions } from './types/eslint';
+declare type EsLintReporterOptions = {
+    files: string | string[];
+    enabled?: boolean;
+    memoryLimit?: number;
+    options?: CLIEngineOptions;
+};
+export { EsLintReporterOptions };

node_modules/fork-ts-checker-webpack-plugin/lib/eslint-reporter/EsLintReporterOptions.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

node_modules/fork-ts-checker-webpack-plugin/lib/eslint-reporter/assertEsLintSupport.d.ts

@@ -0,0 +1,3 @@
+import { EsLintReporterConfiguration } from './EsLintReporterConfiguration';
+declare function assertEsLintSupport(configuration: EsLintReporterConfiguration): void;
+export { assertEsLintSupport };

node_modules/fork-ts-checker-webpack-plugin/lib/eslint-reporter/assertEsLintSupport.js

@@ -0,0 +1,30 @@
+"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 semver = __importStar(require("semver"));
+function assertEsLintSupport(configuration) {
+    if (semver.lt(process.version, '8.10.0')) {
+        throw new Error(`To use 'eslint' option, please update to Node.js >= v8.10.0 ` +
+            `(current version is ${process.version})`);
+    }
+    let eslintVersion;
+    try {
+        eslintVersion = require('eslint').Linter.version;
+    }
+    catch (error) {
+        throw new Error(`When you use 'eslint' option, make sure to install 'eslint'.`);
+    }
+    if (semver.lt(eslintVersion, '6.0.0')) {
+        throw new Error(`Cannot use current eslint version of ${eslintVersion}, the minimum required version is 6.0.0`);
+    }
+    if (!configuration.files) {
+        throw new Error('The `eslint.files` settings is required for EsLint reporter to work.');
+    }
+}
+exports.assertEsLintSupport = assertEsLintSupport;

node_modules/fork-ts-checker-webpack-plugin/lib/eslint-reporter/issue/EsLintIssueFactory.d.ts

@@ -0,0 +1,4 @@
+import { Issue } from '../../issue';
+import { LintResult } from '../types/eslint';
+declare function createIssuesFromEsLintResults(results: LintResult[]): Issue[];
+export { createIssuesFromEsLintResults };

node_modules/fork-ts-checker-webpack-plugin/lib/eslint-reporter/issue/EsLintIssueFactory.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function createIssueFromEsLintMessage(filePath, message) {
+    let location;
+    if (message.line) {
+        location = {
+            start: {
+                line: message.line,
+                column: message.column,
+            },
+            end: {
+                line: message.endLine || message.line,
+                column: message.endColumn || message.column,
+            },
+        };
+    }
+    return {
+        origin: 'eslint',
+        code: message.ruleId ? String(message.ruleId) : '[unknown]',
+        severity: message.severity === 1 ? 'warning' : 'error',
+        message: message.message,
+        file: filePath,
+        location,
+    };
+}
+function createIssuesFromEsLintResults(results) {
+    return results.reduce((messages, result) => [
+        ...messages,
+        ...result.messages.map((message) => createIssueFromEsLintMessage(result.filePath, message)),
+    ], []);
+}
+exports.createIssuesFromEsLintResults = createIssuesFromEsLintResults;

node_modules/fork-ts-checker-webpack-plugin/lib/eslint-reporter/reporter/EsLintReporter.d.ts

@@ -0,0 +1,4 @@
+import { EsLintReporterConfiguration } from '../EsLintReporterConfiguration';
+import { Reporter } from '../../reporter';
+declare function createEsLintReporter(configuration: EsLintReporterConfiguration): Reporter;
+export { createEsLintReporter };

node_modules/fork-ts-checker-webpack-plugin/lib/eslint-reporter/reporter/EsLintReporter.js

@@ -0,0 +1,179 @@
+"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 EsLintIssueFactory_1 = require("../issue/EsLintIssueFactory");
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const minimatch_1 = __importDefault(require("minimatch"));
+const glob_1 = __importDefault(require("glob"));
+const isOldCLIEngine = (eslint) => eslint.resolveFileGlobPatterns !== undefined;
+function createEsLintReporter(configuration) {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const { CLIEngine, ESLint } = require('eslint');
+    const eslint = ESLint
+        ? new ESLint(configuration.options)
+        : new CLIEngine(configuration.options);
+    let isInitialRun = true;
+    let isInitialGetFiles = true;
+    const lintResults = new Map();
+    const includedGlobPatterns = resolveFileGlobPatterns(configuration.files);
+    const includedFiles = new Set();
+    function isFileIncluded(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (!path.includes('node_modules') &&
+                includedGlobPatterns.some((pattern) => minimatch_1.default(path, pattern)) &&
+                !(yield eslint.isPathIgnored(path)));
+        });
+    }
+    function getFiles() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (isInitialGetFiles) {
+                isInitialGetFiles = false;
+                const resolvedGlobs = yield Promise.all(includedGlobPatterns.map((globPattern) => new Promise((resolve) => {
+                    glob_1.default(globPattern, (error, resolvedFiles) => {
+                        if (error) {
+                            // fail silently
+                            resolve([]);
+                        }
+                        else {
+                            resolve(resolvedFiles || []);
+                        }
+                    });
+                })));
+                for (const resolvedGlob of resolvedGlobs) {
+                    for (const resolvedFile of resolvedGlob) {
+                        if (yield isFileIncluded(resolvedFile)) {
+                            includedFiles.add(resolvedFile);
+                        }
+                    }
+                }
+            }
+            return Array.from(includedFiles);
+        });
+    }
+    function getDirs() {
+        return includedGlobPatterns || [];
+    }
+    function getExtensions() {
+        return configuration.options.extensions || [];
+    }
+    // Copied from the eslint 6 implementation, as it's not available in eslint 8
+    function resolveFileGlobPatterns(globPatterns) {
+        if (configuration.options.globInputPaths === false) {
+            return globPatterns.filter(Boolean);
+        }
+        const extensions = getExtensions().map((ext) => ext.replace(/^\./u, ''));
+        const dirSuffix = `/**/*.{${extensions.join(',')}}`;
+        return globPatterns.filter(Boolean).map((globPattern) => {
+            const resolvedPath = path_1.default.resolve(configuration.options.cwd || '', globPattern);
+            const newPath = directoryExists(resolvedPath)
+                ? globPattern.replace(/[/\\]$/u, '') + dirSuffix
+                : globPattern;
+            return path_1.default.normalize(newPath).replace(/\\/gu, '/');
+        });
+    }
+    // Copied from the eslint 6 implementation, as it's not available in eslint 8
+    function directoryExists(resolvedPath) {
+        try {
+            return fs_extra_1.default.statSync(resolvedPath).isDirectory();
+        }
+        catch (error) {
+            if (error && error.code === 'ENOENT') {
+                return false;
+            }
+            throw error;
+        }
+    }
+    return {
+        getReport: ({ changedFiles = [], deletedFiles = [] }) => __awaiter(this, void 0, void 0, function* () {
+            return {
+                getDependencies() {
+                    return __awaiter(this, void 0, void 0, function* () {
+                        for (const changedFile of changedFiles) {
+                            if (yield isFileIncluded(changedFile)) {
+                                includedFiles.add(changedFile);
+                            }
+                        }
+                        for (const deletedFile of deletedFiles) {
+                            includedFiles.delete(deletedFile);
+                        }
+                        return {
+                            files: (yield getFiles()).map((file) => path_1.default.normalize(file)),
+                            dirs: getDirs().map((dir) => path_1.default.normalize(dir)),
+                            excluded: [],
+                            extensions: getExtensions(),
+                        };
+                    });
+                },
+                getIssues() {
+                    return __awaiter(this, void 0, void 0, function* () {
+                        // cleanup old results
+                        for (const changedFile of changedFiles) {
+                            lintResults.delete(changedFile);
+                        }
+                        for (const deletedFile of deletedFiles) {
+                            lintResults.delete(deletedFile);
+                        }
+                        // get reports
+                        const lintReports = [];
+                        if (isInitialRun) {
+                            const lintReport = yield (isOldCLIEngine(eslint)
+                                ? Promise.resolve(eslint.executeOnFiles(includedGlobPatterns))
+                                : eslint.lintFiles(includedGlobPatterns).then((results) => ({ results })));
+                            lintReports.push(lintReport);
+                            isInitialRun = false;
+                        }
+                        else {
+                            // we need to take care to not lint files that are not included by the configuration.
+                            // the eslint engine will not exclude them automatically
+                            const changedAndIncludedFiles = [];
+                            for (const changedFile of changedFiles) {
+                                if (yield isFileIncluded(changedFile)) {
+                                    changedAndIncludedFiles.push(changedFile);
+                                }
+                            }
+                            if (changedAndIncludedFiles.length) {
+                                const lintReport = yield (isOldCLIEngine(eslint)
+                                    ? Promise.resolve(eslint.executeOnFiles(changedAndIncludedFiles))
+                                    : eslint.lintFiles(changedAndIncludedFiles).then((results) => ({ results })));
+                                lintReports.push(lintReport);
+                            }
+                        }
+                        // output fixes if `fix` option is provided
+                        if (configuration.options.fix) {
+                            yield Promise.all(lintReports.map((lintReport) => isOldCLIEngine(eslint)
+                                ? CLIEngine.outputFixes(lintReport)
+                                : ESLint.outputFixes(lintReport.results)));
+                        }
+                        // store results
+                        for (const lintReport of lintReports) {
+                            for (const lintResult of lintReport.results) {
+                                lintResults.set(lintResult.filePath, lintResult);
+                            }
+                        }
+                        // get actual list of previous and current reports
+                        const results = Array.from(lintResults.values());
+                        return EsLintIssueFactory_1.createIssuesFromEsLintResults(results);
+                    });
+                },
+                close() {
+                    return __awaiter(this, void 0, void 0, function* () {
+                        // do nothing
+                    });
+                },
+            };
+        }),
+    };
+}
+exports.createEsLintReporter = createEsLintReporter;

node_modules/fork-ts-checker-webpack-plugin/lib/eslint-reporter/reporter/EsLintReporterRpcClient.d.ts

@@ -0,0 +1,4 @@
+import { EsLintReporterConfiguration } from '../EsLintReporterConfiguration';
+import { ReporterRpcClient } from '../../reporter';
+declare function createEsLintReporterRpcClient(configuration: EsLintReporterConfiguration): ReporterRpcClient;
+export { createEsLintReporterRpcClient };

node_modules/fork-ts-checker-webpack-plugin/lib/eslint-reporter/reporter/EsLintReporterRpcClient.js

@@ -0,0 +1,13 @@
+"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 = __importDefault(require("path"));
+const reporter_1 = require("../../reporter");
+const rpc_ipc_1 = require("../../rpc/rpc-ipc");
+function createEsLintReporterRpcClient(configuration) {
+    const channel = rpc_ipc_1.createRpcIpcMessageChannel(path_1.default.resolve(__dirname, './EsLintReporterRpcService.js'), configuration.memoryLimit);
+    return reporter_1.createReporterRpcClient(channel, configuration);
+}
+exports.createEsLintReporterRpcClient = createEsLintReporterRpcClient;

node_modules/fork-ts-checker-webpack-plugin/lib/eslint-reporter/reporter/EsLintReporterRpcService.d.ts

@@ -0,0 +1 @@
+export {};

node_modules/fork-ts-checker-webpack-plugin/lib/eslint-reporter/reporter/EsLintReporterRpcService.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const process_1 = __importDefault(require("process"));
+const EsLintReporter_1 = require("./EsLintReporter");
+const reporter_1 = require("../../reporter");
+const rpc_ipc_1 = require("../../rpc/rpc-ipc");
+const service = reporter_1.registerReporterRpcService(rpc_ipc_1.createRpcIpcMessagePort(process_1.default), EsLintReporter_1.createEsLintReporter);
+service.open();

node_modules/fork-ts-checker-webpack-plugin/lib/eslint-reporter/types/eslint.d.ts

@@ -0,0 +1,37 @@
+export interface LintMessage {
+    ruleId: string | null;
+    severity: number;
+    message: string;
+    line: number;
+    column: number;
+    endColumn?: number;
+    endLine?: number;
+    [key: string]: any;
+}
+export interface LintResult {
+    filePath: string;
+    messages: LintMessage[];
+    [key: string]: any;
+}
+export interface LintReport {
+    results: LintResult[];
+    [key: string]: any;
+}
+export interface CLIEngine {
+    version: string;
+    executeOnFiles(filesPatterns: string[]): LintReport;
+    resolveFileGlobPatterns(filesPatterns: string[]): string[];
+    isPathIgnored(filePath: string): boolean;
+}
+export interface ESLint {
+    version: string;
+    lintFiles(filesPatterns: string[]): Promise<LintResult[]>;
+    isPathIgnored(filePath: string): Promise<boolean>;
+}
+export declare type ESLintOrCLIEngine = CLIEngine | ESLint;
+export interface CLIEngineOptions {
+    cwd?: string;
+    extensions?: string[];
+    fix?: boolean;
+    [key: string]: any;
+}

node_modules/fork-ts-checker-webpack-plugin/lib/eslint-reporter/types/eslint.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

node_modules/fork-ts-checker-webpack-plugin/lib/formatter/BasicFormatter.d.ts

@@ -0,0 +1,3 @@
+import { Formatter } from './Formatter';
+declare function createBasicFormatter(): Formatter;
+export { createBasicFormatter };

node_modules/fork-ts-checker-webpack-plugin/lib/formatter/BasicFormatter.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chalk_1 = __importDefault(require("chalk"));
+function createBasicFormatter() {
+    return function basicFormatter(issue) {
+        return chalk_1.default.grey(issue.code + ': ') + issue.message;
+    };
+}
+exports.createBasicFormatter = createBasicFormatter;

node_modules/fork-ts-checker-webpack-plugin/lib/formatter/CodeFrameFormatter.d.ts

@@ -0,0 +1,4 @@
+import { Formatter } from './Formatter';
+import { BabelCodeFrameOptions } from './types/babel__code-frame';
+declare function createCodeFrameFormatter(options?: BabelCodeFrameOptions): Formatter;
+export { createCodeFrameFormatter, BabelCodeFrameOptions };

node_modules/fork-ts-checker-webpack-plugin/lib/formatter/CodeFrameFormatter.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const os_1 = __importDefault(require("os"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const code_frame_1 = require("@babel/code-frame");
+const BasicFormatter_1 = require("./BasicFormatter");
+function createCodeFrameFormatter(options) {
+    const basicFormatter = BasicFormatter_1.createBasicFormatter();
+    return function codeFrameFormatter(issue) {
+        const source = issue.file && fs_extra_1.default.existsSync(issue.file) && fs_extra_1.default.readFileSync(issue.file, 'utf-8');
+        let frame = '';
+        if (source && issue.location) {
+            frame = code_frame_1.codeFrameColumns(source, issue.location, Object.assign({ highlightCode: true }, (options || {})))
+                .split('\n')
+                .map((line) => '  ' + line)
+                .join(os_1.default.EOL);
+        }
+        const lines = [basicFormatter(issue)];
+        if (frame) {
+            lines.push(frame);
+        }
+        return lines.join(os_1.default.EOL);
+    };
+}
+exports.createCodeFrameFormatter = createCodeFrameFormatter;

node_modules/fork-ts-checker-webpack-plugin/lib/formatter/Formatter.d.ts

@@ -0,0 +1,3 @@
+import { Issue } from '../issue';
+declare type Formatter = (issue: Issue) => string;
+export { Formatter };

node_modules/fork-ts-checker-webpack-plugin/lib/formatter/Formatter.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

node_modules/fork-ts-checker-webpack-plugin/lib/formatter/FormatterConfiguration.d.ts

@@ -0,0 +1,5 @@
+import { FormatterOptions } from './FormatterOptions';
+import { Formatter } from './Formatter';
+declare type FormatterConfiguration = Formatter;
+declare function createFormatterConfiguration(options: FormatterOptions | undefined): Formatter;
+export { FormatterConfiguration, createFormatterConfiguration };

node_modules/fork-ts-checker-webpack-plugin/lib/formatter/FormatterConfiguration.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const FormatterFactory_1 = require("./FormatterFactory");
+function createFormatterConfiguration(options) {
+    return FormatterFactory_1.createFormatter(options ? (typeof options === 'object' ? options.type || 'codeframe' : options) : 'codeframe', options && typeof options === 'object' ? options.options || {} : {});
+}
+exports.createFormatterConfiguration = createFormatterConfiguration;

node_modules/fork-ts-checker-webpack-plugin/lib/formatter/FormatterFactory.d.ts

@@ -0,0 +1,13 @@
+import { Formatter } from './Formatter';
+import { BabelCodeFrameOptions } from './CodeFrameFormatter';
+declare type NotConfigurableFormatterType = undefined | 'basic' | Formatter;
+declare type ConfigurableFormatterType = 'codeframe';
+declare type FormatterType = NotConfigurableFormatterType | ConfigurableFormatterType;
+declare type ConfigurableFormatterOptions = {
+    codeframe: BabelCodeFrameOptions;
+};
+declare type ComplexFormatterOptions<T extends FormatterType> = T extends ConfigurableFormatterType ? ConfigurableFormatterOptions[T] : never;
+declare function createFormatter<T extends NotConfigurableFormatterType>(type?: T): Formatter;
+declare function createFormatter<T extends ConfigurableFormatterType>(type: T, options?: ConfigurableFormatterOptions[T]): Formatter;
+declare function createFormatter<T extends FormatterType>(type: T, options?: object): Formatter;
+export { createFormatter, FormatterType, ComplexFormatterOptions, NotConfigurableFormatterType, ConfigurableFormatterType, ConfigurableFormatterOptions, };

node_modules/fork-ts-checker-webpack-plugin/lib/formatter/FormatterFactory.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const CodeFrameFormatter_1 = require("./CodeFrameFormatter");
+const BasicFormatter_1 = require("./BasicFormatter");
+// declare function implementation
+function createFormatter(type, options) {
+    if (typeof type === 'function') {
+        return type;
+    }
+    if (typeof type === 'undefined' || type === 'basic') {
+        return BasicFormatter_1.createBasicFormatter();
+    }
+    if (type === 'codeframe') {
+        return CodeFrameFormatter_1.createCodeFrameFormatter(options);
+    }
+    throw new Error(`Unknown "${type}" formatter. Available types are: "basic", "codeframe" or a custom function.`);
+}
+exports.createFormatter = createFormatter;

node_modules/fork-ts-checker-webpack-plugin/lib/formatter/FormatterOptions.d.ts

@@ -0,0 +1,7 @@
+import { ComplexFormatterOptions, FormatterType } from './FormatterFactory';
+declare type ComplexFormatterPreferences<T extends FormatterType = FormatterType> = {
+    type: T;
+    options?: ComplexFormatterOptions<T>;
+};
+declare type FormatterOptions = FormatterType | ComplexFormatterPreferences;
+export { FormatterOptions };

node_modules/fork-ts-checker-webpack-plugin/lib/formatter/FormatterOptions.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

node_modules/fork-ts-checker-webpack-plugin/lib/formatter/WebpackFormatter.d.ts

@@ -0,0 +1,3 @@
+import { Formatter } from './Formatter';
+declare function createWebpackFormatter(formatter: Formatter): Formatter;
+export { createWebpackFormatter };

node_modules/fork-ts-checker-webpack-plugin/lib/formatter/WebpackFormatter.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const os_1 = __importDefault(require("os"));
+const chalk_1 = __importDefault(require("chalk"));
+const path_1 = __importDefault(require("path"));
+const issue_1 = require("../issue");
+const forwardSlash_1 = __importDefault(require("../utils/path/forwardSlash"));
+function createWebpackFormatter(formatter) {
+    // mimics webpack error formatter
+    return function webpackFormatter(issue) {
+        const color = issue.severity === 'warning' ? chalk_1.default.yellow.bold : chalk_1.default.red.bold;
+        const severity = issue.severity.toUpperCase();
+        if (issue.file) {
+            let location = forwardSlash_1.default(path_1.default.relative(process.cwd(), issue.file));
+            if (issue.location) {
+                location += `:${issue_1.formatIssueLocation(issue.location)}`;
+            }
+            return [color(`${severity} in ${location}`), formatter(issue), ''].join(os_1.default.EOL);
+        }
+        else {
+            return [color(`${severity} in `) + formatter(issue), ''].join(os_1.default.EOL);
+        }
+    };
+}
+exports.createWebpackFormatter = createWebpackFormatter;

node_modules/fork-ts-checker-webpack-plugin/lib/formatter/index.d.ts

@@ -0,0 +1,7 @@
+export * from './Formatter';
+export * from './BasicFormatter';
+export * from './CodeFrameFormatter';
+export * from './WebpackFormatter';
+export * from './FormatterFactory';
+export * from './FormatterOptions';
+export * from './FormatterConfiguration';

node_modules/fork-ts-checker-webpack-plugin/lib/formatter/index.js

@@ -0,0 +1,10 @@
+"use strict";
+function __export(m) {
+    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+__export(require("./BasicFormatter"));
+__export(require("./CodeFrameFormatter"));
+__export(require("./WebpackFormatter"));
+__export(require("./FormatterFactory"));
+__export(require("./FormatterConfiguration"));

node_modules/fork-ts-checker-webpack-plugin/lib/formatter/types/babel__code-frame.d.ts

@@ -0,0 +1,21 @@
+export interface BabelCodeFrameOptions {
+    /** Syntax highlight the code as JavaScript for terminals. default: false */
+    highlightCode?: boolean;
+    /**  The number of lines to show above the error. default: 2 */
+    linesAbove?: number;
+    /**  The number of lines to show below the error. default: 3 */
+    linesBelow?: number;
+    /**
+     * Forcibly syntax highlight the code as JavaScript (for non-terminals);
+     * overrides highlightCode.
+     * default: false
+     */
+    forceColor?: boolean;
+    /**
+     * Pass in a string to be displayed inline (if possible) next to the
+     * highlighted location in the code. If it can't be positioned inline,
+     * it will be placed above the code frame.
+     * default: nothing
+     */
+    message?: string;
+}

node_modules/fork-ts-checker-webpack-plugin/lib/formatter/types/babel__code-frame.js

@@ -0,0 +1,7 @@
+"use strict";
+// Base on the type definitions for @babel/code-frame 7.0
+// Project: https://github.com/babel/babel/tree/main/packages/babel-code-frame, https://babeljs.io
+// Definitions by: Mohsen Azimi <https://github.com/mohsen1>
+//                 Forbes Lindesay <https://github.com/ForbesLindesay>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+Object.defineProperty(exports, "__esModule", { value: true });

node_modules/fork-ts-checker-webpack-plugin/lib/hooks/interceptDoneToGetWebpackDevServerTap.d.ts

@@ -0,0 +1,5 @@
+import webpack from 'webpack';
+import { ForkTsCheckerWebpackPluginConfiguration } from '../ForkTsCheckerWebpackPluginConfiguration';
+import { ForkTsCheckerWebpackPluginState } from '../ForkTsCheckerWebpackPluginState';
+declare function interceptDoneToGetWebpackDevServerTap(compiler: webpack.Compiler, configuration: ForkTsCheckerWebpackPluginConfiguration, state: ForkTsCheckerWebpackPluginState): void;
+export { interceptDoneToGetWebpackDevServerTap };

node_modules/fork-ts-checker-webpack-plugin/lib/hooks/interceptDoneToGetWebpackDevServerTap.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function interceptDoneToGetWebpackDevServerTap(compiler, configuration, state) {
+    // inspired by https://github.com/ypresto/fork-ts-checker-async-overlay-webpack-plugin
+    compiler.hooks.done.intercept({
+        register: (tap) => {
+            if (tap.name === 'webpack-dev-server' &&
+                tap.type === 'sync' &&
+                configuration.logger.devServer) {
+                state.webpackDevServerDoneTap = tap;
+            }
+            return tap;
+        },
+    });
+}
+exports.interceptDoneToGetWebpackDevServerTap = interceptDoneToGetWebpackDevServerTap;

node_modules/fork-ts-checker-webpack-plugin/lib/hooks/pluginHooks.d.ts

@@ -0,0 +1,20 @@
+import * as webpack from 'webpack';
+import { SyncHook, SyncWaterfallHook, AsyncSeriesWaterfallHook } from 'tapable';
+import { FilesChange } from '../reporter';
+import { Issue } from '../issue';
+declare function createForkTsCheckerWebpackPluginHooks(): {
+    start: AsyncSeriesWaterfallHook<FilesChange, webpack.compilation.Compilation, any>;
+    waiting: SyncHook<webpack.compilation.Compilation, any, any>;
+    canceled: SyncHook<webpack.compilation.Compilation, any, any>;
+    error: SyncHook<Error, webpack.compilation.Compilation, any>;
+    issues: SyncWaterfallHook<Issue[], webpack.compilation.Compilation | undefined, void>;
+};
+declare type ForkTsCheckerWebpackPluginHooks = ReturnType<typeof createForkTsCheckerWebpackPluginHooks>;
+declare function getForkTsCheckerWebpackPluginHooks(compiler: webpack.Compiler | webpack.MultiCompiler): {
+    start: AsyncSeriesWaterfallHook<FilesChange, webpack.compilation.Compilation, any>;
+    waiting: SyncHook<webpack.compilation.Compilation, any, any>;
+    canceled: SyncHook<webpack.compilation.Compilation, any, any>;
+    error: SyncHook<Error, webpack.compilation.Compilation, any>;
+    issues: SyncWaterfallHook<Issue[], webpack.compilation.Compilation | undefined, void>;
+};
+export { getForkTsCheckerWebpackPluginHooks, ForkTsCheckerWebpackPluginHooks };

node_modules/fork-ts-checker-webpack-plugin/lib/hooks/pluginHooks.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tapable_1 = require("tapable");
+const compilerHookMap = new WeakMap();
+function createForkTsCheckerWebpackPluginHooks() {
+    return {
+        start: new tapable_1.AsyncSeriesWaterfallHook([
+            'change',
+            'compilation',
+        ]),
+        waiting: new tapable_1.SyncHook(['compilation']),
+        canceled: new tapable_1.SyncHook(['compilation']),
+        error: new tapable_1.SyncHook(['error', 'compilation']),
+        issues: new tapable_1.SyncWaterfallHook([
+            'issues',
+            'compilation',
+        ]),
+    };
+}
+function forwardForkTsCheckerWebpackPluginHooks(source, target) {
+    source.start.tapPromise('ForkTsCheckerWebpackPlugin', target.start.promise);
+    source.waiting.tap('ForkTsCheckerWebpackPlugin', target.waiting.call);
+    source.canceled.tap('ForkTsCheckerWebpackPlugin', target.canceled.call);
+    source.error.tap('ForkTsCheckerWebpackPlugin', target.error.call);
+    source.issues.tap('ForkTsCheckerWebpackPlugin', target.issues.call);
+}
+function getForkTsCheckerWebpackPluginHooks(compiler) {
+    let hooks = compilerHookMap.get(compiler);
+    if (hooks === undefined) {
+        hooks = createForkTsCheckerWebpackPluginHooks();
+        compilerHookMap.set(compiler, hooks);
+        // proxy hooks for multi-compiler
+        if ('compilers' in compiler) {
+            compiler.compilers.forEach((childCompiler) => {
+                const childHooks = getForkTsCheckerWebpackPluginHooks(childCompiler);
+                if (hooks) {
+                    forwardForkTsCheckerWebpackPluginHooks(childHooks, hooks);
+                }
+            });
+        }
+    }
+    return hooks;
+}
+exports.getForkTsCheckerWebpackPluginHooks = getForkTsCheckerWebpackPluginHooks;

node_modules/fork-ts-checker-webpack-plugin/lib/hooks/tapAfterCompileToAddDependencies.d.ts

@@ -0,0 +1,5 @@
+import webpack from 'webpack';
+import { ForkTsCheckerWebpackPluginConfiguration } from '../ForkTsCheckerWebpackPluginConfiguration';
+import { ForkTsCheckerWebpackPluginState } from '../ForkTsCheckerWebpackPluginState';
+declare function tapAfterCompileToAddDependencies(compiler: webpack.Compiler, configuration: ForkTsCheckerWebpackPluginConfiguration, state: ForkTsCheckerWebpackPluginState): void;
+export { tapAfterCompileToAddDependencies };

node_modules/fork-ts-checker-webpack-plugin/lib/hooks/tapAfterCompileToAddDependencies.js

@@ -0,0 +1,27 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+function tapAfterCompileToAddDependencies(compiler, configuration, state) {
+    compiler.hooks.afterCompile.tapPromise('ForkTsCheckerWebpackPlugin', (compilation) => __awaiter(this, void 0, void 0, function* () {
+        if (compilation.compiler !== compiler) {
+            // run only for the compiler that the plugin was registered for
+            return;
+        }
+        const dependencies = yield state.dependenciesPromise;
+        if (dependencies) {
+            state.lastDependencies = dependencies;
+            dependencies.files.forEach((file) => {
+                compilation.fileDependencies.add(file);
+            });
+        }
+    }));
+}
+exports.tapAfterCompileToAddDependencies = tapAfterCompileToAddDependencies;

node_modules/fork-ts-checker-webpack-plugin/lib/hooks/tapAfterCompileToGetIssues.d.ts

@@ -0,0 +1,5 @@
+import webpack from 'webpack';
+import { ForkTsCheckerWebpackPluginConfiguration } from '../ForkTsCheckerWebpackPluginConfiguration';
+import { ForkTsCheckerWebpackPluginState } from '../ForkTsCheckerWebpackPluginState';
+declare function tapAfterCompileToGetIssues(compiler: webpack.Compiler, configuration: ForkTsCheckerWebpackPluginConfiguration, state: ForkTsCheckerWebpackPluginState): void;
+export { tapAfterCompileToGetIssues };

node_modules/fork-ts-checker-webpack-plugin/lib/hooks/tapAfterCompileToGetIssues.js

@@ -0,0 +1,48 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const pluginHooks_1 = require("./pluginHooks");
+const IssueWebpackError_1 = require("../issue/IssueWebpackError");
+function tapAfterCompileToGetIssues(compiler, configuration, state) {
+    const hooks = pluginHooks_1.getForkTsCheckerWebpackPluginHooks(compiler);
+    compiler.hooks.afterCompile.tapPromise('ForkTsCheckerWebpackPlugin', (compilation) => __awaiter(this, void 0, void 0, function* () {
+        if (compilation.compiler !== compiler) {
+            // run only for the compiler that the plugin was registered for
+            return;
+        }
+        let issues = [];
+        try {
+            issues = yield state.issuesPromise;
+        }
+        catch (error) {
+            hooks.error.call(error, compilation);
+            return;
+        }
+        if (!issues) {
+            // some error has been thrown or it was canceled
+            return;
+        }
+        // filter list of issues by provided issue predicate
+        issues = issues.filter(configuration.issue.predicate);
+        // modify list of issues in the plugin hooks
+        issues = hooks.issues.call(issues, compilation);
+        issues.forEach((issue) => {
+            const error = new IssueWebpackError_1.IssueWebpackError(configuration.formatter(issue), issue);
+            if (issue.severity === 'warning') {
+                compilation.warnings.push(error);
+            }
+            else {
+                compilation.errors.push(error);
+            }
+        });
+    }));
+}
+exports.tapAfterCompileToGetIssues = tapAfterCompileToGetIssues;

node_modules/fork-ts-checker-webpack-plugin/lib/hooks/tapAfterEnvironmentToPatchWatching.d.ts

@@ -0,0 +1,4 @@
+import webpack from 'webpack';
+import { ForkTsCheckerWebpackPluginState } from '../ForkTsCheckerWebpackPluginState';
+declare function tapAfterEnvironmentToPatchWatching(compiler: webpack.Compiler, state: ForkTsCheckerWebpackPluginState): void;
+export { tapAfterEnvironmentToPatchWatching };

node_modules/fork-ts-checker-webpack-plugin/lib/hooks/tapAfterEnvironmentToPatchWatching.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const InclusiveNodeWatchFileSystem_1 = require("../watch/InclusiveNodeWatchFileSystem");
+function tapAfterEnvironmentToPatchWatching(compiler, state) {
+    compiler.hooks.afterEnvironment.tap('ForkTsCheckerWebpackPlugin', () => {
+        const watchFileSystem = compiler.watchFileSystem;
+        if (watchFileSystem) {
+            // wrap original watch file system
+            compiler.watchFileSystem = new InclusiveNodeWatchFileSystem_1.InclusiveNodeWatchFileSystem(watchFileSystem, compiler, state);
+        }
+    });
+}
+exports.tapAfterEnvironmentToPatchWatching = tapAfterEnvironmentToPatchWatching;

node_modules/fork-ts-checker-webpack-plugin/lib/hooks/tapDoneToAsyncGetIssues.d.ts

@@ -0,0 +1,5 @@
+import webpack from 'webpack';
+import { ForkTsCheckerWebpackPluginConfiguration } from '../ForkTsCheckerWebpackPluginConfiguration';
+import { ForkTsCheckerWebpackPluginState } from '../ForkTsCheckerWebpackPluginState';
+declare function tapDoneToAsyncGetIssues(compiler: webpack.Compiler, configuration: ForkTsCheckerWebpackPluginConfiguration, state: ForkTsCheckerWebpackPluginState): void;
+export { tapDoneToAsyncGetIssues };

node_modules/fork-ts-checker-webpack-plugin/lib/hooks/tapDoneToAsyncGetIssues.js

@@ -0,0 +1,85 @@
+"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 chalk_1 = __importDefault(require("chalk"));
+const pluginHooks_1 = require("./pluginHooks");
+const WebpackFormatter_1 = require("../formatter/WebpackFormatter");
+const IssueWebpackError_1 = require("../issue/IssueWebpackError");
+const isPending_1 = __importDefault(require("../utils/async/isPending"));
+const wait_1 = __importDefault(require("../utils/async/wait"));
+function tapDoneToAsyncGetIssues(compiler, configuration, state) {
+    const hooks = pluginHooks_1.getForkTsCheckerWebpackPluginHooks(compiler);
+    compiler.hooks.done.tap('ForkTsCheckerWebpackPlugin', (stats) => __awaiter(this, void 0, void 0, function* () {
+        if (stats.compilation.compiler !== compiler) {
+            // run only for the compiler that the plugin was registered for
+            return;
+        }
+        const reportPromise = state.issuesReportPromise;
+        const issuesPromise = state.issuesPromise;
+        let issues;
+        try {
+            if (yield isPending_1.default(issuesPromise)) {
+                hooks.waiting.call(stats.compilation);
+                configuration.logger.issues.log(chalk_1.default.cyan('Issues checking in progress...'));
+            }
+            else {
+                // wait 10ms to log issues after webpack stats
+                yield wait_1.default(10);
+            }
+            issues = yield issuesPromise;
+        }
+        catch (error) {
+            hooks.error.call(error, stats.compilation);
+            return;
+        }
+        if (!issues) {
+            // some error has been thrown or it was canceled
+            return;
+        }
+        if (reportPromise !== state.issuesReportPromise) {
+            // there is a newer report - ignore this one
+            return;
+        }
+        // filter list of issues by provided issue predicate
+        issues = issues.filter(configuration.issue.predicate);
+        // modify list of issues in the plugin hooks
+        issues = hooks.issues.call(issues, stats.compilation);
+        const formatter = WebpackFormatter_1.createWebpackFormatter(configuration.formatter);
+        if (issues.length) {
+            // follow webpack's approach - one process.write to stderr with all errors and warnings
+            configuration.logger.issues.error(issues.map((issue) => formatter(issue)).join('\n'));
+        }
+        else {
+            configuration.logger.issues.log(chalk_1.default.green('No issues found.'));
+        }
+        // report issues to webpack-dev-server, if it's listening
+        // skip reporting if there are no issues, to avoid an extra hot reload
+        if (issues.length && state.webpackDevServerDoneTap) {
+            issues.forEach((issue) => {
+                const error = new IssueWebpackError_1.IssueWebpackError(configuration.formatter(issue), issue);
+                if (issue.severity === 'warning') {
+                    stats.compilation.warnings.push(error);
+                }
+                else {
+                    stats.compilation.errors.push(error);
+                }
+            });
+            state.webpackDevServerDoneTap.fn(stats);
+        }
+        if (stats.startTime) {
+            configuration.logger.infrastructure.info(`Time: ${Math.round(Date.now() - stats.startTime).toString()} ms`);
+        }
+    }));
+}
+exports.tapDoneToAsyncGetIssues = tapDoneToAsyncGetIssues;

node_modules/fork-ts-checker-webpack-plugin/lib/hooks/tapErrorToLogMessage.d.ts

@@ -0,0 +1,4 @@
+import webpack from 'webpack';
+import { ForkTsCheckerWebpackPluginConfiguration } from '../ForkTsCheckerWebpackPluginConfiguration';
+declare function tapErrorToLogMessage(compiler: webpack.Compiler, configuration: ForkTsCheckerWebpackPluginConfiguration): void;
+export { tapErrorToLogMessage };

node_modules/fork-ts-checker-webpack-plugin/lib/hooks/tapErrorToLogMessage.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const pluginHooks_1 = require("./pluginHooks");
+const RpcIpcMessagePortClosedError_1 = require("../rpc/rpc-ipc/error/RpcIpcMessagePortClosedError");
+const chalk_1 = __importDefault(require("chalk"));
+function tapErrorToLogMessage(compiler, configuration) {
+    const hooks = pluginHooks_1.getForkTsCheckerWebpackPluginHooks(compiler);
+    hooks.error.tap('ForkTsCheckerWebpackPlugin', (error) => {
+        configuration.logger.issues.error(String(error));
+        if (error instanceof RpcIpcMessagePortClosedError_1.RpcIpcMessagePortClosedError) {
+            if (error.signal === 'SIGINT') {
+                configuration.logger.issues.error(chalk_1.default.red('Issues checking service interrupted - If running in a docker container, this may be caused ' +
+                    "by the container running out of memory. If so, try increasing the container's memory limit " +
+                    'or lowering the `memoryLimit` value in the ForkTsCheckerWebpackPlugin configuration.'));
+            }
+            else {
+                configuration.logger.issues.error(chalk_1.default.red('Issues checking service aborted - probably out of memory. ' +
+                    'Check the `memoryLimit` option in the ForkTsCheckerWebpackPlugin configuration.\n' +
+                    "If increasing the memory doesn't solve the issue, it's most probably a bug in the TypeScript or EsLint."));
+            }
+        }
+    });
+}
+exports.tapErrorToLogMessage = tapErrorToLogMessage;

node_modules/fork-ts-checker-webpack-plugin/lib/hooks/tapStartToConnectAndRunReporter.d.ts

@@ -0,0 +1,6 @@
+import webpack from 'webpack';
+import { ForkTsCheckerWebpackPluginConfiguration } from '../ForkTsCheckerWebpackPluginConfiguration';
+import { ForkTsCheckerWebpackPluginState } from '../ForkTsCheckerWebpackPluginState';
+import { ReporterRpcClient } from '../reporter';
+declare function tapStartToConnectAndRunReporter(compiler: webpack.Compiler, issuesReporter: ReporterRpcClient, dependenciesReporter: ReporterRpcClient, configuration: ForkTsCheckerWebpackPluginConfiguration, state: ForkTsCheckerWebpackPluginState): void;
+export { tapStartToConnectAndRunReporter };

node_modules/fork-ts-checker-webpack-plugin/lib/hooks/tapStartToConnectAndRunReporter.js

@@ -0,0 +1,125 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const pluginHooks_1 = require("./pluginHooks");
+const reporter_1 = require("../reporter");
+const OperationCanceledError_1 = require("../error/OperationCanceledError");
+const tapDoneToAsyncGetIssues_1 = require("./tapDoneToAsyncGetIssues");
+const tapAfterCompileToGetIssues_1 = require("./tapAfterCompileToGetIssues");
+const interceptDoneToGetWebpackDevServerTap_1 = require("./interceptDoneToGetWebpackDevServerTap");
+const ForkTsCheckerWebpackPlugin_1 = require("../ForkTsCheckerWebpackPlugin");
+function tapStartToConnectAndRunReporter(compiler, issuesReporter, dependenciesReporter, configuration, state) {
+    const hooks = pluginHooks_1.getForkTsCheckerWebpackPluginHooks(compiler);
+    compiler.hooks.run.tap('ForkTsCheckerWebpackPlugin', () => {
+        if (!state.initialized) {
+            state.initialized = true;
+            state.watching = false;
+            tapAfterCompileToGetIssues_1.tapAfterCompileToGetIssues(compiler, configuration, state);
+        }
+    });
+    compiler.hooks.watchRun.tap('ForkTsCheckerWebpackPlugin', () => __awaiter(this, void 0, void 0, function* () {
+        if (!state.initialized) {
+            state.initialized = true;
+            state.watching = true;
+            if (configuration.async) {
+                tapDoneToAsyncGetIssues_1.tapDoneToAsyncGetIssues(compiler, configuration, state);
+                interceptDoneToGetWebpackDevServerTap_1.interceptDoneToGetWebpackDevServerTap(compiler, configuration, state);
+            }
+            else {
+                tapAfterCompileToGetIssues_1.tapAfterCompileToGetIssues(compiler, configuration, state);
+            }
+        }
+    }));
+    compiler.hooks.compilation.tap('ForkTsCheckerWebpackPlugin', (compilation) => __awaiter(this, void 0, void 0, function* () {
+        if (compilation.compiler !== compiler) {
+            // run only for the compiler that the plugin was registered for
+            return;
+        }
+        let change = {};
+        if (state.watching) {
+            change = reporter_1.getFilesChange(compiler);
+            configuration.logger.infrastructure.info([
+                'Calling reporter service for incremental check.',
+                `  Changed files: ${JSON.stringify(change.changedFiles)}`,
+                `  Deleted files: ${JSON.stringify(change.deletedFiles)}`,
+            ].join('\n'));
+        }
+        else {
+            configuration.logger.infrastructure.info('Calling reporter service for single check.');
+        }
+        let resolveDependencies;
+        let rejectDependencies;
+        let resolveIssues;
+        let rejectIssues;
+        state.dependenciesPromise = new Promise((resolve, reject) => {
+            resolveDependencies = resolve;
+            rejectDependencies = reject;
+        });
+        state.issuesPromise = new Promise((resolve, reject) => {
+            resolveIssues = resolve;
+            rejectIssues = reject;
+        });
+        const previousIssuesReportPromise = state.issuesReportPromise;
+        const previousDependenciesReportPromise = state.dependenciesReportPromise;
+        change = yield hooks.start.promise(change, compilation);
+        state.issuesReportPromise = ForkTsCheckerWebpackPlugin_1.ForkTsCheckerWebpackPlugin.issuesPool.submit((done) => new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield issuesReporter.connect();
+                const previousReport = yield previousIssuesReportPromise;
+                if (previousReport) {
+                    yield previousReport.close();
+                }
+                const report = yield issuesReporter.getReport(change);
+                resolve(report);
+                report.getIssues().then(resolveIssues).catch(rejectIssues).finally(done);
+            }
+            catch (error) {
+                if (error instanceof OperationCanceledError_1.OperationCanceledError) {
+                    hooks.canceled.call(compilation);
+                }
+                else {
+                    hooks.error.call(error, compilation);
+                }
+                resolve(undefined);
+                resolveIssues(undefined);
+                done();
+            }
+        })));
+        state.dependenciesReportPromise = ForkTsCheckerWebpackPlugin_1.ForkTsCheckerWebpackPlugin.dependenciesPool.submit((done) => new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield dependenciesReporter.connect();
+                const previousReport = yield previousDependenciesReportPromise;
+                if (previousReport) {
+                    yield previousReport.close();
+                }
+                const report = yield dependenciesReporter.getReport(change);
+                resolve(report);
+                report
+                    .getDependencies()
+                    .then(resolveDependencies)
+                    .catch(rejectDependencies)
+                    .finally(done);
+            }
+            catch (error) {
+                if (error instanceof OperationCanceledError_1.OperationCanceledError) {
+                    hooks.canceled.call(compilation);
+                }
+                else {
+                    hooks.error.call(error, compilation);
+                }
+                resolve(undefined);
+                resolveDependencies(undefined);
+                done();
+            }
+        })));
+    }));
+}
+exports.tapStartToConnectAndRunReporter = tapStartToConnectAndRunReporter;

node_modules/fork-ts-checker-webpack-plugin/lib/hooks/tapStopToDisconnectReporter.d.ts

@@ -0,0 +1,5 @@
+import webpack from 'webpack';
+import { ForkTsCheckerWebpackPluginState } from '../ForkTsCheckerWebpackPluginState';
+import { ReporterRpcClient } from '../reporter';
+declare function tapStopToDisconnectReporter(compiler: webpack.Compiler, issuesReporter: ReporterRpcClient, dependenciesReporter: ReporterRpcClient, state: ForkTsCheckerWebpackPluginState): void;
+export { tapStopToDisconnectReporter };

node_modules/fork-ts-checker-webpack-plugin/lib/hooks/tapStopToDisconnectReporter.js

@@ -0,0 +1,29 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+function tapStopToDisconnectReporter(compiler, issuesReporter, dependenciesReporter, state) {
+    compiler.hooks.watchClose.tap('ForkTsCheckerWebpackPlugin', () => {
+        issuesReporter.disconnect();
+        dependenciesReporter.disconnect();
+    });
+    compiler.hooks.done.tap('ForkTsCheckerWebpackPlugin', () => __awaiter(this, void 0, void 0, function* () {
+        if (!state.watching) {
+            yield Promise.all([issuesReporter.disconnect(), dependenciesReporter.disconnect()]);
+        }
+    }));
+    compiler.hooks.failed.tap('ForkTsCheckerWebpackPlugin', () => {
+        if (!state.watching) {
+            issuesReporter.disconnect();
+            dependenciesReporter.disconnect();
+        }
+    });
+}
+exports.tapStopToDisconnectReporter = tapStopToDisconnectReporter;

node_modules/fork-ts-checker-webpack-plugin/lib/index.d.ts

@@ -0,0 +1,2 @@
+import { ForkTsCheckerWebpackPlugin } from './ForkTsCheckerWebpackPlugin';
+export = ForkTsCheckerWebpackPlugin;

node_modules/fork-ts-checker-webpack-plugin/lib/index.js

@@ -0,0 +1,3 @@
+"use strict";
+const ForkTsCheckerWebpackPlugin_1 = require("./ForkTsCheckerWebpackPlugin");
+module.exports = ForkTsCheckerWebpackPlugin_1.ForkTsCheckerWebpackPlugin;

node_modules/fork-ts-checker-webpack-plugin/lib/issue/Issue.d.ts

@@ -0,0 +1,13 @@
+import { IssueSeverity } from './IssueSeverity';
+import { IssueLocation } from './IssueLocation';
+interface Issue {
+    origin: string;
+    severity: IssueSeverity;
+    code: string;
+    message: string;
+    file?: string;
+    location?: IssueLocation;
+}
+declare function isIssue(value: unknown): value is Issue;
+declare function deduplicateAndSortIssues(issues: Issue[]): Issue[];
+export { Issue, isIssue, deduplicateAndSortIssues };

node_modules/fork-ts-checker-webpack-plugin/lib/issue/Issue.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const IssueSeverity_1 = require("./IssueSeverity");
+const IssueLocation_1 = require("./IssueLocation");
+function isIssue(value) {
+    return (!!value &&
+        typeof value === 'object' &&
+        !!value.origin &&
+        IssueSeverity_1.isIssueSeverity(value.severity) &&
+        !!value.code &&
+        !!value.message);
+}
+exports.isIssue = isIssue;
+function compareStrings(stringA, stringB) {
+    if (stringA === stringB) {
+        return 0;
+    }
+    if (stringA === undefined || stringA === null) {
+        return -1;
+    }
+    if (stringB === undefined || stringB === null) {
+        return 1;
+    }
+    return stringA.toString().localeCompare(stringB.toString());
+}
+function compareIssues(issueA, issueB) {
+    return (IssueSeverity_1.compareIssueSeverities(issueA.severity, issueB.severity) ||
+        compareStrings(issueA.origin, issueB.origin) ||
+        compareStrings(issueA.file, issueB.file) ||
+        IssueLocation_1.compareIssueLocations(issueA.location, issueB.location) ||
+        compareStrings(issueA.code, issueB.code) ||
+        compareStrings(issueA.message, issueB.message) ||
+        0 /* EqualTo */);
+}
+function equalsIssues(issueA, issueB) {
+    return compareIssues(issueA, issueB) === 0;
+}
+function deduplicateAndSortIssues(issues) {
+    const sortedIssues = issues.filter(isIssue).sort(compareIssues);
+    return sortedIssues.filter((issue, index) => index === 0 || !equalsIssues(issue, sortedIssues[index - 1]));
+}
+exports.deduplicateAndSortIssues = deduplicateAndSortIssues;

node_modules/fork-ts-checker-webpack-plugin/lib/issue/IssueConfiguration.d.ts

@@ -0,0 +1,8 @@
+import webpack from 'webpack';
+import { IssuePredicate } from './IssuePredicate';
+import { IssueOptions } from './IssueOptions';
+interface IssueConfiguration {
+    predicate: IssuePredicate;
+}
+declare function createIssueConfiguration(compiler: webpack.Compiler, options: IssueOptions | undefined): IssueConfiguration;
+export { IssueConfiguration, createIssueConfiguration };

node_modules/fork-ts-checker-webpack-plugin/lib/issue/IssueConfiguration.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const IssueMatch_1 = require("./IssueMatch");
+const IssuePredicate_1 = require("./IssuePredicate");
+function createIssuePredicateFromOption(context, option) {
+    if (Array.isArray(option)) {
+        return IssuePredicate_1.composeIssuePredicates(option.map((option) => typeof option === 'function' ? option : IssueMatch_1.createIssuePredicateFromIssueMatch(context, option)));
+    }
+    return typeof option === 'function'
+        ? option
+        : IssueMatch_1.createIssuePredicateFromIssueMatch(context, option);
+}
+function createIssueConfiguration(compiler, options) {
+    const context = compiler.options.context || process.cwd();
+    if (!options) {
+        options = {};
+    }
+    const include = options.include
+        ? createIssuePredicateFromOption(context, options.include)
+        : IssuePredicate_1.createTrivialIssuePredicate(true);
+    const exclude = options.exclude
+        ? createIssuePredicateFromOption(context, options.exclude)
+        : IssuePredicate_1.createTrivialIssuePredicate(false);
+    return {
+        predicate: (issue) => include(issue) && !exclude(issue),
+    };
+}
+exports.createIssueConfiguration = createIssueConfiguration;

node_modules/fork-ts-checker-webpack-plugin/lib/issue/IssueLocation.d.ts

@@ -0,0 +1,8 @@
+import { IssuePosition } from './IssuePosition';
+interface IssueLocation {
+    start: IssuePosition;
+    end: IssuePosition;
+}
+declare function compareIssueLocations(locationA?: IssueLocation, locationB?: IssueLocation): number;
+declare function formatIssueLocation(location: IssueLocation): string;
+export { IssueLocation, compareIssueLocations, formatIssueLocation };

node_modules/fork-ts-checker-webpack-plugin/lib/issue/IssueLocation.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const IssuePosition_1 = require("./IssuePosition");
+function compareIssueLocations(locationA, locationB) {
+    if (locationA === locationB) {
+        return 0;
+    }
+    if (!locationA) {
+        return -1;
+    }
+    if (!locationB) {
+        return 1;
+    }
+    return (IssuePosition_1.compareIssuePositions(locationA.start, locationB.start) ||
+        IssuePosition_1.compareIssuePositions(locationA.end, locationB.end));
+}
+exports.compareIssueLocations = compareIssueLocations;
+function formatIssueLocation(location) {
+    return `${location.start.line}:${location.start.column}`;
+}
+exports.formatIssueLocation = formatIssueLocation;

node_modules/fork-ts-checker-webpack-plugin/lib/issue/IssueMatch.d.ts

@@ -0,0 +1,5 @@
+import { Issue } from './index';
+import { IssuePredicate } from './IssuePredicate';
+declare type IssueMatch = Partial<Pick<Issue, 'origin' | 'severity' | 'code' | 'file'>>;
+declare function createIssuePredicateFromIssueMatch(context: string, match: IssueMatch): IssuePredicate;
+export { IssueMatch, createIssuePredicateFromIssueMatch };

node_modules/fork-ts-checker-webpack-plugin/lib/issue/IssueMatch.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const minimatch_1 = __importDefault(require("minimatch"));
+const path_1 = __importDefault(require("path"));
+const forwardSlash_1 = __importDefault(require("../utils/path/forwardSlash"));
+function createIssuePredicateFromIssueMatch(context, match) {
+    return (issue) => {
+        const matchesOrigin = !match.origin || match.origin === issue.origin;
+        const matchesSeverity = !match.severity || match.severity === issue.severity;
+        const matchesCode = !match.code || match.code === issue.code;
+        const matchesFile = !issue.file ||
+            (!!issue.file &&
+                (!match.file || minimatch_1.default(forwardSlash_1.default(path_1.default.relative(context, issue.file)), match.file)));
+        return matchesOrigin && matchesSeverity && matchesCode && matchesFile;
+    };
+}
+exports.createIssuePredicateFromIssueMatch = createIssuePredicateFromIssueMatch;

node_modules/fork-ts-checker-webpack-plugin/lib/issue/IssueOptions.d.ts

@@ -0,0 +1,8 @@
+import { IssueMatch } from './IssueMatch';
+import { IssuePredicate } from './IssuePredicate';
+declare type IssuePredicateOption = IssuePredicate | IssueMatch | (IssuePredicate | IssueMatch)[];
+interface IssueOptions {
+    include?: IssuePredicateOption;
+    exclude?: IssuePredicateOption;
+}
+export { IssueOptions, IssuePredicateOption };

node_modules/fork-ts-checker-webpack-plugin/lib/issue/IssueOptions.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

node_modules/fork-ts-checker-webpack-plugin/lib/issue/IssuePosition.d.ts

@@ -0,0 +1,6 @@
+interface IssuePosition {
+    line: number;
+    column: number;
+}
+declare function compareIssuePositions(positionA?: IssuePosition, positionB?: IssuePosition): number;
+export { IssuePosition, compareIssuePositions };

node_modules/fork-ts-checker-webpack-plugin/lib/issue/IssuePosition.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function compareIssuePositions(positionA, positionB) {
+    if (positionA === positionB) {
+        return 0;
+    }
+    if (!positionA) {
+        return -1;
+    }
+    if (!positionB) {
+        return 1;
+    }
+    return (Math.sign(positionA.line - positionB.line) || Math.sign(positionA.column - positionB.column));
+}
+exports.compareIssuePositions = compareIssuePositions;

node_modules/fork-ts-checker-webpack-plugin/lib/issue/IssuePredicate.d.ts

@@ -0,0 +1,5 @@
+import { Issue } from './index';
+declare type IssuePredicate = (issue: Issue) => boolean;
+declare function createTrivialIssuePredicate(result: boolean): IssuePredicate;
+declare function composeIssuePredicates(predicates: IssuePredicate[]): IssuePredicate;
+export { IssuePredicate, createTrivialIssuePredicate, composeIssuePredicates };

node_modules/fork-ts-checker-webpack-plugin/lib/issue/IssuePredicate.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function createTrivialIssuePredicate(result) {
+    return () => result;
+}
+exports.createTrivialIssuePredicate = createTrivialIssuePredicate;
+function composeIssuePredicates(predicates) {
+    return (issue) => predicates.some((predicate) => predicate(issue));
+}
+exports.composeIssuePredicates = composeIssuePredicates;

node_modules/fork-ts-checker-webpack-plugin/lib/issue/IssueSeverity.d.ts

@@ -0,0 +1,4 @@
+declare type IssueSeverity = 'error' | 'warning';
+declare function isIssueSeverity(value: unknown): value is IssueSeverity;
+declare function compareIssueSeverities(severityA: IssueSeverity, severityB: IssueSeverity): number;
+export { IssueSeverity, isIssueSeverity, compareIssueSeverities };

node_modules/fork-ts-checker-webpack-plugin/lib/issue/IssueSeverity.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function isIssueSeverity(value) {
+    return ['error', 'warning'].includes(value);
+}
+exports.isIssueSeverity = isIssueSeverity;
+function compareIssueSeverities(severityA, severityB) {
+    const [priorityA, priorityB] = [severityA, severityB].map((severity) => ['warning' /* 0 */, 'error' /* 1 */].indexOf(severity));
+    return Math.sign(priorityB - priorityA);
+}
+exports.compareIssueSeverities = compareIssueSeverities;

node_modules/fork-ts-checker-webpack-plugin/lib/issue/IssueWebpackError.d.ts

@@ -0,0 +1,8 @@
+import { Issue } from './Issue';
+declare class IssueWebpackError extends Error {
+    readonly issue: Issue;
+    readonly hideStack = true;
+    readonly file: string | undefined;
+    constructor(message: string, issue: Issue);
+}
+export { IssueWebpackError };

node_modules/fork-ts-checker-webpack-plugin/lib/issue/IssueWebpackError.js

@@ -0,0 +1,26 @@
+"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 IssueLocation_1 = require("./IssueLocation");
+const forwardSlash_1 = __importDefault(require("../utils/path/forwardSlash"));
+class IssueWebpackError extends Error {
+    constructor(message, issue) {
+        super(message);
+        this.issue = issue;
+        this.hideStack = true;
+        // to display issue location using `loc` property, webpack requires `error.module` which
+        // should be a NormalModule instance.
+        // to avoid such a dependency, we do a workaround - error.file will contain formatted location instead
+        if (issue.file) {
+            this.file = forwardSlash_1.default(path_1.relative(process.cwd(), issue.file));
+            if (issue.location) {
+                this.file += `:${IssueLocation_1.formatIssueLocation(issue.location)}`;
+            }
+        }
+        Error.captureStackTrace(this, this.constructor);
+    }
+}
+exports.IssueWebpackError = IssueWebpackError;

node_modules/fork-ts-checker-webpack-plugin/lib/issue/index.d.ts

@@ -0,0 +1,3 @@
+export * from './Issue';
+export * from './IssueSeverity';
+export * from './IssueLocation';

node_modules/fork-ts-checker-webpack-plugin/lib/issue/index.js

@@ -0,0 +1,8 @@
+"use strict";
+function __export(m) {
+    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+__export(require("./Issue"));
+__export(require("./IssueSeverity"));
+__export(require("./IssueLocation"));

node_modules/fork-ts-checker-webpack-plugin/lib/logger/Logger.d.ts

@@ -0,0 +1,6 @@
+interface Logger {
+    info: (message: string) => void;
+    log: (message: string) => void;
+    error: (message: string) => void;
+}
+export default Logger;

node_modules/fork-ts-checker-webpack-plugin/lib/logger/Logger.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

node_modules/fork-ts-checker-webpack-plugin/lib/logger/LoggerConfiguration.d.ts

@@ -0,0 +1,10 @@
+import LoggerOptions from './LoggerOptions';
+import Logger from './Logger';
+import webpack from 'webpack';
+interface LoggerConfiguration {
+    infrastructure: Logger;
+    issues: Logger;
+    devServer: boolean;
+}
+declare function createLoggerConfiguration(compiler: webpack.Compiler, options: LoggerOptions | undefined): LoggerConfiguration;
+export { LoggerConfiguration, createLoggerConfiguration };

node_modules/fork-ts-checker-webpack-plugin/lib/logger/LoggerConfiguration.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const LoggerFactory_1 = require("./LoggerFactory");
+function createLoggerConfiguration(compiler, options) {
+    return {
+        infrastructure: LoggerFactory_1.createLogger((options && options.infrastructure) || 'silent', compiler),
+        issues: LoggerFactory_1.createLogger((options && options.issues) || 'console', compiler),
+        devServer: (options === null || options === void 0 ? void 0 : options.devServer) !== false,
+    };
+}
+exports.createLoggerConfiguration = createLoggerConfiguration;

node_modules/fork-ts-checker-webpack-plugin/lib/logger/LoggerFactory.d.ts

@@ -0,0 +1,5 @@
+import webpack from 'webpack';
+import Logger from './Logger';
+declare type LoggerType = 'console' | 'webpack-infrastructure' | 'silent';
+declare function createLogger(type: LoggerType | Logger, compiler: webpack.Compiler): Logger;
+export { createLogger, LoggerType };

node_modules/fork-ts-checker-webpack-plugin/lib/logger/LoggerFactory.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const WebpackInfrastructureLogger_1 = require("./WebpackInfrastructureLogger");
+const PartialLogger_1 = require("./PartialLogger");
+function createLogger(type, compiler) {
+    if (typeof type !== 'string') {
+        return type;
+    }
+    switch (type) {
+        case 'webpack-infrastructure':
+            return (WebpackInfrastructureLogger_1.createWebpackInfrastructureLogger(compiler) ||
+                PartialLogger_1.createPartialLogger(['log', 'error'], console));
+        case 'silent':
+            return PartialLogger_1.createPartialLogger([], console);
+        case 'console':
+        default:
+            return console;
+    }
+}
+exports.createLogger = createLogger;

node_modules/fork-ts-checker-webpack-plugin/lib/logger/LoggerOptions.d.ts

@@ -0,0 +1,8 @@
+import { LoggerType } from './LoggerFactory';
+import Logger from './Logger';
+declare type LoggerOptions = {
+    infrastructure?: LoggerType | Logger;
+    issues?: LoggerType | Logger;
+    devServer?: boolean;
+};
+export default LoggerOptions;

node_modules/fork-ts-checker-webpack-plugin/lib/logger/LoggerOptions.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

node_modules/fork-ts-checker-webpack-plugin/lib/logger/PartialLogger.d.ts

@@ -0,0 +1,4 @@
+import Logger from './Logger';
+declare type LoggerMethods = 'info' | 'log' | 'error';
+declare function createPartialLogger(methods: LoggerMethods[], logger: Logger): Logger;
+export { createPartialLogger };

node_modules/fork-ts-checker-webpack-plugin/lib/logger/PartialLogger.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function createPartialLogger(methods, logger) {
+    return {
+        info: (message) => (methods.includes('info') ? logger.info(message) : undefined),
+        log: (message) => (methods.includes('log') ? logger.log(message) : undefined),
+        error: (message) => (methods.includes('error') ? logger.error(message) : undefined),
+    };
+}
+exports.createPartialLogger = createPartialLogger;

node_modules/fork-ts-checker-webpack-plugin/lib/logger/WebpackInfrastructureLogger.d.ts

@@ -0,0 +1,4 @@
+import webpack from 'webpack';
+import Logger from './Logger';
+declare function createWebpackInfrastructureLogger(compiler: webpack.Compiler): Logger | undefined;
+export { createWebpackInfrastructureLogger };

node_modules/fork-ts-checker-webpack-plugin/lib/logger/WebpackInfrastructureLogger.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function isInfrastructureLoggerProvider(candidate) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return !!candidate.getInfrastructureLogger;
+}
+function createWebpackInfrastructureLogger(compiler) {
+    return isInfrastructureLoggerProvider(compiler)
+        ? compiler.getInfrastructureLogger('ForkTsCheckerWebpackPlugin')
+        : undefined;
+}
+exports.createWebpackInfrastructureLogger = createWebpackInfrastructureLogger;

node_modules/fork-ts-checker-webpack-plugin/lib/profile/Performance.d.ts

@@ -0,0 +1,11 @@
+interface Performance {
+    enable(): void;
+    disable(): void;
+    mark(name: string): void;
+    markStart(name: string): void;
+    markEnd(name: string): void;
+    measure(name: string, startMark?: string, endMark?: string): void;
+    print(): void;
+}
+declare function createPerformance(): Performance;
+export { Performance, createPerformance };

node_modules/fork-ts-checker-webpack-plugin/lib/profile/Performance.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const perf_hooks_1 = require("perf_hooks");
+function createPerformance() {
+    let enabled = false;
+    let timeOrigin;
+    let marks;
+    let measurements;
+    function enable() {
+        enabled = true;
+        marks = new Map();
+        measurements = new Map();
+        timeOrigin = perf_hooks_1.performance.now();
+    }
+    function disable() {
+        enabled = false;
+    }
+    function mark(name) {
+        if (enabled) {
+            marks.set(name, perf_hooks_1.performance.now());
+        }
+    }
+    function measure(name, startMark, endMark) {
+        if (enabled) {
+            const start = (startMark && marks.get(startMark)) || timeOrigin;
+            const end = (endMark && marks.get(endMark)) || perf_hooks_1.performance.now();
+            measurements.set(name, (measurements.get(name) || 0) + (end - start));
+        }
+    }
+    function markStart(name) {
+        if (enabled) {
+            mark(`${name} start`);
+        }
+    }
+    function markEnd(name) {
+        if (enabled) {
+            mark(`${name} end`);
+            measure(name, `${name} start`, `${name} end`);
+        }
+    }
+    function formatName(name, width = 0) {
+        return `${name}:`.padEnd(width);
+    }
+    function formatDuration(duration, width = 0) {
+        return `${(duration / 1000).toFixed(2)} s`.padStart(width);
+    }
+    function print() {
+        if (enabled) {
+            let nameWidth = 0;
+            let durationWidth = 0;
+            measurements.forEach((duration, name) => {
+                nameWidth = Math.max(nameWidth, formatName(name).length);
+                durationWidth = Math.max(durationWidth, formatDuration(duration).length);
+            });
+            measurements.forEach((duration, name) => {
+                console.log(`${formatName(name, nameWidth)} ${formatDuration(duration, durationWidth)}`);
+            });
+        }
+    }
+    return { enable, disable, mark, markStart, markEnd, measure, print };
+}
+exports.createPerformance = createPerformance;

node_modules/fork-ts-checker-webpack-plugin/lib/reporter/AggregatedReporter.d.ts

@@ -0,0 +1,6 @@
+import { Reporter } from './Reporter';
+/**
+ * This higher order reporter aggregates too frequent getReport requests to avoid unnecessary computation.
+ */
+declare function createAggregatedReporter<TReporter extends Reporter>(reporter: TReporter): TReporter;
+export { createAggregatedReporter };