@parcel/workers 2.0.0-nightly.130 → 2.0.0-nightly.1303

package/lib/child.js

@@ -5,75 +5,114 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.Child = void 0;
 
-var _assert = _interopRequireDefault(require("assert"));
+function _assert() {
+  const data = _interopRequireDefault(require("assert"));
 
-var _nullthrows = _interopRequireDefault(require("nullthrows"));
+  _assert = function () {
+    return data;
+  };
 
-var _logger = _interopRequireWildcard(require("@parcel/logger"));
-
-var _diagnostic = _interopRequireWildcard(require("@parcel/diagnostic"));
-
-var _bus = _interopRequireDefault(require("./bus"));
+  return data;
+}
 
-var _Profiler = _interopRequireDefault(require("./Profiler"));
+function _nullthrows() {
+  const data = _interopRequireDefault(require("nullthrows"));
 
-var _Handle = _interopRequireDefault(require("./Handle"));
+  _nullthrows = function () {
+    return data;
+  };
 
-function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
+  return data;
+}
 
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+function _logger() {
+  const data = _interopRequireWildcard(require("@parcel/logger"));
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+  _logger = function () {
+    return data;
+  };
 
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+  return data;
+}
 
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+function _diagnostic() {
+  const data = _interopRequireWildcard(require("@parcel/diagnostic"));
 
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+  _diagnostic = function () {
+    return data;
+  };
 
-class Child {
-  constructor(ChildBackend) {
-    _defineProperty(this, "callQueue", []);
+  return data;
+}
 
-    _defineProperty(this, "childId", void 0);
+function _core() {
+  const data = require("@parcel/core");
 
-    _defineProperty(this, "maxConcurrentCalls", 10);
+  _core = function () {
+    return data;
+  };
 
-    _defineProperty(this, "module", void 0);
+  return data;
+}
 
-    _defineProperty(this, "responseId", 0);
+var _bus = _interopRequireDefault(require("./bus"));
 
-    _defineProperty(this, "responseQueue", new Map());
+function _profiler() {
+  const data = require("@parcel/profiler");
 
-    _defineProperty(this, "loggerDisposable", void 0);
+  _profiler = function () {
+    return data;
+  };
 
-    _defineProperty(this, "child", void 0);
+  return data;
+}
 
-    _defineProperty(this, "profiler", void 0);
+var _Handle2 = _interopRequireDefault(require("./Handle"));
 
-    _defineProperty(this, "workerApi", void 0);
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 
-    _defineProperty(this, "handles", new Map());
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 
-    _defineProperty(this, "sharedReferences", new Map());
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-    _defineProperty(this, "sharedReferencesByValue", new Map());
+// The import of './Handle' should really be imported eagerly (with @babel/plugin-transform-modules-commonjs's lazy mode).
+const Handle = _Handle2.default;
 
-    _defineProperty(this, "workerApi", {
-      callMaster: (request, awaitResponse = true) => this.addCall(request, awaitResponse),
-      createReverseHandle: fn => this.createReverseHandle(fn),
-      getSharedReference: ref => this.sharedReferences.get(ref),
-      resolveSharedReference: value => this.sharedReferencesByValue.get(value)
-    });
+class Child {
+  callQueue = [];
+  maxConcurrentCalls = 10;
+  responseId = 0;
+  responseQueue = new Map();
+  handles = new Map();
+  sharedReferences = new Map();
+  sharedReferencesByValue = new Map();
 
-    this.child = new ChildBackend(this.messageListener.bind(this), this.handleEnd.bind(this)); // Monitior all logging events inside this child process and forward to
+  constructor(ChildBackend) {
+    this.child = new ChildBackend(m => {
+      this.messageListener(m);
+    }, () => this.handleEnd()); // Monitior all logging events inside this child process and forward to
     // the main process via the bus.
 
-    this.loggerDisposable = _logger.default.onLog(event => {
+    this.loggerDisposable = _logger().default.onLog(event => {
       _bus.default.emit('logEvent', event);
+    }); // .. and do the same for trace events
+
+    this.tracerDisposable = _profiler().tracer.onTrace(event => {
+      _bus.default.emit('traceEvent', event);
     });
   }
 
+  workerApi = {
+    callMaster: (request, awaitResponse = true) => this.addCall(request, awaitResponse),
+    createReverseHandle: fn => this.createReverseHandle(fn),
+    runHandle: (handle, args) => this.workerApi.callMaster({
+      handle: handle.id,
+      args
+    }, true),
+    getSharedReference: ref => this.sharedReferences.get(ref),
+    resolveSharedReference: value => this.sharedReferencesByValue.get(value)
+  };
+
   messageListener(message) {
     if (message.type === 'response') {
       return this.handleResponse(message);
@@ -86,10 +125,14 @@ class Child {
     this.child.send(data);
   }
 
-  childInit(module, childId) {
+  async childInit(module, childId) {
     // $FlowFixMe this must be dynamic
     this.module = require(module);
     this.childId = childId;
+
+    if (this.module.childInit != null) {
+      await this.module.childInit();
+    }
   }
 
   async handleRequest(data) {
@@ -99,7 +142,7 @@ class Child {
       args,
       handle: handleId
     } = data;
-    let child = (0, _nullthrows.default)(data.child);
+    let child = (0, _nullthrows().default)(data.child);
 
     const responseFromContent = content => ({
       idx,
@@ -114,14 +157,16 @@ class Child {
       child,
       type: 'response',
       contentType: 'error',
-      content: (0, _diagnostic.anyToDiagnostic)(e)
+      content: (0, _diagnostic().anyToDiagnostic)(e)
     });
 
     let result;
 
     if (handleId != null) {
       try {
-        let fn = (0, _nullthrows.default)(this.handles.get(handleId)).fn;
+        var _this$handles$get;
+
+        let fn = (0, _nullthrows().default)((_this$handles$get = this.handles.get(handleId)) === null || _this$handles$get === void 0 ? void 0 : _this$handles$get.fn);
         result = responseFromContent(fn(...args));
       } catch (e) {
         result = errorResponseFromError(e);
@@ -130,21 +175,25 @@ class Child {
       try {
         let [moduleName, childOptions] = args;
 
-        if (childOptions.patchConsole) {
-          (0, _logger.patchConsole)();
+        if (childOptions.shouldPatchConsole) {
+          (0, _logger().patchConsole)();
         } else {
-          (0, _logger.unpatchConsole)();
+          (0, _logger().unpatchConsole)();
+        }
+
+        if (childOptions.shouldTrace) {
+          _profiler().tracer.enable();
         }
 
-        result = responseFromContent(this.childInit(moduleName, child));
+        result = responseFromContent(await this.childInit(moduleName, child));
       } catch (e) {
         result = errorResponseFromError(e);
       }
     } else if (method === 'startProfile') {
-      this.profiler = new _Profiler.default();
+      this.profiler = new (_profiler().SamplingProfiler)();
 
       try {
-        result = responseFromContent((await this.profiler.startProfiling()));
+        result = responseFromContent(await this.profiler.startProfiling());
       } catch (e) {
         result = errorResponseFromError(e);
       }
@@ -155,35 +204,53 @@ class Child {
       } catch (e) {
         result = errorResponseFromError(e);
       }
+    } else if (method === 'takeHeapSnapshot') {
+      try {
+        let v8 = require('v8');
+
+        result = responseFromContent(v8.writeHeapSnapshot('heap-' + args[0] + '-' + (this.childId ? 'worker' + this.childId : 'main') + '.heapsnapshot'));
+      } catch (e) {
+        result = errorResponseFromError(e);
+      }
     } else if (method === 'createSharedReference') {
-      let [ref, value] = args;
+      let [ref, _value] = args;
+      let value = _value instanceof ArrayBuffer ? // In the case the value is pre-serialized as a buffer,
+      // deserialize it.
+      (0, _core().deserialize)(Buffer.from(_value)) : _value;
       this.sharedReferences.set(ref, value);
       this.sharedReferencesByValue.set(value, ref);
       result = responseFromContent(null);
     } else if (method === 'deleteSharedReference') {
-      this.sharedReferences.delete(args[0]);
+      let ref = args[0];
+      let value = this.sharedReferences.get(ref);
+      this.sharedReferencesByValue.delete(value);
+      this.sharedReferences.delete(ref);
       result = responseFromContent(null);
     } else {
       try {
-        result = responseFromContent(( // $FlowFixMe
-        await this.module[method](this.workerApi, ...args)));
+        result = responseFromContent( // $FlowFixMe
+        await this.module[method](this.workerApi, ...args));
       } catch (e) {
         result = errorResponseFromError(e);
       }
     }
 
-    this.send(result);
+    try {
+      this.send(result);
+    } catch (e) {
+      result = this.send(errorResponseFromError(e));
+    }
   }
 
   handleResponse(data) {
-    let idx = (0, _nullthrows.default)(data.idx);
+    let idx = (0, _nullthrows().default)(data.idx);
     let contentType = data.contentType;
     let content = data.content;
-    let call = (0, _nullthrows.default)(this.responseQueue.get(idx));
+    let call = (0, _nullthrows().default)(this.responseQueue.get(idx));
 
     if (contentType === 'error') {
-      (0, _assert.default)(typeof content !== 'string');
-      call.reject(new _diagnostic.default({
+      (0, _assert().default)(typeof content !== 'string');
+      call.reject(new (_diagnostic().default)({
         diagnostic: content
       }));
     } else {
@@ -200,14 +267,14 @@ class Child {
     var _promise;
 
     // $FlowFixMe
-    let call = _objectSpread({}, request, {
+    let call = { ...request,
       type: 'request',
       child: this.childId,
+      // $FlowFixMe Added in Flow 0.121.0 upgrade in #4381
       awaitResponse,
       resolve: () => {},
       reject: () => {}
-    });
-
+    };
     let promise;
 
     if (awaitResponse) {
@@ -254,12 +321,12 @@ class Child {
 
   handleEnd() {
     this.loggerDisposable.dispose();
+    this.tracerDisposable.dispose();
   }
 
   createReverseHandle(fn) {
-    let handle = new _Handle.default({
+    let handle = new Handle({
       fn,
-      workerApi: this.workerApi,
       childId: this.childId
     });
     this.handles.set(handle.id, handle);

package/lib/childState.js

@@ -3,8 +3,8 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.setChild = setChild;
 exports.child = void 0;
+exports.setChild = setChild;
 // This file is imported by both the WorkerFarm and child implementation.
 // When a worker is inited, it sets the state in this file.
 // This way, WorkerFarm can access the state without directly importing the child code.

package/lib/cpuCount.js

@@ -3,18 +3,34 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.detectRealCores = detectRealCores;
 exports.default = getCores;
+exports.detectRealCores = detectRealCores;
+
+function _os() {
+  const data = _interopRequireDefault(require("os"));
 
-var _os = _interopRequireDefault(require("os"));
+  _os = function () {
+    return data;
+  };
+
+  return data;
+}
 
-var _child_process = require("child_process");
+function _child_process() {
+  const data = require("child_process");
+
+  _child_process = function () {
+    return data;
+  };
+
+  return data;
+}
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 const exec = command => {
   try {
-    let stdout = (0, _child_process.execSync)(command, {
+    let stdout = (0, _child_process().execSync)(command, {
       encoding: 'utf8',
       // This prevents the command from outputting to the console
       stdio: [null, null, null]
@@ -26,7 +42,7 @@ const exec = command => {
 };
 
 function detectRealCores() {
-  let platform = _os.default.platform();
+  let platform = _os().default.platform();
 
   let amount = 0;
 
@@ -34,6 +50,12 @@ function detectRealCores() {
     amount = parseInt(exec('lscpu -p | egrep -v "^#" | sort -u -t, -k 2,4 | wc -l'), 10);
   } else if (platform === 'darwin') {
     amount = parseInt(exec('sysctl -n hw.physicalcpu_max'), 10);
+  } else if (platform === 'win32') {
+    const str = exec('wmic cpu get NumberOfCores').match(/\d+/g);
+
+    if (str !== null) {
+      amount = parseInt(str.filter(n => n !== '')[0], 10);
+    }
   }
 
   if (!amount || amount <= 0) {
@@ -47,7 +69,6 @@ let cores;
 
 function getCores(bypassCache = false) {
   // Do not re-run commands if we already have the count...
-  // $FlowFixMe
   if (cores && !bypassCache) {
     return cores;
   }
@@ -56,7 +77,7 @@ function getCores(bypassCache = false) {
     cores = detectRealCores();
   } catch (e) {
     // Guess the amount of real cores
-    cores = _os.default.cpus().filter((cpu, index) => !cpu.model.includes('Intel') || index % 2 === 1).length;
+    cores = _os().default.cpus().filter((cpu, index) => !cpu.model.includes('Intel') || index % 2 === 1).length;
   } // Another fallback
 
 

package/lib/index.js

@@ -17,17 +17,43 @@ Object.defineProperty(exports, "bus", {
 });
 exports.default = void 0;
 
-var _assert = _interopRequireDefault(require("assert"));
+function _assert() {
+  const data = _interopRequireDefault(require("assert"));
+
+  _assert = function () {
+    return data;
+  };
+
+  return data;
+}
 
 var _WorkerFarm = _interopRequireWildcard(require("./WorkerFarm"));
 
-var _logger = _interopRequireDefault(require("@parcel/logger"));
+function _logger() {
+  const data = _interopRequireDefault(require("@parcel/logger"));
+
+  _logger = function () {
+    return data;
+  };
+
+  return data;
+}
 
 var _bus = _interopRequireDefault(require("./bus"));
 
-function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
+function _profiler() {
+  const data = require("@parcel/profiler");
 
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+  _profiler = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
@@ -36,35 +62,40 @@ if (!_WorkerFarm.default.isWorker()) {
   _bus.default.on('logEvent', e => {
     switch (e.level) {
       case 'info':
-        _logger.default.info(e.diagnostics);
+        _logger().default.info(e.diagnostics);
 
         break;
 
       case 'progress':
-        (0, _assert.default)(typeof e.message === 'string');
+        (0, _assert().default)(typeof e.message === 'string');
 
-        _logger.default.progress(e.message);
+        _logger().default.progress(e.message);
 
         break;
 
       case 'verbose':
-        _logger.default.verbose(e.diagnostics);
+        _logger().default.verbose(e.diagnostics);
 
         break;
 
       case 'warn':
-        _logger.default.warn(e.diagnostics);
+        _logger().default.warn(e.diagnostics);
 
         break;
 
       case 'error':
-        _logger.default.error(e.diagnostics);
+        _logger().default.error(e.diagnostics);
 
         break;
 
       default:
         throw new Error('Unknown log level');
     }
+  }); // Forward all trace events originating from workers into the main process
+
+
+  _bus.default.on('traceEvent', e => {
+    _profiler().tracer.trace(e);
   });
 }
 

package/lib/process/ProcessChild.js

@@ -5,24 +5,34 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-var _nullthrows = _interopRequireDefault(require("nullthrows"));
+function _nullthrows() {
+  const data = _interopRequireDefault(require("nullthrows"));
+
+  _nullthrows = function () {
+    return data;
+  };
+
+  return data;
+}
 
 var _childState = require("../childState");
 
 var _child = require("../child");
 
-var _core = require("@parcel/core");
+function _core() {
+  const data = require("@parcel/core");
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+  _core = function () {
+    return data;
+  };
 
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+  return data;
+}
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 class ProcessChild {
   constructor(onMessage, onExit) {
-    _defineProperty(this, "onMessage", void 0);
-
-    _defineProperty(this, "onExit", void 0);
-
     if (!process.send) {
       throw new Error('Only create ProcessChild instances in a worker!');
     }
@@ -37,13 +47,14 @@ class ProcessChild {
       return this.stop();
     }
 
-    this.onMessage((0, _core.deserialize)(Buffer.from(data, 'base64')));
+    this.onMessage((0, _core().deserialize)(Buffer.from(data, 'base64')));
   }
 
   send(data) {
-    let processSend = (0, _nullthrows.default)(process.send).bind(process);
-    processSend((0, _core.serialize)(data).toString('base64'), err => {
+    let processSend = (0, _nullthrows().default)(process.send).bind(process);
+    processSend((0, _core().serialize)(data).toString('base64'), err => {
       if (err && err instanceof Error) {
+        // $FlowFixMe[prop-missing]
         if (err.code === 'ERR_IPC_CHANNEL_CLOSED') {
           // IPC connection closed
           // no need to keep the worker running if it can't send or receive data

package/lib/process/ProcessWorker.js

@@ -5,34 +5,45 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-var _child_process = _interopRequireDefault(require("child_process"));
+function _child_process() {
+  const data = _interopRequireDefault(require("child_process"));
 
-var _path = _interopRequireDefault(require("path"));
+  _child_process = function () {
+    return data;
+  };
 
-var _core = require("@parcel/core");
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+  return data;
+}
 
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _path() {
+  const data = _interopRequireDefault(require("path"));
 
-const WORKER_PATH = _path.default.join(__dirname, 'ProcessChild.js');
+  _path = function () {
+    return data;
+  };
 
-class ProcessWorker {
-  constructor(execArgv, onMessage, onError, onExit) {
-    _defineProperty(this, "execArgv", void 0);
+  return data;
+}
 
-    _defineProperty(this, "onMessage", void 0);
+function _core() {
+  const data = require("@parcel/core");
 
-    _defineProperty(this, "onError", void 0);
+  _core = function () {
+    return data;
+  };
 
-    _defineProperty(this, "onExit", void 0);
+  return data;
+}
 
-    _defineProperty(this, "child", void 0);
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-    _defineProperty(this, "processQueue", true);
+const WORKER_PATH = _path().default.join(__dirname, 'ProcessChild.js');
 
-    _defineProperty(this, "sendQueue", []);
+class ProcessWorker {
+  processQueue = true;
+  sendQueue = [];
 
+  constructor(execArgv, onMessage, onError, onExit) {
     this.execArgv = execArgv;
     this.onMessage = onMessage;
     this.onError = onError;
@@ -40,13 +51,13 @@ class ProcessWorker {
   }
 
   start() {
-    this.child = _child_process.default.fork(WORKER_PATH, process.argv, {
+    this.child = _child_process().default.fork(WORKER_PATH, process.argv, {
       execArgv: this.execArgv,
       env: process.env,
       cwd: process.cwd()
     });
     this.child.on('message', data => {
-      this.onMessage((0, _core.deserialize)(Buffer.from(data, 'base64')));
+      this.onMessage((0, _core().deserialize)(Buffer.from(data, 'base64')));
     });
     this.child.once('exit', this.onExit);
     this.child.on('error', this.onError);
@@ -68,7 +79,7 @@ class ProcessWorker {
       return;
     }
 
-    let result = this.child.send((0, _core.serialize)(data).toString('base64'), error => {
+    let result = this.child.send((0, _core().serialize)(data).toString('base64'), error => {
       if (error && error instanceof Error) {
         // Ignore this, the workerfarm handles child errors
         return;