anchor.diff:          |> Option.map (fun e -> e.extensionPath)
   
   
  +module CrossSpawn = 
  +    open Node.ChildProcess
  +    type [<AllowNullLiteral>] IExports = 
  +        abstract spawn: command: string * options: ExecOptions -> ChildProcess
  +        abstract spawn: command: string * args: ResizeArray<string>  * ?options: ExecOptions -> ChildProcess
  +
  +    let crossSpawn: IExports = Fable.Core.JsInterop.importAll "cross-spawn"
  +
   //---------------------------------------------------
   //Process Helpers
   //---------------------------------------------------
   module Process =
  -    let splitArgs cmd =
  -        if cmd = "" then
  -            [||]
  -        else
  -            cmd.Split(' ')
  -            |> Array.toList
  -            |> List.fold (fun (quoted : string option,acc) e ->
  -                if quoted.IsSome then
  -                    if e.EndsWith "\"" then None, (quoted.Value + " " + e).Replace("\"", "")::acc
  -                    else Some (quoted.Value + " " + e), acc
  -                else
  -                    if e.StartsWith "\"" &&  e.EndsWith "\"" then None, e.Replace("\"", "")::acc
  -                    elif e.StartsWith "\"" then Some e, acc
  -                    elif String.IsNullOrEmpty e then None, acc
  -                    else None, e::acc
  -            ) (None,[])
  -            |> snd
  -            |> List.rev
  -            |> List.toArray
   
       open Node
       open Node.ChildProcess
       open Fable.Import.VSCode.Vscode
       open Fable.Core.JsInterop
  +    open CrossSpawn
   
       module node = Node.Api
   
  
positive.code:             |> ignore
          )
  
      let exec location linuxCmd cmd : JS.Promise<ExecError option * string * string> =
          let options = createEmpty<ExecOptions>
          options.cwd <- workspace.rootPath
          
          Promise.create (fun resolve error ->
              let execCmd =
                  if isWin () then location + " " + cmd
                  else linuxCmd + " " + location + " " + cmd
              node.childProcess.exec(execCmd, options,
                  (fun (e : ExecError option) (i : U2<string, Buffer.Buffer>) (o : U2<string, Buffer.Buffer>) ->
                      // As we don't specify an encoding, the documentation specifies that we'll receive strings
                      // "By default, Node.js will decode the output as UTF-8 and pass strings to the callback"
                      let arg = e, unbox<string> i, unbox<string> o
                      resolve arg)
              ) |> ignore
          )
  
  
  
negative.code:         proc?on $ ("error", f |> unbox) |> ignore
          proc
  
      /// <summary>
      /// spawns a child process in a directory, using a prefix command on linux if required
      /// </summary>
      /// <param name="dir">the directory to run the command in</param>
      /// <param name="command">the 'base' command to execute</param>
      /// <param name="args">an array of additional CLI args</param>
      /// <returns></returns>
      let spawnInDir dir command args =
          let options = createEmpty<ExecOptions>
          options.cwd <- Some dir
          node.childProcess.spawn(command, args, options)
  
      /// <summary>
      /// Spawns a child process with a prefix command on linux if required.
      /// </summary>
      /// <param name="command">the 'base' command to execute</param>
      /// <param name="args">an array of additional CLI args</param>
      /// <returns>a node child process</returns>
      let spawn command (args: ResizeArray<string>) =
          let options = createEmpty<ExecOptions>
          options.cwd <- workspace.rootPath
          crossSpawn.spawn(command, args, options)
  
      /// <summary>
      /// Run a command in a local vscode terminal
      /// </summary>
      /// <param name="command">the 'base' command to execute</param>
      /// <param name="args">an array of additional CLI args</param>
      /// <returns>a vscode terminal</returns>
      let spawnWithShell command (args: ResizeArray<string>) =
          window.createTerminal("F# Application", command, U2.Case1 args)
  
      /// <summary>
      /// fire off a command in the workspace root and write its output to a channel
      /// </summary>
      /// <param name="command">the 'base' command to execute</param>
      /// <param name="args">an array of additional CLI args</param>
      /// <param name="outputChannel">the output channel to write the stdout/stderr of the process to</param>
      /// <returns></returns>
      let spawnWithNotification command args (outputChannel : OutputChannel) =
          spawn command args
          |> onOutput(fun e -> e.toString () |> outputChannel.append)
          |> onError (fun e -> e.ToString () |> outputChannel.append)
          |> onErrorOutput(fun e -> e.toString () |> outputChannel.append)
  
  
      /// <summary>
      /// fire off a command in a directory and write its output to a channel
      /// </summary>
      /// <param name="location">the directory to run the command in</param>
      /// <param name="command">the 'base' command to execute</param>
      /// <param name="args">an array of additional CLI args</param>
      /// <param name="outputChannel">the output channel to write the stdout/stderr of the process to</param>
      /// <returns></returns>
      let spawnWithNotificationInDir location command args (outputChannel : OutputChannel) =
          spawnInDir location command args
          |> onOutput(fun e -> e.toString () |> outputChannel.append)
          |> onError (fun e -> e.ToString () |> outputChannel.append)
          |> onErrorOutput(fun e -> e.toString () |> outputChannel.append)
  