@rollup/plugin-terser 0.2.1 → 0.4.0

package/dist/cjs/index.js

@@ -2,11 +2,11 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var process = require('process');
 var worker_threads = require('worker_threads');
 var smob = require('smob');
 var terser$1 = require('terser');
 var url = require('url');
+var async_hooks = require('async_hooks');
 var os = require('os');
 var events = require('events');
 var serializeJavascript = require('serialize-javascript');
@@ -23,53 +23,66 @@ function isWorkerContextSerialized(input) {
         smob.hasOwnProperty(input, 'options') &&
         typeof input.options === 'string');
 }
-async function runWorker() {
-    if (worker_threads.isMainThread || !worker_threads.parentPort || !isWorkerContextSerialized(worker_threads.workerData)) {
+function runWorker() {
+    if (worker_threads.isMainThread || !worker_threads.parentPort) {
         return;
     }
-    try {
-        // eslint-disable-next-line no-eval
-        const eval2 = eval;
-        const options = eval2(`(${worker_threads.workerData.options})`);
-        const result = await terser$1.minify(worker_threads.workerData.code, options);
+    // eslint-disable-next-line no-eval
+    const eval2 = eval;
+    worker_threads.parentPort.on('message', async (data) => {
+        if (!isWorkerContextSerialized(data)) {
+            return;
+        }
+        const options = eval2(`(${data.options})`);
+        const result = await terser$1.minify(data.code, options);
         const output = {
-            code: result.code || worker_threads.workerData.code,
+            code: result.code || data.code,
             nameCache: options.nameCache
         };
-        worker_threads.parentPort.postMessage(output);
+        if (typeof result.map === 'string') {
+            output.sourceMap = JSON.parse(result.map);
+        }
+        if (smob.isObject(result.map)) {
+            output.sourceMap = result.map;
+        }
+        worker_threads.parentPort === null || worker_threads.parentPort === void 0 ? void 0 : worker_threads.parentPort.postMessage(output);
+    });
+}
+
+const taskInfo = Symbol('taskInfo');
+const freeWorker = Symbol('freeWorker');
+
+class WorkerPoolTaskInfo extends async_hooks.AsyncResource {
+    constructor(callback) {
+        super('WorkerPoolTaskInfo');
+        this.callback = callback;
     }
-    catch (e) {
-        process.exit(1);
+    done(err, result) {
+        this.runInAsyncScope(this.callback, null, err, result);
+        this.emitDestroy();
     }
 }
-
-const symbol = Symbol.for('FreeWoker');
 class WorkerPool extends events.EventEmitter {
     constructor(options) {
         super();
         this.tasks = [];
-        this.workers = 0;
+        this.workers = [];
+        this.freeWorkers = [];
         this.maxInstances = options.maxWorkers || os.cpus().length;
         this.filePath = options.filePath;
-        this.on(symbol, () => {
+        this.on(freeWorker, () => {
             if (this.tasks.length > 0) {
-                this.run();
+                const { context, cb } = this.tasks.shift();
+                this.runTask(context, cb);
             }
         });
     }
-    add(context, cb) {
-        this.tasks.push({
-            context,
-            cb
-        });
-        if (this.workers >= this.maxInstances) {
-            return;
-        }
-        this.run();
+    get numWorkers() {
+        return this.workers.length;
     }
-    async addAsync(context) {
+    addAsync(context) {
         return new Promise((resolve, reject) => {
-            this.add(context, (err, output) => {
+            this.runTask(context, (err, output) => {
                 if (err) {
                     reject(err);
                     return;
@@ -82,54 +95,69 @@ class WorkerPool extends events.EventEmitter {
             });
         });
     }
-    run() {
-        if (this.tasks.length === 0) {
-            return;
+    close() {
+        for (let i = 0; i < this.workers.length; i++) {
+            const worker = this.workers[i];
+            worker.terminate();
         }
-        const task = this.tasks.shift();
-        if (typeof task === 'undefined') {
-            return;
-        }
-        this.workers += 1;
-        let called = false;
-        const callCallback = (err, output) => {
-            if (called) {
-                return;
-            }
-            called = true;
-            this.workers -= 1;
-            task.cb(err, output);
-            this.emit(symbol);
-        };
-        const worker = new worker_threads.Worker(this.filePath, {
-            workerData: {
-                code: task.context.code,
-                options: serializeJavascript(task.context.options)
-            }
-        });
-        worker.on('message', (data) => {
-            callCallback(null, data);
+    }
+    addNewWorker() {
+        const worker = new worker_threads.Worker(this.filePath);
+        worker.on('message', (result) => {
+            var _a;
+            (_a = worker[taskInfo]) === null || _a === void 0 ? void 0 : _a.done(null, result);
+            worker[taskInfo] = null;
+            this.freeWorkers.push(worker);
+            this.emit(freeWorker);
         });
         worker.on('error', (err) => {
-            callCallback(err);
-        });
-        worker.on('exit', (code) => {
-            if (code !== 0) {
-                callCallback(new Error(`Minify worker stopped with exit code ${code}`));
+            if (worker[taskInfo]) {
+                worker[taskInfo].done(err, null);
             }
+            else {
+                this.emit('error', err);
+            }
+            this.workers.splice(this.workers.indexOf(worker), 1);
+            this.addNewWorker();
         });
+        this.workers.push(worker);
+        this.freeWorkers.push(worker);
+        this.emit(freeWorker);
+    }
+    runTask(context, cb) {
+        if (this.freeWorkers.length === 0) {
+            this.tasks.push({ context, cb });
+            if (this.numWorkers < this.maxInstances) {
+                this.addNewWorker();
+            }
+            return;
+        }
+        const worker = this.freeWorkers.pop();
+        if (worker) {
+            worker[taskInfo] = new WorkerPoolTaskInfo(cb);
+            worker.postMessage({
+                code: context.code,
+                options: serializeJavascript(context.options)
+            });
+        }
     }
 }
 
 function terser(input = {}) {
     const { maxWorkers, ...options } = input;
-    const workerPool = new WorkerPool({
-        filePath: url.fileURLToPath((typeof document === 'undefined' ? new (require('u' + 'rl').URL)('file:' + __filename).href : (document.currentScript && document.currentScript.src || new URL('index.js', document.baseURI).href))),
-        maxWorkers
-    });
+    let workerPool;
+    let numOfChunks = 0;
+    let numOfWorkersUsed = 0;
     return {
         name: 'terser',
         async renderChunk(code, chunk, outputOptions) {
+            if (!workerPool) {
+                workerPool = new WorkerPool({
+                    filePath: url.fileURLToPath((typeof document === 'undefined' ? new (require('u' + 'rl').URL)('file:' + __filename).href : (document.currentScript && document.currentScript.src || new URL('index.js', document.baseURI).href))),
+                    maxWorkers
+                });
+            }
+            numOfChunks += 1;
             const defaultOptions = {
                 sourceMap: outputOptions.sourcemap === true || typeof outputOptions.sourcemap === 'string'
             };
@@ -140,7 +168,7 @@ function terser(input = {}) {
                 defaultOptions.toplevel = true;
             }
             try {
-                const { code: result, nameCache } = await workerPool.addAsync({
+                const { code: result, nameCache, sourceMap } = await workerPool.addAsync({
                     code,
                     options: smob.merge({}, options || {}, defaultOptions)
                 });
@@ -167,11 +195,28 @@ function terser(input = {}) {
                     // eslint-disable-next-line no-param-reassign
                     options.nameCache.props = props;
                 }
+                if ((!!defaultOptions.sourceMap || !!options.sourceMap) && smob.isObject(sourceMap)) {
+                    return {
+                        code: result,
+                        map: sourceMap
+                    };
+                }
                 return result;
             }
             catch (e) {
                 return Promise.reject(e);
             }
+            finally {
+                numOfChunks -= 1;
+                if (numOfChunks === 0) {
+                    numOfWorkersUsed = workerPool.numWorkers;
+                    workerPool.close();
+                    workerPool = null;
+                }
+            }
+        },
+        get numOfWorkersUsed() {
+            return numOfWorkersUsed;
         }
     };
 }

package/dist/es/index.js

@@ -1,8 +1,8 @@
-import process from 'process';
-import { isMainThread, parentPort, workerData, Worker } from 'worker_threads';
+import { isMainThread, parentPort, Worker } from 'worker_threads';
 import { isObject, hasOwnProperty, merge } from 'smob';
 import { minify } from 'terser';
 import { fileURLToPath } from 'url';
+import { AsyncResource } from 'async_hooks';
 import { cpus } from 'os';
 import { EventEmitter } from 'events';
 import serializeJavascript from 'serialize-javascript';
@@ -19,53 +19,66 @@ function isWorkerContextSerialized(input) {
         hasOwnProperty(input, 'options') &&
         typeof input.options === 'string');
 }
-async function runWorker() {
-    if (isMainThread || !parentPort || !isWorkerContextSerialized(workerData)) {
+function runWorker() {
+    if (isMainThread || !parentPort) {
         return;
     }
-    try {
-        // eslint-disable-next-line no-eval
-        const eval2 = eval;
-        const options = eval2(`(${workerData.options})`);
-        const result = await minify(workerData.code, options);
+    // eslint-disable-next-line no-eval
+    const eval2 = eval;
+    parentPort.on('message', async (data) => {
+        if (!isWorkerContextSerialized(data)) {
+            return;
+        }
+        const options = eval2(`(${data.options})`);
+        const result = await minify(data.code, options);
         const output = {
-            code: result.code || workerData.code,
+            code: result.code || data.code,
             nameCache: options.nameCache
         };
-        parentPort.postMessage(output);
+        if (typeof result.map === 'string') {
+            output.sourceMap = JSON.parse(result.map);
+        }
+        if (isObject(result.map)) {
+            output.sourceMap = result.map;
+        }
+        parentPort === null || parentPort === void 0 ? void 0 : parentPort.postMessage(output);
+    });
+}
+
+const taskInfo = Symbol('taskInfo');
+const freeWorker = Symbol('freeWorker');
+
+class WorkerPoolTaskInfo extends AsyncResource {
+    constructor(callback) {
+        super('WorkerPoolTaskInfo');
+        this.callback = callback;
     }
-    catch (e) {
-        process.exit(1);
+    done(err, result) {
+        this.runInAsyncScope(this.callback, null, err, result);
+        this.emitDestroy();
     }
 }
-
-const symbol = Symbol.for('FreeWoker');
 class WorkerPool extends EventEmitter {
     constructor(options) {
         super();
         this.tasks = [];
-        this.workers = 0;
+        this.workers = [];
+        this.freeWorkers = [];
         this.maxInstances = options.maxWorkers || cpus().length;
         this.filePath = options.filePath;
-        this.on(symbol, () => {
+        this.on(freeWorker, () => {
             if (this.tasks.length > 0) {
-                this.run();
+                const { context, cb } = this.tasks.shift();
+                this.runTask(context, cb);
             }
         });
     }
-    add(context, cb) {
-        this.tasks.push({
-            context,
-            cb
-        });
-        if (this.workers >= this.maxInstances) {
-            return;
-        }
-        this.run();
+    get numWorkers() {
+        return this.workers.length;
     }
-    async addAsync(context) {
+    addAsync(context) {
         return new Promise((resolve, reject) => {
-            this.add(context, (err, output) => {
+            this.runTask(context, (err, output) => {
                 if (err) {
                     reject(err);
                     return;
@@ -78,54 +91,69 @@ class WorkerPool extends EventEmitter {
             });
         });
     }
-    run() {
-        if (this.tasks.length === 0) {
-            return;
+    close() {
+        for (let i = 0; i < this.workers.length; i++) {
+            const worker = this.workers[i];
+            worker.terminate();
         }
-        const task = this.tasks.shift();
-        if (typeof task === 'undefined') {
-            return;
-        }
-        this.workers += 1;
-        let called = false;
-        const callCallback = (err, output) => {
-            if (called) {
-                return;
-            }
-            called = true;
-            this.workers -= 1;
-            task.cb(err, output);
-            this.emit(symbol);
-        };
-        const worker = new Worker(this.filePath, {
-            workerData: {
-                code: task.context.code,
-                options: serializeJavascript(task.context.options)
-            }
-        });
-        worker.on('message', (data) => {
-            callCallback(null, data);
+    }
+    addNewWorker() {
+        const worker = new Worker(this.filePath);
+        worker.on('message', (result) => {
+            var _a;
+            (_a = worker[taskInfo]) === null || _a === void 0 ? void 0 : _a.done(null, result);
+            worker[taskInfo] = null;
+            this.freeWorkers.push(worker);
+            this.emit(freeWorker);
         });
         worker.on('error', (err) => {
-            callCallback(err);
-        });
-        worker.on('exit', (code) => {
-            if (code !== 0) {
-                callCallback(new Error(`Minify worker stopped with exit code ${code}`));
+            if (worker[taskInfo]) {
+                worker[taskInfo].done(err, null);
             }
+            else {
+                this.emit('error', err);
+            }
+            this.workers.splice(this.workers.indexOf(worker), 1);
+            this.addNewWorker();
         });
+        this.workers.push(worker);
+        this.freeWorkers.push(worker);
+        this.emit(freeWorker);
+    }
+    runTask(context, cb) {
+        if (this.freeWorkers.length === 0) {
+            this.tasks.push({ context, cb });
+            if (this.numWorkers < this.maxInstances) {
+                this.addNewWorker();
+            }
+            return;
+        }
+        const worker = this.freeWorkers.pop();
+        if (worker) {
+            worker[taskInfo] = new WorkerPoolTaskInfo(cb);
+            worker.postMessage({
+                code: context.code,
+                options: serializeJavascript(context.options)
+            });
+        }
     }
 }
 
 function terser(input = {}) {
     const { maxWorkers, ...options } = input;
-    const workerPool = new WorkerPool({
-        filePath: fileURLToPath(import.meta.url),
-        maxWorkers
-    });
+    let workerPool;
+    let numOfChunks = 0;
+    let numOfWorkersUsed = 0;
     return {
         name: 'terser',
         async renderChunk(code, chunk, outputOptions) {
+            if (!workerPool) {
+                workerPool = new WorkerPool({
+                    filePath: fileURLToPath(import.meta.url),
+                    maxWorkers
+                });
+            }
+            numOfChunks += 1;
             const defaultOptions = {
                 sourceMap: outputOptions.sourcemap === true || typeof outputOptions.sourcemap === 'string'
             };
@@ -136,7 +164,7 @@ function terser(input = {}) {
                 defaultOptions.toplevel = true;
             }
             try {
-                const { code: result, nameCache } = await workerPool.addAsync({
+                const { code: result, nameCache, sourceMap } = await workerPool.addAsync({
                     code,
                     options: merge({}, options || {}, defaultOptions)
                 });
@@ -163,11 +191,28 @@ function terser(input = {}) {
                     // eslint-disable-next-line no-param-reassign
                     options.nameCache.props = props;
                 }
+                if ((!!defaultOptions.sourceMap || !!options.sourceMap) && isObject(sourceMap)) {
+                    return {
+                        code: result,
+                        map: sourceMap
+                    };
+                }
                 return result;
             }
             catch (e) {
                 return Promise.reject(e);
             }
+            finally {
+                numOfChunks -= 1;
+                if (numOfChunks === 0) {
+                    numOfWorkersUsed = workerPool.numWorkers;
+                    workerPool.close();
+                    workerPool = null;
+                }
+            }
+        },
+        get numOfWorkersUsed() {
+            return numOfWorkersUsed;
         }
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rollup/plugin-terser",
-  "version": "0.2.1",
+  "version": "0.4.0",
   "publishConfig": {
     "access": "public"
   },

package/src/constants.ts

@@ -0,0 +1,2 @@
+export const taskInfo = Symbol('taskInfo');
+export const freeWorker = Symbol('freeWorker');

package/src/module.ts

@@ -9,15 +9,23 @@ import { WorkerPool } from './worker-pool';
 export default function terser(input: Options = {}) {
   const { maxWorkers, ...options } = input;
 
-  const workerPool = new WorkerPool({
-    filePath: fileURLToPath(import.meta.url),
-    maxWorkers
-  });
+  let workerPool: WorkerPool | null | undefined;
+  let numOfChunks = 0;
+  let numOfWorkersUsed = 0;
 
   return {
     name: 'terser',
 
     async renderChunk(code: string, chunk: RenderedChunk, outputOptions: NormalizedOutputOptions) {
+      if (!workerPool) {
+        workerPool = new WorkerPool({
+          filePath: fileURLToPath(import.meta.url),
+          maxWorkers
+        });
+      }
+
+      numOfChunks += 1;
+
       const defaultOptions: Options = {
         sourceMap: outputOptions.sourcemap === true || typeof outputOptions.sourcemap === 'string'
       };
@@ -31,7 +39,11 @@ export default function terser(input: Options = {}) {
       }
 
       try {
-        const { code: result, nameCache } = await workerPool.addAsync({
+        const {
+          code: result,
+          nameCache,
+          sourceMap
+        } = await workerPool.addAsync({
           code,
           options: merge({}, options || {}, defaultOptions)
         });
@@ -67,10 +79,27 @@ export default function terser(input: Options = {}) {
           options.nameCache.props = props;
         }
 
+        if ((!!defaultOptions.sourceMap || !!options.sourceMap) && isObject(sourceMap)) {
+          return {
+            code: result,
+            map: sourceMap
+          };
+        }
         return result;
       } catch (e) {
         return Promise.reject(e);
+      } finally {
+        numOfChunks -= 1;
+        if (numOfChunks === 0) {
+          numOfWorkersUsed = workerPool.numWorkers;
+          workerPool.close();
+          workerPool = null;
+        }
       }
+    },
+
+    get numOfWorkersUsed() {
+      return numOfWorkersUsed;
     }
   };
 }

package/src/type.ts

@@ -1,5 +1,10 @@
+import type { AsyncResource } from 'async_hooks';
+import type { Worker } from 'worker_threads';
+
 import type { MinifyOptions } from 'terser';
 
+import type { taskInfo } from './constants';
+
 export interface Options extends MinifyOptions {
   nameCache?: Record<string, any>;
   maxWorkers?: number;
@@ -12,6 +17,12 @@ export interface WorkerContext {
 
 export type WorkerCallback = (err: Error | null, output?: WorkerOutput) => void;
 
+interface WorkerPoolTaskInfo extends AsyncResource {
+  done(err: Error | null, result: any): void;
+}
+
+export type WorkerWithTaskInfo = Worker & { [taskInfo]?: WorkerPoolTaskInfo | null };
+
 export interface WorkerContextSerialized {
   code: string;
   options: string;
@@ -20,6 +31,7 @@ export interface WorkerContextSerialized {
 export interface WorkerOutput {
   code: string;
   nameCache?: Options['nameCache'];
+  sourceMap?: Record<string, any>;
 }
 
 export interface WorkerPoolOptions {

package/src/worker-pool.ts

@@ -1,18 +1,31 @@
+import { AsyncResource } from 'async_hooks';
 import { Worker } from 'worker_threads';
 import { cpus } from 'os';
 import { EventEmitter } from 'events';
 
 import serializeJavascript from 'serialize-javascript';
 
+import { freeWorker, taskInfo } from './constants';
+
 import type {
   WorkerCallback,
   WorkerContext,
   WorkerOutput,
   WorkerPoolOptions,
-  WorkerPoolTask
+  WorkerPoolTask,
+  WorkerWithTaskInfo
 } from './type';
 
-const symbol = Symbol.for('FreeWoker');
+class WorkerPoolTaskInfo extends AsyncResource {
+  constructor(private callback: WorkerCallback) {
+    super('WorkerPoolTaskInfo');
+  }
+
+  done(err: Error | null, result: any) {
+    this.runInAsyncScope(this.callback, null, err, result);
+    this.emitDestroy();
+  }
+}
 
 export class WorkerPool extends EventEmitter {
   protected maxInstances: number;
@@ -21,7 +34,8 @@ export class WorkerPool extends EventEmitter {
 
   protected tasks: WorkerPoolTask[] = [];
 
-  protected workers = 0;
+  protected workers: WorkerWithTaskInfo[] = [];
+  protected freeWorkers: WorkerWithTaskInfo[] = [];
 
   constructor(options: WorkerPoolOptions) {
     super();
@@ -29,29 +43,21 @@ export class WorkerPool extends EventEmitter {
     this.maxInstances = options.maxWorkers || cpus().length;
     this.filePath = options.filePath;
 
-    this.on(symbol, () => {
+    this.on(freeWorker, () => {
       if (this.tasks.length > 0) {
-        this.run();
+        const { context, cb } = this.tasks.shift()!;
+        this.runTask(context, cb);
       }
     });
   }
 
-  add(context: WorkerContext, cb: WorkerCallback) {
-    this.tasks.push({
-      context,
-      cb
-    });
-
-    if (this.workers >= this.maxInstances) {
-      return;
-    }
-
-    this.run();
+  get numWorkers(): number {
+    return this.workers.length;
   }
 
-  async addAsync(context: WorkerContext): Promise<WorkerOutput> {
+  addAsync(context: WorkerContext): Promise<WorkerOutput> {
     return new Promise((resolve, reject) => {
-      this.add(context, (err, output) => {
+      this.runTask(context, (err, output) => {
         if (err) {
           reject(err);
           return;
@@ -67,51 +73,54 @@ export class WorkerPool extends EventEmitter {
     });
   }
 
-  private run() {
-    if (this.tasks.length === 0) {
-      return;
-    }
-
-    const task = this.tasks.shift();
-
-    if (typeof task === 'undefined') {
-      return;
+  close() {
+    for (let i = 0; i < this.workers.length; i++) {
+      const worker = this.workers[i];
+      worker.terminate();
     }
+  }
 
-    this.workers += 1;
-
-    let called = false;
-    const callCallback = (err: Error | null, output?: WorkerOutput) => {
-      if (called) {
-        return;
-      }
-      called = true;
-
-      this.workers -= 1;
-
-      task.cb(err, output);
-      this.emit(symbol);
-    };
-
-    const worker = new Worker(this.filePath, {
-      workerData: {
-        code: task.context.code,
-        options: serializeJavascript(task.context.options)
-      }
-    });
+  private addNewWorker() {
+    const worker: WorkerWithTaskInfo = new Worker(this.filePath);
 
-    worker.on('message', (data) => {
-      callCallback(null, data);
+    worker.on('message', (result) => {
+      worker[taskInfo]?.done(null, result);
+      worker[taskInfo] = null;
+      this.freeWorkers.push(worker);
+      this.emit(freeWorker);
     });
 
     worker.on('error', (err) => {
-      callCallback(err);
+      if (worker[taskInfo]) {
+        worker[taskInfo].done(err, null);
+      } else {
+        this.emit('error', err);
+      }
+      this.workers.splice(this.workers.indexOf(worker), 1);
+      this.addNewWorker();
     });
 
-    worker.on('exit', (code) => {
-      if (code !== 0) {
-        callCallback(new Error(`Minify worker stopped with exit code ${code}`));
+    this.workers.push(worker);
+    this.freeWorkers.push(worker);
+    this.emit(freeWorker);
+  }
+
+  private runTask(context: WorkerContext, cb: WorkerCallback) {
+    if (this.freeWorkers.length === 0) {
+      this.tasks.push({ context, cb });
+      if (this.numWorkers < this.maxInstances) {
+        this.addNewWorker();
       }
-    });
+      return;
+    }
+
+    const worker = this.freeWorkers.pop();
+    if (worker) {
+      worker[taskInfo] = new WorkerPoolTaskInfo(cb);
+      worker.postMessage({
+        code: context.code,
+        options: serializeJavascript(context.options)
+      });
+    }
   }
 }

package/src/worker.ts

@@ -1,5 +1,4 @@
-import process from 'process';
-import { isMainThread, parentPort, workerData } from 'worker_threads';
+import { isMainThread, parentPort } from 'worker_threads';
 
 import { hasOwnProperty, isObject } from 'smob';
 
@@ -22,26 +21,36 @@ function isWorkerContextSerialized(input: unknown): input is WorkerContextSerial
   );
 }
 
-export async function runWorker() {
-  if (isMainThread || !parentPort || !isWorkerContextSerialized(workerData)) {
+export function runWorker() {
+  if (isMainThread || !parentPort) {
     return;
   }
 
-  try {
-    // eslint-disable-next-line no-eval
-    const eval2 = eval;
+  // eslint-disable-next-line no-eval
+  const eval2 = eval;
 
-    const options = eval2(`(${workerData.options})`);
+  parentPort.on('message', async (data: WorkerContextSerialized) => {
+    if (!isWorkerContextSerialized(data)) {
+      return;
+    }
 
-    const result = await minify(workerData.code, options);
+    const options = eval2(`(${data.options})`);
+
+    const result = await minify(data.code, options);
 
     const output: WorkerOutput = {
-      code: result.code || workerData.code,
+      code: result.code || data.code,
       nameCache: options.nameCache
     };
 
-    parentPort.postMessage(output);
-  } catch (e) {
-    process.exit(1);
-  }
+    if (typeof result.map === 'string') {
+      output.sourceMap = JSON.parse(result.map);
+    }
+
+    if (isObject(result.map)) {
+      output.sourceMap = result.map;
+    }
+
+    parentPort?.postMessage(output);
+  });
 }