@lvce-editor/static-server 0.86.5 → 0.86.6

package/dist/static-server.js

@@ -5,84 +5,74 @@ import config from '../config.json' with { type: 'json' };
 
 const { files, headers } = config;
 
-const handleUncaughtExceptionMonitor = (error) => {
+const handleUncaughtExceptionMonitor = error => {
   console.error(`[static-server] uncaught exception ${error}`);
 };
 
 const __dirname$1 = import.meta.dirname;
-
 const root = resolve$1(__dirname$1, '..');
 
-const codiconsPathCandidates = [
-  join(root, 'packages', 'renderer-worker', 'node_modules', '@vscode', 'codicons'),
-  join(root, 'node_modules', '@vscode', 'codicons'),
-];
-
+const codiconsPathCandidates = [join(root, 'packages', 'renderer-worker', 'node_modules', '@vscode', 'codicons'), join(root, 'node_modules', '@vscode', 'codicons')];
 const getCodiconsPath = () => {
   for (const candidate of codiconsPathCandidates) {
     if (existsSync(candidate)) {
-      return candidate
+      return candidate;
     }
   }
-  return codiconsPathCandidates[0]
+  return codiconsPathCandidates[0];
 };
-
 const codiconsPath = getCodiconsPath();
-
 const codiconsIconsPath = join(codiconsPath, 'src', 'icons');
 
 const STATIC = join(root, 'static');
 
 const invalidIconsPath = join(STATIC, '__missing_vscode_icon__.svg');
 const invalidStaticPath = join(STATIC, '__invalid_path__');
-
 const getContainedPath = (basePath, pathName) => {
   let decodedPathName;
   try {
     decodedPathName = decodeURIComponent(pathName);
   } catch {
-    return invalidStaticPath
+    return invalidStaticPath;
   }
   const absolutePath = resolve$1(basePath, decodedPathName.replace(/^[/\\]+/, ''));
   const relativePath = relative(basePath, absolutePath);
   if (relativePath === '..' || relativePath.startsWith(`..${sep}`) || isAbsolute(relativePath)) {
-    return invalidStaticPath
+    return invalidStaticPath;
   }
-  return absolutePath
+  return absolutePath;
 };
-
-const getIconAbsolutePath = (pathName) => {
+const getIconAbsolutePath = pathName => {
   const relativePath = pathName.startsWith('/static/icons/') ? pathName.slice('/static/icons/'.length) : pathName.slice('/icons/'.length);
   if (!relativePath || relativePath.includes('/') || relativePath.includes('\\') || relativePath.includes('..')) {
-    return invalidIconsPath
+    return invalidIconsPath;
   }
   const codiconPath = join(codiconsIconsPath, relativePath);
   if (existsSync(codiconPath)) {
-    return codiconPath
+    return codiconPath;
   }
   const staticIconPath = join(STATIC, 'icons', relativePath);
   if (existsSync(staticIconPath)) {
-    return staticIconPath
+    return staticIconPath;
   }
-  return invalidIconsPath
+  return invalidIconsPath;
 };
-
-const getAbsolutePath = (pathName) => {
+const getAbsolutePath = pathName => {
   if (pathName === '/') {
-    return join(STATIC, 'index.html')
+    return join(STATIC, 'index.html');
   }
   if (pathName === '/auth/callback') {
-    return join(STATIC, 'auth', 'callback.html')
+    return join(STATIC, 'auth', 'callback.html');
   }
   if (pathName === '/favicon.ico') {
-    return join(STATIC, 'favicon.ico')
+    return join(STATIC, 'favicon.ico');
   }
   if (pathName.startsWith('/icons/') || pathName.startsWith('/static/icons/')) {
-    return getIconAbsolutePath(pathName)
+    return getIconAbsolutePath(pathName);
   }
-  return getContainedPath(STATIC, pathName)
+  return getContainedPath(STATIC, pathName);
 };
-const etag = "W/\"c377d49\"";
+const etag = "W/\"8a228d4\"";
 
 const Etag = 'Etag';
 const IfNotMatch = 'if-none-match';
@@ -94,30 +84,34 @@ const ServerError = 500;
 const NotModifed = 304;
 
 const matchesEtag = (request, etag) => {
-  return request.headers[IfNotMatch] === etag
+  return request.headers?.[IfNotMatch] === etag;
 };
 
 const notFoundResponse = {
   absolutePath: '',
   status: NotFound,
-  headers: {},
+  headers: {}
 };
 
-const isSupportedMethod = (method) => {
-  return method === 'GET' || method === 'HEAD'
+const isSupportedMethod = method => {
+  return method === 'GET' || method === 'HEAD';
 };
 
-const getResponseInfo = async ({ request, isImmutable, applicationName = 'lvce-oss' }) => {
+const getResponseInfo = async ({
+  request,
+  isImmutable,
+  applicationName = 'lvce-oss'
+}) => {
   if (!isSupportedMethod(request.method)) {
     return {
       absolutePath: '',
       status: MethodNotAllowed,
-      headers: {},
-    }
+      headers: {}
+    };
   }
-  const pathname = request.path || request.url.split('?')[0];
-  if(!Object.hasOwn(files, pathname)){
-    return notFoundResponse
+  const pathname = request.path || request.url?.split('?')[0] || '/';
+  if (!Object.hasOwn(files, pathname)) {
+    return notFoundResponse;
   }
   const index = files[pathname];
   const headers$1 = headers[index];
@@ -128,45 +122,52 @@ const getResponseInfo = async ({ request, isImmutable, applicationName = 'lvce-o
       absolutePath: '',
       status: NotModifed,
       headers: {
-        [Etag]: etag$1,
-      },
-    }
+        [Etag]: etag$1
+      }
+    };
   }
   return {
     absolutePath,
     status: Ok,
-    headers: headers$1,
-  }
+    headers: headers$1
+  };
 };
 
 const isImmutable = true;
 
-const getResponse$1 = async (request) => {
-  const { absolutePath, status, headers } = await getResponseInfo({ request, isImmutable: isImmutable });
+const getResponse$1 = async request => {
+  const {
+    absolutePath,
+    status,
+    headers
+  } = await getResponseInfo({
+    request,
+    isImmutable: isImmutable
+  });
   const hasBody = request.method !== 'HEAD';
   if (status === MethodNotAllowed) {
     return {
       headers,
       status,
       body: 'Method not Allowed',
-      hasBody,
-    }
+      hasBody
+    };
   }
   if (status === NotFound) {
     return {
       headers,
       status,
       body: 'Not Found',
-      hasBody,
-    }
+      hasBody
+    };
   }
   if (status === NotModifed) {
     return {
       headers,
       status,
       body: '',
-      hasBody: false,
-    }
+      hasBody: false
+    };
   }
   // TODO maybe read content as blob
   // TODO implment buffering
@@ -176,21 +177,21 @@ const getResponse$1 = async (request) => {
       headers,
       status,
       body: content,
-      hasBody,
-    }
+      hasBody
+    };
   } catch (error) {
     console.error(`[static server] response error at ${request.url} ${error}`);
     return {
       headers: {},
       status: ServerError,
       body: 'Server Error',
-      hasBody: true,
-    }
+      hasBody: true
+    };
   }
 };
 
 const commandMap = {
-  'StaticServer.getResponse': getResponse$1,
+  'StaticServer.getResponse': getResponse$1
 };
 
 const normalizeLine = line => {
@@ -202,7 +203,6 @@ const normalizeLine = line => {
   }
   return line;
 };
-
 const getCombinedMessage = (error, message) => {
   const stringifiedError = normalizeLine(`${error}`);
   if (message) {
@@ -210,13 +210,10 @@ const getCombinedMessage = (error, message) => {
   }
   return stringifiedError;
 };
-
 const NewLine$2 = '\n';
-
 const getNewLineIndex$1 = (string, startIndex = undefined) => {
   return string.indexOf(NewLine$2, startIndex);
 };
-
 const mergeStacks = (parent, child) => {
   if (!child) {
     return parent;
@@ -234,7 +231,6 @@ const mergeStacks = (parent, child) => {
   }
   return child;
 };
-
 class VError extends Error {
   constructor(error, message) {
     const combinedMessage = getCombinedMessage(error, message);
@@ -257,25 +253,19 @@ class VError extends Error {
 const isMessagePort = value => {
   return value && value instanceof MessagePort;
 };
-
 const isMessagePortMain = value => {
   return value && value.constructor && value.constructor.name === 'MessagePortMain';
 };
-
 const isOffscreenCanvas = value => {
   return typeof OffscreenCanvas !== 'undefined' && value instanceof OffscreenCanvas;
 };
-
 const isInstanceOf = (value, constructorName) => {
   return value?.constructor?.name === constructorName;
 };
-
 const isSocket = value => {
   return isInstanceOf(value, 'Socket');
 };
-
 const transferrables = [isMessagePort, isMessagePortMain, isOffscreenCanvas, isSocket];
-
 const isTransferrable = value => {
   for (const fn of transferrables) {
     if (fn(value)) {
@@ -284,7 +274,6 @@ const isTransferrable = value => {
   }
   return false;
 };
-
 const walkValue = (value, transferrables, isTransferrable) => {
   if (!value) {
     return;
@@ -305,13 +294,11 @@ const walkValue = (value, transferrables, isTransferrable) => {
     }
   }
 };
-
 const getTransferrables = value => {
   const transferrables = [];
   walkValue(value, transferrables, isTransferrable);
   return transferrables;
 };
-
 const attachEvents = that => {
   const handleMessage = (...args) => {
     const data = that.getData(...args);
@@ -325,7 +312,6 @@ const attachEvents = that => {
   };
   that.onClose(handleClose);
 };
-
 class Ipc extends EventTarget {
   constructor(rawIpc) {
     super();
@@ -333,17 +319,13 @@ class Ipc extends EventTarget {
     attachEvents(this);
   }
 }
-
 const E_INCOMPATIBLE_NATIVE_MODULE = 'E_INCOMPATIBLE_NATIVE_MODULE';
 const E_MODULES_NOT_SUPPORTED_IN_ELECTRON = 'E_MODULES_NOT_SUPPORTED_IN_ELECTRON';
 const ERR_MODULE_NOT_FOUND = 'ERR_MODULE_NOT_FOUND';
-
 const NewLine$1 = '\n';
-
 const joinLines$1 = lines => {
   return lines.join(NewLine$1);
 };
-
 const RE_AT = /^\s+at/;
 const RE_AT_PROMISE_INDEX = /^\s*at async Promise.all \(index \d+\)$/;
 const isNormalStackLine = line => {
@@ -368,11 +350,9 @@ const getDetails = lines => {
     rest: lines.slice(index, lastIndex)
   };
 };
-
 const splitLines$1 = lines => {
   return lines.split(NewLine$1);
 };
-
 const RE_MESSAGE_CODE_BLOCK_START = /^Error: The module '.*'$/;
 const RE_MESSAGE_CODE_BLOCK_END = /^\s* at/;
 const isMessageCodeBlockStartIndex = line => {
@@ -389,7 +369,6 @@ const getMessageCodeBlock = stderr => {
   const relevantMessage = relevantLines.join(' ').slice('Error: '.length);
   return relevantMessage;
 };
-
 const isModuleNotFoundMessage = line => {
   return line.includes('[ERR_MODULE_NOT_FOUND]');
 };
@@ -402,27 +381,23 @@ const getModuleNotFoundError = stderr => {
     message
   };
 };
-
 const isModuleNotFoundError = stderr => {
   if (!stderr) {
     return false;
   }
   return stderr.includes('ERR_MODULE_NOT_FOUND');
 };
-
 const isModulesSyntaxError = stderr => {
   if (!stderr) {
     return false;
   }
   return stderr.includes('SyntaxError: Cannot use import statement outside a module');
 };
-
 const RE_NATIVE_MODULE_ERROR = /^innerError Error: Cannot find module '.*.node'/;
 const RE_NATIVE_MODULE_ERROR_2 = /was compiled against a different Node.js version/;
 const isUnhelpfulNativeModuleError = stderr => {
   return RE_NATIVE_MODULE_ERROR.test(stderr) && RE_NATIVE_MODULE_ERROR_2.test(stderr);
 };
-
 const getNativeModuleErrorMessage = stderr => {
   const message = getMessageCodeBlock(stderr);
   return {
@@ -457,7 +432,6 @@ const getHelpfulChildProcessError = (stdout, stderr) => {
     stack: rest
   };
 };
-
 class IpcError extends VError {
   // @ts-ignore
   constructor(betterMessage, stdout = '', stderr = '') {
@@ -471,7 +445,14 @@ class IpcError extends VError {
       const cause = new Error(message);
       // @ts-ignore
       cause.code = code;
-      cause.stack = stack;
+      if (stack) {
+        Object.defineProperty(cause, 'stack', {
+          configurable: true,
+          enumerable: false,
+          value: stack,
+          writable: true
+        });
+      }
       super(cause, betterMessage);
     } else {
       super(betterMessage);
@@ -484,9 +465,7 @@ class IpcError extends VError {
     this.stderr = stderr;
   }
 }
-
 const readyMessage = 'ready';
-
 const getActualData = (message, handle) => {
   if (handle) {
     return {
@@ -496,7 +475,6 @@ const getActualData = (message, handle) => {
   }
   return message;
 };
-
 const getTransferrablesNode = value => {
   const transferrables = getTransferrables(value);
   if (transferrables.length === 0) {
@@ -504,7 +482,6 @@ const getTransferrablesNode = value => {
   }
   return transferrables[0];
 };
-
 const listen$5 = async () => {
   if (!process.send) {
     throw new IpcError('process.send must be defined');
@@ -538,14 +515,12 @@ class IpcChildWithNodeForkedProcess extends Ipc {
 const wrap$d = process => {
   return new IpcChildWithNodeForkedProcess(process);
 };
-
 const IpcChildWithNodeForkedProcess$1 = {
   __proto__: null,
   listen: listen$5,
   signal: signal$7,
   wrap: wrap$d
 };
-
 const listen$3 = async () => {
   const {
     parentPort
@@ -582,7 +557,6 @@ class IpcChildWithNodeWorker extends Ipc {
 const wrap$b = parentPort => {
   return new IpcChildWithNodeWorker(parentPort);
 };
-
 const IpcChildWithNodeWorker$1 = {
   __proto__: null,
   listen: listen$3,
@@ -596,7 +570,6 @@ class CommandNotFoundError extends Error {
     this.name = 'CommandNotFoundError';
   }
 }
-
 const commands = Object.create(null);
 const register = commandMap => {
   Object.assign(commands, commandMap);
@@ -604,7 +577,6 @@ const register = commandMap => {
 const getCommand = key => {
   return commands[key];
 };
-
 const execute = (command, ...args) => {
   const fn = getCommand(command);
   if (!fn) {
@@ -614,7 +586,6 @@ const execute = (command, ...args) => {
 };
 
 const Two$1 = '2.0';
-
 const callbacks = Object.create(null);
 const get = id => {
   return callbacks[id];
@@ -622,21 +593,17 @@ const get = id => {
 const remove = id => {
   delete callbacks[id];
 };
-
 class JsonRpcError extends Error {
   constructor(message) {
     super(message);
     this.name = 'JsonRpcError';
   }
 }
-
 const NewLine = '\n';
-
 const DomException = 'DOMException';
 const ReferenceError$1 = 'ReferenceError';
 const SyntaxError$1 = 'SyntaxError';
 const TypeError$1 = 'TypeError';
-
 const getErrorConstructor = (message, type) => {
   if (type) {
     switch (type) {
@@ -663,7 +630,6 @@ const getErrorConstructor = (message, type) => {
   }
   return Error;
 };
-
 const constructError = (message, type, name) => {
   const ErrorConstructor = getErrorConstructor(message, type);
   if (ErrorConstructor === DOMException && name) {
@@ -678,27 +644,22 @@ const constructError = (message, type, name) => {
   }
   return new ErrorConstructor(message);
 };
-
 const joinLines = lines => {
   return lines.join(NewLine);
 };
-
 const splitLines = lines => {
   return lines.split(NewLine);
 };
-
 const getCurrentStack = () => {
   const stackLinesToSkip = 3;
   const currentStack = joinLines(splitLines(new Error().stack || '').slice(stackLinesToSkip));
   return currentStack;
 };
-
 const getNewLineIndex = (string, startIndex) => {
   {
     return string.indexOf(NewLine);
   }
 };
-
 const getParentStack = error => {
   let parentStack = error.stack || error.data || error.message || '';
   if (parentStack.startsWith('    at')) {
@@ -706,10 +667,8 @@ const getParentStack = error => {
   }
   return parentStack;
 };
-
 const MethodNotFound = -32601;
 const Custom = -32001;
-
 const restoreExistingError = (error, currentStack) => {
   if (typeof error.stack === 'string') {
     error.stack = error.stack + NewLine + currentStack;
@@ -787,7 +746,6 @@ const restoreJsonRpcError = error => {
   }
   return new Error(`JsonRpc Error: ${error}`);
 };
-
 const unwrapJsonRpcResult = responseMessage => {
   if ('error' in responseMessage) {
     const restoredError = restoreJsonRpcError(responseMessage.error);
@@ -798,11 +756,9 @@ const unwrapJsonRpcResult = responseMessage => {
   }
   throw new JsonRpcError('unexpected response message');
 };
-
 const warn = (...args) => {
   console.warn(...args);
 };
-
 const resolve = (id, response) => {
   const fn = get(id);
   if (!fn) {
@@ -813,9 +769,7 @@ const resolve = (id, response) => {
   fn(response);
   remove(id);
 };
-
 const E_COMMAND_NOT_FOUND = 'E_COMMAND_NOT_FOUND';
-
 const getErrorType = prettyError => {
   if (prettyError && prettyError.type) {
     return prettyError.type;
@@ -825,7 +779,6 @@ const getErrorType = prettyError => {
   }
   return undefined;
 };
-
 const isAlreadyStack = line => {
   return line.trim().startsWith('at ');
 };
@@ -857,7 +810,6 @@ const getErrorProperty = (error, prettyError) => {
     message: prettyError.message
   };
 };
-
 const create$1$1 = (id, error) => {
   return {
     error,
@@ -865,14 +817,12 @@ const create$1$1 = (id, error) => {
     jsonrpc: Two$1
   };
 };
-
 const getErrorResponse = (id, error, preparePrettyError, logError) => {
   const prettyError = preparePrettyError(error);
   logError(error, prettyError);
   const errorProperty = getErrorProperty(error, prettyError);
   return create$1$1(id, errorProperty);
 };
-
 const create$5 = (message, result) => {
   return {
     id: message.id,
@@ -880,12 +830,10 @@ const create$5 = (message, result) => {
     result: result ?? null
   };
 };
-
 const getSuccessResponse = (message, result) => {
   const resultProperty = result ?? null;
   return create$5(message, resultProperty);
 };
-
 const getErrorResponseSimple = (id, error) => {
   return {
     error: {
@@ -898,7 +846,6 @@ const getErrorResponseSimple = (id, error) => {
     jsonrpc: Two$1
   };
 };
-
 const getResponse = async (message, ipc, execute, preparePrettyError, logError, requiresSocket) => {
   try {
     const result = requiresSocket(message.method) ? await execute(message.method, ipc, ...message.params) : await execute(message.method, ...message.params);
@@ -910,7 +857,6 @@ const getResponse = async (message, ipc, execute, preparePrettyError, logError,
     return getErrorResponse(message.id, error, preparePrettyError, logError);
   }
 };
-
 const defaultPreparePrettyError = error => {
   return error;
 };
@@ -946,7 +892,6 @@ const normalizeParams = args => {
     resolve: args[3]
   };
 };
-
 const handleJsonRpcMessage = async (...args) => {
   const options = normalizeParams(args);
   const {
@@ -982,172 +927,185 @@ const handleJsonRpcMessage = async (...args) => {
 const Two = '2.0';
 
 const create$4 = (method, params) => {
-    return {
-        jsonrpc: Two,
-        method,
-        params,
-    };
+  return {
+    jsonrpc: Two,
+    method,
+    params
+  };
 };
 
 const create$3 = (id, method, params) => {
-    const message = {
-        id,
-        jsonrpc: Two,
-        method,
-        params,
-    };
-    return message;
+  const message = {
+    id,
+    jsonrpc: Two,
+    method,
+    params
+  };
+  return message;
 };
 
 let id = 0;
 const create$2 = () => {
-    return ++id;
+  return ++id;
 };
 
-const registerPromise = (map) => {
-    const id = create$2();
-    const { promise, resolve } = Promise.withResolvers();
-    map[id] = resolve;
-    return { id, promise };
+const registerPromise = map => {
+  const id = create$2();
+  const {
+    promise,
+    resolve
+  } = Promise.withResolvers();
+  map[id] = resolve;
+  return {
+    id,
+    promise
+  };
 };
 
 const invokeHelper = async (callbacks, ipc, method, params, useSendAndTransfer) => {
-    const { id, promise } = registerPromise(callbacks);
-    const message = create$3(id, method, params);
-    if (useSendAndTransfer && ipc.sendAndTransfer) {
-        ipc.sendAndTransfer(message);
+  const {
+    id,
+    promise
+  } = registerPromise(callbacks);
+  const message = create$3(id, method, params);
+  if (useSendAndTransfer && ipc.sendAndTransfer) {
+    ipc.sendAndTransfer(message);
+  } else {
+    ipc.send(message);
+  }
+  const responseMessage = await promise;
+  return unwrapJsonRpcResult(responseMessage);
+};
+const createRpc = ipc => {
+  const callbacks = Object.create(null);
+  ipc._resolve = (id, response) => {
+    const fn = callbacks[id];
+    if (!fn) {
+      console.warn(`callback ${id} may already be disposed`);
+      return;
     }
-    else {
-        ipc.send(message);
+    fn(response);
+    delete callbacks[id];
+  };
+  const rpc = {
+    async dispose() {
+      await ipc?.dispose();
+    },
+    invoke(method, ...params) {
+      return invokeHelper(callbacks, ipc, method, params, false);
+    },
+    invokeAndTransfer(method, ...params) {
+      return invokeHelper(callbacks, ipc, method, params, true);
+    },
+    // @ts-ignore
+    ipc,
+    /**
+     * @deprecated
+     */
+    send(method, ...params) {
+      const message = create$4(method, params);
+      ipc.send(message);
     }
-    const responseMessage = await promise;
-    return unwrapJsonRpcResult(responseMessage);
-};
-const createRpc = (ipc) => {
-    const callbacks = Object.create(null);
-    ipc._resolve = (id, response) => {
-        const fn = callbacks[id];
-        if (!fn) {
-            console.warn(`callback ${id} may already be disposed`);
-            return;
-        }
-        fn(response);
-        delete callbacks[id];
-    };
-    const rpc = {
-        async dispose() {
-            await ipc?.dispose();
-        },
-        invoke(method, ...params) {
-            return invokeHelper(callbacks, ipc, method, params, false);
-        },
-        invokeAndTransfer(method, ...params) {
-            return invokeHelper(callbacks, ipc, method, params, true);
-        },
-        // @ts-ignore
-        ipc,
-        /**
-         * @deprecated
-         */
-        send(method, ...params) {
-            const message = create$4(method, params);
-            ipc.send(message);
-        },
-    };
-    return rpc;
+  };
+  return rpc;
 };
 
 const requiresSocket = () => {
-    return false;
+  return false;
 };
-const preparePrettyError = (error) => {
-    return error;
+const preparePrettyError = error => {
+  return error;
 };
 const logError = () => {
-    // handled by renderer worker
+  // handled by renderer worker
 };
-const handleMessage = (event) => {
-    const actualRequiresSocket = event?.target?.requiresSocket || requiresSocket;
-    const actualExecute = event?.target?.execute || execute;
-    return handleJsonRpcMessage(event.target, event.data, actualExecute, event.target._resolve, preparePrettyError, logError, actualRequiresSocket);
+const handleMessage = event => {
+  const actualRequiresSocket = event?.target?.requiresSocket || requiresSocket;
+  const actualExecute = event?.target?.execute || execute;
+  return handleJsonRpcMessage(event.target, event.data, actualExecute, event.target._resolve, preparePrettyError, logError, actualRequiresSocket);
 };
 
-const handleIpc = (ipc) => {
-    if ('addEventListener' in ipc) {
-        ipc.addEventListener('message', handleMessage);
-    }
-    else if ('on' in ipc) {
-        // deprecated
-        ipc.on('message', handleMessage);
-    }
+const handleIpc = ipc => {
+  if ('addEventListener' in ipc) {
+    ipc.addEventListener('message', handleMessage);
+  } else if ('on' in ipc) {
+    // deprecated
+    ipc.on('message', handleMessage);
+  }
 };
 
 const listen$2 = async (module, options) => {
-    const rawIpc = await module.listen(options);
-    if (module.signal) {
-        module.signal(rawIpc);
-    }
-    const ipc = module.wrap(rawIpc);
-    return ipc;
+  const rawIpc = await module.listen(options);
+  if (module.signal) {
+    module.signal(rawIpc);
+  }
+  const ipc = module.wrap(rawIpc);
+  return ipc;
 };
 
-const create$1 = async ({ commandMap }) => {
-    // TODO create a commandMap per rpc instance
-    register(commandMap);
-    const ipc = await listen$2(IpcChildWithNodeForkedProcess$1);
-    handleIpc(ipc);
-    const rpc = createRpc(ipc);
-    return rpc;
+const create$1 = async ({
+  commandMap
+}) => {
+  // TODO create a commandMap per rpc instance
+  register(commandMap);
+  const ipc = await listen$2(IpcChildWithNodeForkedProcess$1);
+  handleIpc(ipc);
+  const rpc = createRpc(ipc);
+  return rpc;
 };
 
-const create = async ({ commandMap }) => {
-    // TODO create a commandMap per rpc instance
-    register(commandMap);
-    const ipc = await listen$2(IpcChildWithNodeWorker$1);
-    handleIpc(ipc);
-    const rpc = createRpc(ipc);
-    return rpc;
+const create = async ({
+  commandMap
+}) => {
+  // TODO create a commandMap per rpc instance
+  register(commandMap);
+  const ipc = await listen$2(IpcChildWithNodeWorker$1);
+  handleIpc(ipc);
+  const rpc = createRpc(ipc);
+  return rpc;
 };
 
 const NodeWorker = 1;
 const NodeForkedProcess = 2;
 const ElectronUtilityProcess = 3;
-
-const Auto = (argv) => {
+const Auto = argv => {
   if (argv.includes('--ipc-type=node-worker')) {
-    return NodeWorker
+    return NodeWorker;
   }
   if (argv.includes('--ipc-type=node-forked-process')) {
-    return NodeForkedProcess
+    return NodeForkedProcess;
   }
   if (argv.includes('--ipc-type=electron-utility-process')) {
-    return ElectronUtilityProcess
+    return ElectronUtilityProcess;
   }
-  throw new Error(`[file-system-process] unknown ipc type`)
+  throw new Error(`[file-system-process] unknown ipc type`);
 };
 
-const getModule = (method) => {
+const getModule = method => {
   switch (method) {
     case NodeForkedProcess:
-      return create$1
+      return create$1;
     case NodeWorker:
-      return create
+      return create;
     default:
-      throw new Error('unexpected ipc type')
+      throw new Error('unexpected ipc type');
   }
 };
 
-const listen$1 = async ({ method, ...params }) => {
+const listen$1 = async ({
+  method,
+  ...params
+}) => {
   const create = getModule(method);
   // @ts-ignore
   const rpc = await create(params);
-  return rpc
+  return rpc;
 };
 
-const listen = async (argv) => {
+const listen = async argv => {
   await listen$1({
     method: Auto(argv),
-    commandMap: commandMap,
+    commandMap: commandMap
   });
 };