@lvce-editor/shared-process 0.12.0 → 0.12.1

package/src/parts/ExtractZip/ExtractZip.js

@@ -1,5 +1,5 @@
-import extract from 'extract-zip'
 import { mkdir } from 'node:fs/promises'
+import extract from 'extract-zip'
 import VError from 'verror'
 
 export const extractZip = async ({ inFile, outDir }) => {

package/src/parts/GetResponse/GetResponse.js

@@ -3,6 +3,7 @@ import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
 import * as JsonRpcErrorCode from '../JsonRpcErrorCode/JsonRpcErrorCode.js'
 import * as JsonRpcVersion from '../JsonRpcVersion/JsonRpcVersion.js'
 import * as PrettyError from '../PrettyError/PrettyError.js'
+import * as PrintPrettyError from '../PrintPrettyError/PrintPrettyError.js'
 import { requiresSocket } from '../RequiresSocket/RequiresSocket.js'
 
 export const getResponse = async (message, handle) => {
@@ -40,7 +41,7 @@ export const getResponse = async (message, handle) => {
       }
     }
     const prettyError = PrettyError.prepare(error)
-    PrettyError.print(prettyError, `[shared-process] `)
+    PrintPrettyError.printPrettyError(prettyError, `[shared-process] `)
     return {
       jsonrpc: JsonRpcVersion.Two,
       id: message.id,

package/src/parts/GitLsFiles/GitLsFiles.ipc.js

@@ -4,4 +4,6 @@ export const name = 'GitLsFiles'
 
 export const Commands = {
   gitLsFiles: GitLsFiles.gitLsFiles,
+  gitLsFilesHash: GitLsFiles.gitLsFilesHash,
+  resolveGit: GitLsFiles.resolveGit,
 }

package/src/parts/GitLsFiles/GitLsFiles.js

@@ -1,9 +1,25 @@
-import * as Exec from '../Exec/Exec.js'
+import * as ExecCommand from '../ExecCommand/ExecCommand.js'
+import * as Hash from '../Hash/Hash.js'
 
-export const gitLsFiles = async (cwd, limit) => {
-  const { stdout, stderr } = await Exec.exec('git', ['ls-files'], {
+export const gitLsFiles = async (gitPath, cwd, limit) => {
+  const { stdout, stderr } = await ExecCommand.execCommand(gitPath, ['ls-files'], {
     cwd,
   })
-  // TODO limit stdout lines to given limit
-  return stdout
+  const hash = Hash.fromString(stdout)
+  return {
+    stdout,
+    cacheId: hash,
+  }
+}
+
+export const gitLsFilesHash = async (gitPath, cwd, limit) => {
+  const hash = await ExecCommand.execCommandHash(gitPath, ['ls-files'], {
+    cwd,
+  })
+  return hash
+}
+
+export const resolveGit = async () => {
+  const bin = ExecCommand.execSync(`which git`)
+  return bin
 }

package/src/parts/Hash/Hash.js

@@ -0,0 +1,7 @@
+import * as NodeCrypto from 'node:crypto'
+
+export const fromString = (content) => {
+  return NodeCrypto.createHash('sha1').update(content).digest('hex')
+}
+
+export const { createHash } = NodeCrypto

package/src/parts/IpcChild/IpcChild.js

@@ -0,0 +1,6 @@
+import * as IpcChildModule from '../IpcChildModule/IpcChildModule.js'
+
+export const listen = async ({ method }) => {
+  const module = await IpcChildModule.getModule(method)
+  return module.listen()
+}

package/src/parts/IpcChildModule/IpcChildModule.js

@@ -0,0 +1,12 @@
+import * as IpcChildType from '../IpcChildType/IpcChildType.js'
+
+export const getModule = (method) => {
+  switch (method) {
+    case IpcChildType.NodeForkedProcess:
+      return import('../IpcChildWithNodeForkedProcess/IpcChildWithNodeForkedProcess.js')
+    case IpcChildType.NodeWorker:
+      return import('../IpcChildWithNodeWorker/IpcChildWithNodeWorker.js')
+    default:
+      throw new Error('unexpected ipc type')
+  }
+}

package/src/parts/IpcChildType/IpcChildType.js

@@ -0,0 +1,13 @@
+export const NodeWorker = 1
+export const NodeForkedProcess = 2
+
+export const Auto = () => {
+  const { argv } = process
+  if (argv.includes('--ipc-type=node-worker')) {
+    return NodeWorker
+  }
+  if (argv.includes('--ipc-type=node-forked-process')) {
+    return NodeForkedProcess
+  }
+  throw new Error(`[shared-process] unknown ipc type`)
+}

package/src/parts/IpcChildWithNodeForkedProcess/IpcChildWithNodeForkedProcess.js

@@ -0,0 +1,19 @@
+export const listen = async () => {
+  return process
+}
+
+export const wrap = (process) => {
+  return {
+    process,
+    on(event, listener) {
+      this.process.on(event, listener)
+    },
+    off(event, listener) {
+      this.process.off(event, listener)
+    },
+    send(message) {
+      this.process.send(message)
+    },
+    dispose() {},
+  }
+}

package/src/parts/IpcChildWithNodeWorker/IpcChildWithNodeWorker.js

@@ -0,0 +1,27 @@
+import { parentPort } from 'node:worker_threads'
+
+export const listen = async () => {
+  if (!parentPort) {
+    throw new Error('parentPort is required')
+  }
+  parentPort.postMessage('ready')
+  return parentPort
+}
+
+export const wrap = (parentPort) => {
+  return {
+    parentPort,
+    on(event, listener) {
+      this.parentPort.on(event, listener)
+    },
+    off(event, listener) {
+      this.parentPort.off(event, listener)
+    },
+    send(message) {
+      this.parentPort.postMessage(message)
+    },
+    dispose() {
+      this.parentPort.close()
+    },
+  }
+}

package/src/parts/MergeStacks/MergeStacks.js

@@ -0,0 +1,19 @@
+import * as NormalizeErrorLine from '../NormalizeErrorLine/NormalizeErrorLine.js'
+
+export const mergeStacks = (parent, child) => {
+  if (!child) {
+    return parent
+  }
+  const parentNewLineIndex = parent.indexOf('\n')
+  const childNewLineIndex = child.indexOf('\n')
+  if (childNewLineIndex === -1) {
+    return parent
+  }
+  const parentFirstLine = parent.slice(0, parentNewLineIndex)
+  const childRest = child.slice(childNewLineIndex)
+  const childFirstLine = NormalizeErrorLine.normalizeLine(child.slice(0, childNewLineIndex))
+  if (parentFirstLine.includes(childFirstLine)) {
+    return parentFirstLine + childRest
+  }
+  return child
+}

package/src/parts/ModuleMap/ModuleMap.js

@@ -1,3 +1,4 @@
+import { CommandNotFoundError } from '../CommandNotFoundError/CommandNotFoundError.js'
 import * as ModuleId from '../ModuleId/ModuleId.js'
 
 export const getModuleId = (commandId) => {
@@ -93,6 +94,8 @@ export const getModuleId = (commandId) => {
     case 'FileSystem.writeFile':
       return ModuleId.FileSystem
     case 'GitLsFiles.gitLsFiles':
+    case 'GitLsFiles.gitLsFilesHash':
+    case 'GitLsFiles.resolveGit':
       return ModuleId.GitLsFiles
     case 'Native.openFolder':
       return ModuleId.Native
@@ -137,6 +140,6 @@ export const getModuleId = (commandId) => {
     case 'Workspace.resolveRoot':
       return ModuleId.Workspace
     default:
-      throw new Error(`command ${commandId} not found`)
+      throw new CommandNotFoundError(commandId)
   }
 }

package/src/parts/NormalizeErrorLine/NormalizeErrorLine.js

@@ -0,0 +1,9 @@
+export const normalizeLine = (line) => {
+  if (line.startsWith('Error: ')) {
+    return line.slice(`Error: `.length)
+  }
+  if (line.startsWith('VError: ')) {
+    return line.slice(`VError: `.length)
+  }
+  return line
+}

package/src/parts/OutputChannel/OutputChannel.ipc.js

@@ -1,7 +1,7 @@
 import * as Assert from '../Assert/Assert.js'
 import * as Command from '../Command/Command.js'
-import * as OutputChannel from './OutputChannel.js'
 import * as JsonRpcVersion from '../JsonRpcVersion/JsonRpcVersion.js'
+import * as OutputChannel from './OutputChannel.js'
 
 export const state = {
   outputChannels: Object.create(null),

package/src/parts/ParentIpc/ParentIpc.js

@@ -8,7 +8,7 @@ import * as ExtensionHostHelperProcessIpc from '../ExtensionHostHelperProcessIpc
 import * as ExtensionHostIpc from '../ExtensionHostIpc/ExtensionHostIpc.js'
 import * as ExtensionHostRpc from '../ExtensionHostRpc/ExtensionHostRpc.js'
 import * as GetResponse from '../GetResponse/GetResponse.js'
-
+import * as ProtocolType from '../ProtocolType/ProtocolType.js'
 // TODO add tests for this
 
 // TODO handle structure: one shared process multiple extension hosts
@@ -42,17 +42,13 @@ const handleWebSocketSharedProcess = (message, handle) => {
     }
     console.info('[info shared process: handle error]', error)
   })
-  Command.execute(
-    /* WebSocketServer.handleUpgrade */ 'WebSocketServer.handleUpgrade',
-    /* message */ message,
-    /* handle */ handle
-  )
+  Command.execute(/* WebSocketServer.handleUpgrade */ 'WebSocketServer.handleUpgrade', /* message */ message, /* handle */ handle)
 }
 
 // TODO lazyload modules for spawning extension host, they are only needed later
 const handleWebSocketExtensionHost = async (message, handle) => {
   // console.log('[shared-process] received extension host websocket', message)
-  const ipc = ExtensionHostIpc.create()
+  const ipc = await ExtensionHostIpc.create()
   console.info('[sharedprocess] creating extension ipc')
   const rpc = await ExtensionHostRpc.create(ipc, handle)
   console.info('[sharedprocess] created extension host rpc')
@@ -77,11 +73,11 @@ const handleWebSocket = (message, handle) => {
     throw new VError('missing sec websocket protocol header')
   }
   switch (protocol) {
-    case 'lvce.shared-process':
+    case ProtocolType.SharedProcess:
       return handleWebSocketSharedProcess(message, handle)
-    case 'lvce.extension-host':
+    case ProtocolType.ExtensionHost:
       return handleWebSocketExtensionHost(message, handle)
-    case 'lvce.extension-host-helper-process':
+    case ProtocolType.ExtensionHostHelperProcess:
       return handleWebSocketExtensionHostHelperProcess(message, handle)
     default:
       console.warn(`unsupported sec-websocket-procotol ${protocol}`)

package/src/parts/ParseInt/ParseInt.js

@@ -0,0 +1,3 @@
+export const parseInt = (string) => {
+  return Number.parseInt(string, 10)
+}

package/src/parts/Platform/Platform.js

@@ -1,9 +1,10 @@
-import { extensionHostPath } from '@lvce-editor/extension-host'
 import { homedir, tmpdir } from 'node:os'
-import { dirname, join, resolve, sep } from 'node:path'
-import { fileURLToPath, pathToFileURL } from 'node:url'
+import { join, resolve, sep } from 'node:path'
+import { pathToFileURL } from 'node:url'
 import { xdgCache, xdgConfig, xdgData, xdgState } from 'xdg-basedir'
+import * as DesktopType from '../DesktopType/DesktopType.js'
 import * as Path from '../Path/Path.js'
+import * as Process from '../Process/Process.js'
 import * as Root from '../Root/Root.js'
 
 const { env, platform } = process
@@ -24,8 +25,6 @@ export const homeDir = isWindows ? '' : homedir()
 
 export const appDir = Root.root
 
-const __dirname = dirname(fileURLToPath(import.meta.url))
-
 export const getExtensionsPath = () => {
   return Path.join(dataDir, 'extensions')
 }
@@ -55,32 +54,27 @@ export const getChromeExtensionsPath = () => {
 }
 
 export const getMarketplaceUrl = () => {
-  return (
-    env.LVCE_MARKETPLACE_URL || 'https://marketplace.22e924c84de072d4b25b.com'
-  )
+  return env.LVCE_MARKETPLACE_URL || 'https://marketplace.22e924c84de072d4b25b.com'
 }
 
 export const getDesktop = () => {
   const { ORIGINAL_XDG_CURRENT_DESKTOP, XDG_CURRENT_DESKTOP } = env
-  if (
-    ORIGINAL_XDG_CURRENT_DESKTOP &&
-    ORIGINAL_XDG_CURRENT_DESKTOP !== 'undefined'
-  ) {
+  if (ORIGINAL_XDG_CURRENT_DESKTOP && ORIGINAL_XDG_CURRENT_DESKTOP !== 'undefined') {
     if (ORIGINAL_XDG_CURRENT_DESKTOP === 'ubuntu:GNOME') {
-      return 'gnome'
+      return DesktopType.Gnome
     }
     return ORIGINAL_XDG_CURRENT_DESKTOP
   }
   if (XDG_CURRENT_DESKTOP) {
     if (XDG_CURRENT_DESKTOP === 'ubuntu:GNOME') {
-      return 'gnome'
+      return DesktopType.Gnome
     }
     return XDG_CURRENT_DESKTOP
   }
   if (isWindows) {
-    return 'windows'
+    return DesktopType.Windows
   }
-  return ''
+  return DesktopType.Unknown
 }
 
 export const getPathSeparator = () => {
@@ -99,7 +93,10 @@ export const getUserSettingsPath = () => {
   return Path.join(configDir, 'settings.json')
 }
 
-export const getExtensionHostPath = () => {
+export const getExtensionHostPath = async () => {
+  const { extensionHostPath } = await import(
+    '@lvce-editor/extension-host'
+  )
   return extensionHostPath
 }
 
@@ -125,16 +122,14 @@ export const setEnvironmentVariables = (variables) => {
 
 export const getTestPath = () => {
   if (env.TEST_PATH) {
-    const testPath =
-      '/remote' +
-      pathToFileURL(Path.join(process.cwd(), env.TEST_PATH)).toString().slice(7)
+    const testPath = '/remote' + pathToFileURL(Path.join(process.cwd(), env.TEST_PATH)).toString().slice(7)
     return testPath
   }
   return '/packages/extension-host-worker-tests'
 }
 
 export const getNodePath = () => {
-  return process.argv[0]
+  return Process.argv[0]
 }
 
 export const getTmpDir = () => {

package/src/parts/Preferences/Preferences.js

@@ -1,6 +1,7 @@
 import VError from 'verror'
 import * as JsonFile from '../JsonFile/JsonFile.js'
 import * as Platform from '../Platform/Platform.js'
+import * as Process from '../Process/Process.js'
 
 // TODO need jsonc parser for settings with comments
 
@@ -38,7 +39,7 @@ export const getDefaultPreferences = async () => {
 //                                   -> on idle check preferences
 
 const getOverrides = () => {
-  const argvSliced = process.argv.slice(2)
+  const argvSliced = Process.argv.slice(2)
   const overrides = {}
   for (const argv of argvSliced) {
     if (argv.startsWith('--theme=')) {

package/src/parts/PrettyError/PrettyError.js

@@ -1,9 +1,10 @@
 import { codeFrameColumns } from '@babel/code-frame'
-import cleanStack from 'clean-stack'
 import { LinesAndColumns } from 'lines-and-columns'
 import { readFileSync } from 'node:fs'
 import { fileURLToPath } from 'node:url'
+import * as CleanStack from '../CleanStack/CleanStack.js'
 import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
+import * as JoinLines from '../JoinLines/JoinLines.js'
 import * as Json from '../Json/Json.js'
 import * as SplitLines from '../SplitLines/SplitLines.js'
 
@@ -14,11 +15,10 @@ const getActualPath = (fileUri) => {
   return fileUri
 }
 
-const RE_MODULE_NOT_FOUND_STACK =
-  /Cannot find package '([^']+)' imported from (.+)$/
+const RE_MODULE_NOT_FOUND_STACK = /Cannot find package '([^']+)' imported from (.+)$/
 
 const prepareModuleNotFoundError = (error) => {
-  const message = error.message
+  const { message } = error
   const match = message.match(RE_MODULE_NOT_FOUND_STACK)
   if (!match) {
     return {
@@ -32,7 +32,7 @@ const prepareModuleNotFoundError = (error) => {
   const rawLines = readFileSync(importedFrom, 'utf-8')
   let line = 0
   let column = 0
-  const splittedLines = rawLines.split('\n')
+  const splittedLines = SplitLines.splitLines(rawLines)
   for (let i = 0; i < splittedLines.length; i++) {
     const splittedLine = splittedLines[i]
     const index = splittedLine.indexOf(notFoundModule)
@@ -50,12 +50,8 @@ const prepareModuleNotFoundError = (error) => {
   }
   const codeFrame = codeFrameColumns(rawLines, location)
   const stackLines = SplitLines.splitLines(error.stack)
-  const newStackLines = [
-    stackLines[0],
-    `    at ${importedFrom}:${line}:${column}`,
-    ...stackLines.slice(1),
-  ]
-  const newStack = newStackLines.join('\n')
+  const newStackLines = [stackLines[0], `    at ${importedFrom}:${line}:${column}`, ...stackLines.slice(1)]
+  const newStack = JoinLines.joinLines(newStackLines)
   return {
     message,
     stack: newStack,
@@ -67,14 +63,14 @@ export const prepare = (error) => {
   if (error && error.code === ErrorCodes.ERR_MODULE_NOT_FOUND) {
     return prepareModuleNotFoundError(error)
   }
-  const message = error.message
+  const { message } = error
   if (error && error.cause) {
     const cause = error.cause()
     if (cause) {
       error = cause
     }
   }
-  const cleanedStack = cleanStack(error.stack)
+  const cleanedStack = CleanStack.cleanStack(error.stack)
   const lines = SplitLines.splitLines(cleanedStack)
   const file = lines[1]
   let codeFrame = ''
@@ -99,7 +95,7 @@ export const prepare = (error) => {
       codeFrame = codeFrameColumns(rawLines, location)
     }
   }
-  const relevantStack = lines.slice(1).join('\n')
+  const relevantStack = JoinLines.joinLines(lines.slice(1))
   return {
     message,
     stack: relevantStack,
@@ -121,10 +117,9 @@ export const prepareJsonError = (json, property, message) => {
   }
   if (index !== -1) {
     const lines = new LinesAndColumns(string)
-    const location = lines.locationForIndex(
-      index + stringifiedPropertyName.length + 1
-    )
+    const location = lines.locationForIndex(index + stringifiedPropertyName.length + 1)
     const codeFrame = codeFrameColumns(string, {
+      // @ts-ignore
       start: { line: location.line + 1, column: location.column + 1 },
     })
     jsonError.codeFrame = codeFrame
@@ -132,9 +127,3 @@ export const prepareJsonError = (json, property, message) => {
   // jsonError.stack = `${bottomMessage}\n    at ${filePath}`
   return jsonError
 }
-
-export const print = (prettyError, prefix = '') => {
-  console.error(
-    `${prefix}Error: ${prettyError.message}\n\n${prettyError.codeFrame}\n\n${prettyError.stack}`
-  )
-}

package/src/parts/PrintPrettyError/PrintPrettyError.js

@@ -0,0 +1,3 @@
+export const printPrettyError = (prettyError, prefix = '') => {
+  console.error(`${prefix}Error: ${prettyError.message}\n\n${prettyError.codeFrame}\n\n${prettyError.stack}`)
+}

package/src/parts/Process/Process.js

@@ -14,7 +14,7 @@ export const setExitCode = (exitCode) => {
   process.exitCode = exitCode
 }
 
-export const argv = process.argv
+export const { argv } = process
 
 export const cwd = () => {
   return process.cwd()
@@ -28,4 +28,4 @@ export const isConnected = () => {
   return process.connected
 }
 
-export const platform = process.platform
+export const { platform } = process

package/src/parts/ProtocolType/ProtocolType.js

@@ -0,0 +1,3 @@
+export const SharedProcess = 'lvce.shared-process'
+export const ExtensionHost = 'lvce.extension-host'
+export const ExtensionHostHelperProcess = 'lvce.extension-host-helper-process'

package/src/parts/RecentlyOpened/RecentlyOpened.js

@@ -1,4 +1,4 @@
-import { dirname } from 'path'
+import { dirname } from 'node:path'
 import VError from 'verror'
 import * as Assert from '../Assert/Assert.js'
 import { FileNotFoundError } from '../Error/FileNotFoundError.js'

package/src/parts/Stats/Stats.js

@@ -2,6 +2,7 @@
 
 import * as Exec from '../Exec/Exec.js'
 import * as SplitLines from '../SplitLines/SplitLines.js'
+import * as ParseInt from '../ParseInt/ParseInt.js'
 
 const PID_CMD = /^\s*(\d+)\s+(\d+)\s+(\d+\.\d+)\s+(\d+\.\d+)\s+(.+)$/
 
@@ -9,11 +10,11 @@ const parsePsOutputLine = (line) => {
   const matches = PID_CMD.exec(line.trim())
   if (matches && matches.length === 6) {
     return {
-      pid: Number.parseInt(matches[1]),
-      ppid: Number.parseInt(matches[2]),
+      pid: ParseInt.parseInt(matches[1]),
+      ppid: ParseInt.parseInt(matches[2]),
       cwd: matches[5],
-      load: Number.parseInt(matches[3]),
-      mem: Number.parseInt(matches[4]),
+      load: ParseInt.parseInt(matches[3]),
+      mem: ParseInt.parseInt(matches[4]),
     }
   }
 }
@@ -23,13 +24,9 @@ const parsePsOutput = (stdout, rootPid) => {
 }
 
 const getPsOutput = async (rootPid) => {
-  const { stdout } = await Exec.exec(
-    'ps',
-    ['-g', `${rootPid}`, '-a', '-o', 'pid=,ppid=,pcpu=,pmem=,command='],
-    {
-      shell: true,
-    }
-  )
+  const { stdout } = await Exec.exec('ps', ['-g', `${rootPid}`, '-a', '-o', 'pid=,ppid=,pcpu=,pmem=,command='], {
+    shell: true,
+  })
   return stdout
 }
 

package/src/parts/SymLink/SymLink.js

@@ -1,17 +1,5 @@
-import { mkdir, symlink } from 'node:fs/promises'
-import { dirname } from 'node:path'
-import { FileSystemError } from '../Error/FileSystemError.js'
-
-// TODO maybe move this to FileSystem module
+import symlinkDir from 'symlink-dir'
 
 export const createSymLink = async (target, path) => {
-  try {
-    await mkdir(dirname(path), { recursive: true })
-    await symlink(target, path)
-  } catch (error) {
-    throw new FileSystemError(
-      error,
-      `Failed to create symbolic link from ${target} to ${path}`
-    )
-  }
+  await symlinkDir(target, path)
 }

package/src/parts/TextDocument/TextDocument.js

@@ -1,3 +1,5 @@
+import * as JoinLines from '../JoinLines/JoinLines.js'
+
 export const state = {
   textDocuments: Object.create(null),
   /** @type{any[]} */
@@ -29,7 +31,7 @@ export const applyEdit = (socket, textDocument, documentEdits) => {
 }
 
 export const getText = (textDocument) => {
-  return textDocument.lines.join('\n')
+  return JoinLines.joinLines(textDocument.lines)
 }
 
 export const onChange = (listener) => {

package/src/parts/VError/VError.js

@@ -1,38 +1,21 @@
+import * as MergeStacks from '../MergeStacks/MergeStacks.js'
+import * as NormalizeErrorLine from '../NormalizeErrorLine/NormalizeErrorLine.js'
+
 const getCombinedMessage = (error, message) => {
-  let stringifiedError = `${error}`
-  if (stringifiedError.startsWith('Error: ')) {
-    stringifiedError = stringifiedError.slice(`Error: `.length)
-  } else if (stringifiedError.startsWith('VError: ')) {
-    stringifiedError = stringifiedError.slice(`VError: `.length)
-  }
+  const stringifiedError = NormalizeErrorLine.normalizeLine(`${error}`)
   if (message) {
     return `${message}: ${stringifiedError}`
   }
   return stringifiedError
 }
 
-const mergeStacks = (parent, child) => {
-  if (!child) {
-    return parent
-  }
-  const parentNewLineIndex = parent.indexOf('\n')
-  const childNewLineIndex = child.indexOf('\n')
-  const parentFirstLine = parent.slice(0, parentNewLineIndex)
-  const childRest = child.slice(childNewLineIndex)
-  const childFirstLine = child.slice(0, childNewLineIndex)
-  if (parentFirstLine.includes(childFirstLine)) {
-    return parentFirstLine + childRest
-  }
-  return child
-}
-
 export class VError extends Error {
   constructor(error, message) {
     const combinedMessage = getCombinedMessage(error, message)
     super(combinedMessage)
     this.name = 'VError'
     if (error instanceof Error) {
-      this.stack = mergeStacks(this.stack, error.stack)
+      this.stack = MergeStacks.mergeStacks(this.stack, error.stack)
     }
     if (error.codeFrame) {
       this.codeFrame = error.codeFrame