up n_m

node_modules/fork-ts-checker-webpack-plugin/lib/utils/array/flatten.d.ts

@@ -0,0 +1,2 @@
+declare function flatten<T>(matrix: T[][]): T[];
+export default flatten;

node_modules/fork-ts-checker-webpack-plugin/lib/utils/array/flatten.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function flatten(matrix) {
+    return matrix.reduce((flatten, array) => flatten.concat(array), []);
+}
+exports.default = flatten;

node_modules/fork-ts-checker-webpack-plugin/lib/utils/array/intersect.d.ts

@@ -0,0 +1,2 @@
+declare function intersect<T>(arrayA?: T[], arrayB?: T[]): T[];
+export default intersect;

node_modules/fork-ts-checker-webpack-plugin/lib/utils/array/intersect.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function intersect(arrayA = [], arrayB = []) {
+    return arrayA.filter((item) => arrayB.includes(item));
+}
+exports.default = intersect;

node_modules/fork-ts-checker-webpack-plugin/lib/utils/array/substract.d.ts

@@ -0,0 +1,2 @@
+declare function subtract<T>(arrayA?: T[], arrayB?: T[]): T[];
+export default subtract;

node_modules/fork-ts-checker-webpack-plugin/lib/utils/array/substract.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function subtract(arrayA = [], arrayB = []) {
+    return arrayA.filter((item) => !arrayB.includes(item));
+}
+exports.default = subtract;

node_modules/fork-ts-checker-webpack-plugin/lib/utils/array/unique.d.ts

@@ -0,0 +1,2 @@
+declare function unique<T>(array: T[]): T[];
+export default unique;

node_modules/fork-ts-checker-webpack-plugin/lib/utils/array/unique.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function unique(array) {
+    return Array.from(new Set(array));
+}
+exports.default = unique;

node_modules/fork-ts-checker-webpack-plugin/lib/utils/async/isPending.d.ts

@@ -0,0 +1,2 @@
+declare function isPending(promise: Promise<unknown>, timeout?: number): Promise<unknown>;
+export default isPending;

node_modules/fork-ts-checker-webpack-plugin/lib/utils/async/isPending.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function isPending(promise, timeout = 100) {
+    return Promise.race([
+        promise.then(() => false).catch(() => false),
+        new Promise((resolve) => setTimeout(() => resolve(true), timeout)),
+    ]);
+}
+exports.default = isPending;

node_modules/fork-ts-checker-webpack-plugin/lib/utils/async/pool.d.ts

@@ -0,0 +1,8 @@
+declare type Task<T> = (done: () => void) => Promise<T>;
+interface Pool {
+    submit<T>(task: Task<T>): Promise<T>;
+    size: number;
+    readonly pending: number;
+}
+declare function createPool(size: number): Pool;
+export { Pool, createPool };

node_modules/fork-ts-checker-webpack-plugin/lib/utils/async/pool.js

@@ -0,0 +1,45 @@
+"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 createPool(size) {
+    let pendingPromises = [];
+    const pool = {
+        submit(task) {
+            return __awaiter(this, void 0, void 0, function* () {
+                while (pendingPromises.length >= pool.size) {
+                    yield Promise.race(pendingPromises).catch(() => undefined);
+                }
+                let resolve;
+                let reject;
+                const taskPromise = new Promise((taskResolve, taskReject) => {
+                    resolve = taskResolve;
+                    reject = taskReject;
+                });
+                const donePromise = new Promise((doneResolve) => {
+                    task(() => {
+                        doneResolve(undefined);
+                        pendingPromises = pendingPromises.filter((pendingPromise) => pendingPromise !== donePromise);
+                    })
+                        .then(resolve)
+                        .catch(reject);
+                });
+                pendingPromises.push(donePromise);
+                return taskPromise;
+            });
+        },
+        size,
+        get pending() {
+            return pendingPromises.length;
+        },
+    };
+    return pool;
+}
+exports.createPool = createPool;

node_modules/fork-ts-checker-webpack-plugin/lib/utils/async/wait.d.ts

@@ -0,0 +1,2 @@
+declare function wait(timeout: number): Promise<unknown>;
+export default wait;

node_modules/fork-ts-checker-webpack-plugin/lib/utils/async/wait.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function wait(timeout) {
+    return new Promise((resolve) => setTimeout(resolve, timeout));
+}
+exports.default = wait;

node_modules/fork-ts-checker-webpack-plugin/lib/utils/path/forwardSlash.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Replaces backslashes with one forward slash
+ * @param input
+ */
+declare function forwardSlash(input: string): string;
+export default forwardSlash;

node_modules/fork-ts-checker-webpack-plugin/lib/utils/path/forwardSlash.js

@@ -0,0 +1,14 @@
+"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"));
+/**
+ * Replaces backslashes with one forward slash
+ * @param input
+ */
+function forwardSlash(input) {
+    return path_1.default.normalize(input).replace(/\\+/g, '/');
+}
+exports.default = forwardSlash;