xhs-mp-pack 1.1.0-beta.0

package/dist/template/Template.js

@@ -0,0 +1,269 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Template = exports.NUMBER_OF_IDENTIFIER_CONTINUATION_CHARS = exports.NUMBER_OF_IDENTIFIER_START_CHARS = void 0;
+const webpack_sources_1 = require("webpack-sources");
+const ModuleTypeConstants_1 = require("@/module/ModuleTypeConstants");
+const RuntimeGlobals = __importStar(require("@/module/RuntimeGlobals"));
+const START_LOWERCASE_ALPHABET_CODE = 'a'.charCodeAt(0);
+const START_UPPERCASE_ALPHABET_CODE = 'A'.charCodeAt(0);
+const DELTA_A_TO_Z = 'z'.charCodeAt(0) - START_LOWERCASE_ALPHABET_CODE + 1;
+const NUMBER_OF_IDENTIFIER_START_CHARS = DELTA_A_TO_Z * 2 + 2; // a-z A-Z _ $
+exports.NUMBER_OF_IDENTIFIER_START_CHARS = NUMBER_OF_IDENTIFIER_START_CHARS;
+const NUMBER_OF_IDENTIFIER_CONTINUATION_CHARS = NUMBER_OF_IDENTIFIER_START_CHARS + 10; // a-z A-Z _ $ 0-9
+exports.NUMBER_OF_IDENTIFIER_CONTINUATION_CHARS = NUMBER_OF_IDENTIFIER_CONTINUATION_CHARS;
+const FUNCTION_CONTENT_REGEX = /^function\s?\(\)\s?\{\r?\n?|\r?\n?\}$/g;
+const INDENT_MULTILINE_REGEX = /^\t/gm;
+const LINE_SEPARATOR_REGEX = /\r?\n/g;
+const IDENTIFIER_NAME_REPLACE_REGEX = /^([^a-zA-Z$_])/;
+const IDENTIFIER_ALPHA_NUMERIC_NAME_REPLACE_REGEX = /[^a-zA-Z0-9$]+/g;
+const COMMENT_END_REGEX = /\*\//g;
+const PATH_NAME_NORMALIZE_REPLACE_REGEX = /[^a-zA-Z0-9_!§$()=\-^°]+/g;
+const MATCH_PADDED_HYPHENS_REPLACE_REGEX = /^-|-$/g;
+class Template {
+    static getFunctionContent(fn) {
+        return fn
+            .toString()
+            .replace(FUNCTION_CONTENT_REGEX, '')
+            .replace(INDENT_MULTILINE_REGEX, '')
+            .replace(LINE_SEPARATOR_REGEX, '\n');
+    }
+    static toIdentifier(str) {
+        if (typeof str !== 'string')
+            return '';
+        return str
+            .replace(IDENTIFIER_NAME_REPLACE_REGEX, '_$1')
+            .replace(IDENTIFIER_ALPHA_NUMERIC_NAME_REPLACE_REGEX, '_');
+    }
+    static toComment(str) {
+        if (!str)
+            return '';
+        return `/*! ${str.replace(COMMENT_END_REGEX, '* /')} */`;
+    }
+    static toNormalComment(str) {
+        if (!str)
+            return '';
+        return `/* ${str.replace(COMMENT_END_REGEX, '* /')} */`;
+    }
+    static toPath(str) {
+        if (typeof str !== 'string')
+            return '';
+        return str
+            .replace(PATH_NAME_NORMALIZE_REPLACE_REGEX, '-')
+            .replace(MATCH_PADDED_HYPHENS_REPLACE_REGEX, '');
+    }
+    // map number to a single character a-z, A-Z or multiple characters if number is too big
+    static numberToIdentifier(n) {
+        if (n >= NUMBER_OF_IDENTIFIER_START_CHARS) {
+            // use multiple letters
+            return (Template.numberToIdentifier(n % NUMBER_OF_IDENTIFIER_START_CHARS) +
+                Template.numberToIdentifierContinuation(Math.floor(n / NUMBER_OF_IDENTIFIER_START_CHARS)));
+        }
+        // lower case
+        if (n < DELTA_A_TO_Z) {
+            return String.fromCharCode(START_LOWERCASE_ALPHABET_CODE + n);
+        }
+        n -= DELTA_A_TO_Z;
+        // upper case
+        if (n < DELTA_A_TO_Z) {
+            return String.fromCharCode(START_UPPERCASE_ALPHABET_CODE + n);
+        }
+        if (n === DELTA_A_TO_Z)
+            return '_';
+        return '$';
+    }
+    static numberToIdentifierContinuation(n) {
+        if (n >= NUMBER_OF_IDENTIFIER_CONTINUATION_CHARS) {
+            // use multiple letters
+            return (Template.numberToIdentifierContinuation(n % NUMBER_OF_IDENTIFIER_CONTINUATION_CHARS) +
+                Template.numberToIdentifierContinuation(Math.floor(n / NUMBER_OF_IDENTIFIER_CONTINUATION_CHARS)));
+        }
+        // lower case
+        if (n < DELTA_A_TO_Z) {
+            return String.fromCharCode(START_LOWERCASE_ALPHABET_CODE + n);
+        }
+        n -= DELTA_A_TO_Z;
+        // upper case
+        if (n < DELTA_A_TO_Z) {
+            return String.fromCharCode(START_UPPERCASE_ALPHABET_CODE + n);
+        }
+        n -= DELTA_A_TO_Z;
+        // numbers
+        if (n < 10) {
+            return `${n}`;
+        }
+        if (n === 10)
+            return '_';
+        return '$';
+    }
+    static indent(s) {
+        if (Array.isArray(s)) {
+            return s.map(Template.indent).join('\n');
+        }
+        const str = s.trimEnd();
+        if (!str)
+            return '';
+        const ind = str[0] === '\n' ? '' : '\t';
+        return ind + str.replace(/\n([^\n])/g, '\n\t$1');
+    }
+    static prefix(s, prefix) {
+        const str = Template.asString(s).trim();
+        if (!str)
+            return '';
+        const ind = str[0] === '\n' ? '' : prefix;
+        return ind + str.replace(/\n([^\n])/g, `\n${prefix}$1`);
+    }
+    static asString(str) {
+        if (Array.isArray(str)) {
+            return str.join('\n');
+        }
+        return str;
+    }
+    static getModulesArrayBounds(modules) {
+        let maxId = -Infinity;
+        let minId = Infinity;
+        for (const module of modules) {
+            const moduleId = module.id;
+            if (typeof moduleId !== 'number')
+                return false;
+            if (maxId < moduleId)
+                maxId = moduleId;
+            if (minId > moduleId)
+                minId = moduleId;
+        }
+        if (minId < 16 + (`${minId}`).length) {
+            // add minId x ',' instead of 'Array(minId).concat(…)'
+            minId = 0;
+        }
+        // start with -1 because the first module needs no comma
+        let objectOverhead = -1;
+        for (const module of modules) {
+            // module id + colon + comma
+            objectOverhead += `${module.id}`.length + 2;
+        }
+        // number of commas, or when starting non-zero the length of Array(minId).concat()
+        const arrayOverhead = minId === 0 ? maxId : 16 + `${minId}`.length + maxId;
+        return arrayOverhead < objectOverhead ? [minId, maxId] : false;
+    }
+    static renderChunkModules(renderContext, modules, renderModule, prefix = '') {
+        const { chunkGraph } = renderContext;
+        const source = new webpack_sources_1.ConcatSource();
+        if (modules.length === 0) {
+            return null;
+        }
+        const allModules = modules.map(module => ({
+            id: chunkGraph.getModuleId(module),
+            source: renderModule(module) || 'false',
+        }));
+        const bounds = Template.getModulesArrayBounds(allModules);
+        if (bounds) {
+            // Render a spare array
+            const minId = bounds[0];
+            const maxId = bounds[1];
+            if (minId !== 0) {
+                source.add(`Array(${minId}).concat(`);
+            }
+            source.add('[\n');
+            const modules = new Map();
+            for (const module of allModules) {
+                modules.set(module.id, module);
+            }
+            for (let idx = minId; idx <= maxId; idx++) {
+                const module = modules.get(idx);
+                if (idx !== minId) {
+                    source.add(',\n');
+                }
+                source.add(`/* ${idx} */`);
+                if (module) {
+                    source.add('\n');
+                    source.add(module.source);
+                }
+            }
+            source.add(`\n${prefix}]`);
+            if (minId !== 0) {
+                source.add(')');
+            }
+        }
+        else {
+            // Render an object
+            source.add('{\n');
+            for (let i = 0; i < allModules.length; i++) {
+                const module = allModules[i];
+                if (i !== 0) {
+                    source.add(',\n');
+                }
+                source.add(`\n/***/ ${JSON.stringify(module.id)}:\n`);
+                source.add(module.source);
+            }
+            source.add(`\n\n${prefix}}`);
+        }
+        return source;
+    }
+    static renderRuntimeModules(runtimeModules, renderContext) {
+        const source = new webpack_sources_1.ConcatSource();
+        for (const module of runtimeModules) {
+            const codeGenerationResults = renderContext.codeGenerationResults;
+            let runtimeSource;
+            if (codeGenerationResults) {
+                runtimeSource = codeGenerationResults.getSource(module, renderContext.chunk.runtime, ModuleTypeConstants_1.WEBPACK_MODULE_TYPE_RUNTIME);
+            }
+            else {
+                const codeGenResult = module.codeGeneration({
+                    chunkGraph: renderContext.chunkGraph,
+                    dependencyTemplates: renderContext.dependencyTemplates,
+                    moduleGraph: renderContext.moduleGraph,
+                    runtimeTemplate: renderContext.runtimeTemplate,
+                    runtime: renderContext.chunk.runtime,
+                    codeGenerationResults,
+                });
+                if (!codeGenResult)
+                    continue;
+                runtimeSource = codeGenResult.sources.get('runtime');
+            }
+            if (runtimeSource) {
+                source.add(`${Template.toNormalComment(module.identifier())}\n`);
+                if (!module.shouldIsolate()) {
+                    source.add(runtimeSource);
+                    source.add('\n\n');
+                }
+                else if (renderContext.runtimeTemplate.supportsArrowFunction()) {
+                    source.add('(() => {\n');
+                    source.add(new webpack_sources_1.PrefixSource('\t', runtimeSource));
+                    source.add('\n})();\n\n');
+                }
+                else {
+                    source.add('!function() {\n');
+                    source.add(new webpack_sources_1.PrefixSource('\t', runtimeSource));
+                    source.add('\n}();\n\n');
+                }
+            }
+        }
+        return source;
+    }
+    static renderChunkRuntimeModules(runtimeModules, renderContext) {
+        return new webpack_sources_1.PrefixSource('/******/ ', new webpack_sources_1.ConcatSource(`function(${RuntimeGlobals.require}) { // webpackRuntimeModules\n`, this.renderRuntimeModules(runtimeModules, renderContext), '}\n'));
+    }
+}
+exports.Template = Template;

package/dist/template/TemplatedPathPlugin.d.ts

@@ -0,0 +1,4 @@
+declare class TemplatedPathPlugin {
+    apply(compiler: any): void;
+}
+export default TemplatedPathPlugin;

package/dist/template/TemplatedPathPlugin.js

@@ -0,0 +1,228 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const mime_types_1 = __importDefault(require("mime-types"));
+const path_1 = require("path");
+const util_1 = __importDefault(require("util"));
+const Chunk_1 = __importDefault(require("@/chunk/Chunk"));
+const Module_1 = __importDefault(require("@/module/Module"));
+const identifier_1 = require("@/base/identifier");
+const REGEXP = /\[\\*([\w:]+)\\*\]/gi;
+const prepareId = id => {
+    if (typeof id !== 'string')
+        return id;
+    if (/^"\s\+*.*\+\s*"$/.test(id)) {
+        const match = /^"\s\+*\s*(.*)\s*\+\s*"$/.exec(id);
+        return `" + (${match[1]} + "").replace(/(^[.-]|[^a-zA-Z0-9_-])+/g, "_") + "`;
+    }
+    return id.replace(/(^[.-]|[^a-zA-Z0-9_-])+/g, '_');
+};
+const hashLength = (replacer, handler, assetInfo, hashName) => {
+    const fn = (match, arg, input) => {
+        let result;
+        const length = arg && parseInt(arg, 10);
+        if (length && handler) {
+            result = handler(length);
+        }
+        else {
+            const hash = replacer(match, arg, input);
+            result = length ? hash.slice(0, length) : hash;
+        }
+        if (assetInfo) {
+            assetInfo.immutable = true;
+            if (Array.isArray(assetInfo[hashName])) {
+                assetInfo[hashName] = [...assetInfo[hashName], result];
+            }
+            else if (assetInfo[hashName]) {
+                assetInfo[hashName] = [assetInfo[hashName], result];
+            }
+            else {
+                assetInfo[hashName] = result;
+            }
+        }
+        return result;
+    };
+    return fn;
+};
+const replacer = (value, allowEmpty) => {
+    const fn = (match, arg, input) => {
+        if (typeof value === 'function') {
+            value = value();
+        }
+        if (value === null || value === undefined) {
+            if (!allowEmpty) {
+                throw new Error(`Path variable ${match} not implemented in this context: ${input}`);
+            }
+            return '';
+        }
+        return `${value}`;
+    };
+    return fn;
+};
+const deprecationCache = new Map();
+const deprecatedFunction = (() => () => { })();
+const deprecated = (fn, message, code) => {
+    let d = deprecationCache.get(message);
+    if (d === undefined) {
+        d = util_1.default.deprecate(deprecatedFunction, message, code);
+        deprecationCache.set(message, d);
+    }
+    return (...args) => {
+        d();
+        return fn(...args);
+    };
+};
+const replacePathVariables = (path, data, assetInfo) => {
+    const chunkGraph = data.chunkGraph;
+    const replacements = new Map();
+    // Filename context
+    //
+    // Placeholders
+    //
+    // for /some/path/file.js?query#fragment:
+    // [file] - /some/path/file.js
+    // [query] - ?query
+    // [fragment] - #fragment
+    // [base] - file.js
+    // [path] - /some/path/
+    // [name] - file
+    // [ext] - .js
+    if (typeof data.filename === 'string') {
+        // check that filename is data uri
+        const match = data.filename.match(/^data:([^;,]+)/);
+        if (match) {
+            const ext = mime_types_1.default.extension(match[1]);
+            const emptyReplacer = replacer('', true);
+            replacements.set('file', emptyReplacer);
+            replacements.set('query', emptyReplacer);
+            replacements.set('fragment', emptyReplacer);
+            replacements.set('path', emptyReplacer);
+            replacements.set('base', emptyReplacer);
+            replacements.set('name', emptyReplacer);
+            replacements.set('ext', replacer(ext ? `.${ext}` : '', true));
+            // Legacy
+            replacements.set('filebase', deprecated(emptyReplacer, '[filebase] is now [base]', 'DEP_WEBPACK_TEMPLATE_PATH_PLUGIN_REPLACE_PATH_VARIABLES_FILENAME'));
+        }
+        else {
+            const { path: file, query, fragment } = (0, identifier_1.parseResource)(data.filename);
+            const ext = (0, path_1.extname)(file);
+            const base = (0, path_1.basename)(file);
+            const name = base.slice(0, base.length - ext.length);
+            const path = file.slice(0, file.length - base.length);
+            replacements.set('file', replacer(file));
+            replacements.set('query', replacer(query, true));
+            replacements.set('fragment', replacer(fragment, true));
+            replacements.set('path', replacer(path, true));
+            replacements.set('base', replacer(base));
+            replacements.set('name', replacer(name));
+            replacements.set('ext', replacer(ext, true));
+            // Legacy
+            replacements.set('filebase', deprecated(replacer(base), '[filebase] is now [base]', 'DEP_WEBPACK_TEMPLATE_PATH_PLUGIN_REPLACE_PATH_VARIABLES_FILENAME'));
+        }
+    }
+    // Compilation context
+    //
+    // Placeholders
+    //
+    // [fullhash] - data.hash (3a4b5c6e7f)
+    //
+    // Legacy Placeholders
+    //
+    // [hash] - data.hash (3a4b5c6e7f)
+    if (data.hash) {
+        const hashReplacer = hashLength(replacer(data.hash), data.hashWithLength, assetInfo, 'fullhash');
+        replacements.set('fullhash', hashReplacer);
+        // Legacy
+        replacements.set('hash', deprecated(hashReplacer, '[hash] is now [fullhash] (also consider using [chunkhash] or [contenthash], see documentation for details)', 'DEP_WEBPACK_TEMPLATE_PATH_PLUGIN_REPLACE_PATH_VARIABLES_HASH'));
+    }
+    // Chunk Context
+    //
+    // Placeholders
+    //
+    // [id] - chunk.id (0.js)
+    // [name] - chunk.name (app.js)
+    // [chunkhash] - chunk.hash (7823t4t4.js)
+    // [contenthash] - chunk.contentHash[type] (3256u3zg.js)
+    if (data.chunk) {
+        const chunk = data.chunk;
+        const contentHashType = data.contentHashType;
+        const idReplacer = replacer(chunk.id);
+        const nameReplacer = replacer(chunk.name || chunk.id);
+        const chunkhashReplacer = hashLength(replacer(chunk instanceof Chunk_1.default ? chunk.renderedHash : chunk.hash), 'hashWithLength' in chunk ? chunk.hashWithLength : undefined, assetInfo, 'chunkhash');
+        const contenthashReplacer = hashLength(replacer(data.contentHash ||
+            (contentHashType && chunk.contentHash && chunk.contentHash[contentHashType])), data.contentHashWithLength ||
+            ('contentHashWithLength' in chunk && chunk.contentHashWithLength
+                ? chunk.contentHashWithLength[contentHashType]
+                : undefined), assetInfo, 'contenthash');
+        replacements.set('id', idReplacer);
+        replacements.set('name', nameReplacer);
+        replacements.set('chunkhash', chunkhashReplacer);
+        replacements.set('contenthash', contenthashReplacer);
+    }
+    // Module Context
+    //
+    // Placeholders
+    //
+    // [id] - module.id (2.png)
+    // [hash] - module.hash (6237543873.png)
+    //
+    // Legacy Placeholders
+    //
+    // [moduleid] - module.id (2.png)
+    // [modulehash] - module.hash (6237543873.png)
+    if (data.module) {
+        const module = data.module;
+        const idReplacer = replacer(() => prepareId(module instanceof Module_1.default ? chunkGraph.getModuleId(module) : module.id));
+        const moduleHashReplacer = hashLength(replacer(() => module instanceof Module_1.default
+            ? chunkGraph.getRenderedModuleHash(module, data.runtime)
+            : module.hash), 'hashWithLength' in module ? module.hashWithLength : undefined, assetInfo, 'modulehash');
+        const contentHashReplacer = hashLength(replacer(data.contentHash), undefined, assetInfo, 'contenthash');
+        replacements.set('id', idReplacer);
+        replacements.set('modulehash', moduleHashReplacer);
+        replacements.set('contenthash', contentHashReplacer);
+        replacements.set('hash', data.contentHash ? contentHashReplacer : moduleHashReplacer);
+        // Legacy
+        replacements.set('moduleid', deprecated(idReplacer, '[moduleid] is now [id]', 'DEP_WEBPACK_TEMPLATE_PATH_PLUGIN_REPLACE_PATH_VARIABLES_MODULE_ID'));
+    }
+    // Other things
+    if (data.url) {
+        replacements.set('url', replacer(data.url));
+    }
+    if (typeof data.runtime === 'string') {
+        replacements.set('runtime', replacer(() => prepareId(data.runtime)));
+    }
+    else {
+        replacements.set('runtime', replacer('_'));
+    }
+    if (typeof path === 'function') {
+        path = path(data, assetInfo);
+    }
+    path = path.replace(REGEXP, (match, content) => {
+        if (content.length + 2 === match.length) {
+            const contentMatch = /^(\w+)(?::(\w+))?$/.exec(content);
+            if (!contentMatch)
+                return match;
+            const [, kind, arg] = contentMatch;
+            const replacer = replacements.get(kind);
+            if (replacer !== undefined) {
+                return replacer(match, arg, path);
+            }
+        }
+        else if (match.startsWith('[\\') && match.endsWith('\\]')) {
+            return `[${match.slice(2, -2)}]`;
+        }
+        return match;
+    });
+    return path;
+};
+const plugin = 'TemplatedPathPlugin';
+class TemplatedPathPlugin {
+    apply(compiler) {
+        compiler.hooks.compilation.tap(plugin, compilation => {
+            compilation.hooks.assetPath.tap(plugin, replacePathVariables);
+        });
+    }
+}
+exports.default = TemplatedPathPlugin;

package/dist/thread/WorkerError.d.ts

@@ -0,0 +1,4 @@
+declare class WorkerError extends Error {
+    constructor(err: any, workerId: any);
+}
+export default WorkerError;

package/dist/thread/WorkerError.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const stack = (err, worker, workerId) => {
+    const originError = (err.stack || '').split('\n').filter(line => line.trim().startsWith('at'));
+    const workerError = worker.split('\n').filter(line => line.trim().startsWith('at'));
+    const diff = workerError.slice(0, workerError.length - originError.length).join('\n');
+    originError.unshift(diff);
+    originError.unshift(err.message);
+    originError.unshift(`Thread Loader (Worker ${workerId})`);
+    return originError.join('\n');
+};
+class WorkerError extends Error {
+    constructor(err, workerId) {
+        super(err);
+        this.name = err.name;
+        this.message = err.message;
+        Error.captureStackTrace(this, this.constructor);
+        this.stack = stack(err, this.stack, workerId);
+    }
+}
+exports.default = WorkerError;

package/dist/thread/WorkerPool.d.ts

@@ -0,0 +1,52 @@
+/// <reference types="node" />
+import childProcess from 'child_process';
+import WorkerError from './WorkerError';
+declare class PoolWorker {
+    disposed: boolean;
+    nextJobId: number;
+    jobs: any;
+    activeJobs: number;
+    onJobDone: any;
+    id: number;
+    worker: childProcess.ChildProcess;
+    readPipe: any;
+    writePipe: any;
+    state: string;
+    constructor(options: any, onJobDone: any);
+    listenStdOutAndErrFromWorker(workerStdout: any, workerStderr: any): void;
+    ignoreStdOutAndErrFromWorker(workerStdout: any, workerStderr: any): void;
+    writeToStdout(data: any): void;
+    writeToStderr(data: any): void;
+    run(data: any, callback: any): void;
+    warmup(requires: any): void;
+    writeJson(data: any): void;
+    writeEnd(): void;
+    readNextMessage(): void;
+    onWorkerMessage(message: any, finalCallback: any): void;
+    fromErrorObj(arg: any): WorkerError;
+    readBuffer(length: any, callback: any): void;
+    dispose(): void;
+}
+export default class WorkerPool {
+    options: any;
+    numberOfWorkers: any;
+    poolTimeout: any;
+    workerNodeArgs: any;
+    workerParallelJobs: any;
+    workers: Set<any>;
+    activeJobs: number;
+    timeout: any;
+    poolQueue: any;
+    terminated: boolean;
+    constructor(options: any);
+    isAbleToRun(): boolean;
+    terminate(): void;
+    setupLifeCycle(): void;
+    run(data: any, callback: any): void;
+    distributeJob(data: any, callback: any): void;
+    createWorker(): PoolWorker;
+    warmup(requires: any): void;
+    onJobDone(): void;
+    disposeWorkers(fromTerminate?: any): void;
+}
+export {};