anchor.diff:              member _.Write(str) =
                   async {
                       do! stream.WriteAsync(str) |> Async.AwaitTask
  +                    if cliArgs.SourceMaps then
  +                        let mapPath = targetPath + ".map"
  +                        do! stream.WriteLineAsync($"//# sourceMappingURL={IO.Path.GetFileName(mapPath)}") |> Async.AwaitTask
                       do! stream.FlushAsync() |> Async.AwaitTask
                   }
               member _.EscapeJsStringLiteral(str) =
  
positive.code: 
                  use writer = new FileWriter(com.CurrentFile, outPath, cliArgs, pathResolver)
                  do! BabelPrinter.run writer babel
                  let! written = writer.WriteToFileIfChangedAsync()
  
                  if written && cliArgs.SourceMaps then
                      let mapPath = outPath + ".map"
                      do! IO.File.AppendAllLinesAsync(outPath, [$"//# sourceMappingURL={IO.Path.GetFileName(mapPath)}"]) |> Async.AwaitTask
                      use fs = IO.File.Open(mapPath, IO.FileMode.Create)
                      do! writer.SourceMap.SerializeAsync(fs) |> Async.AwaitTask
  
              return Ok {| File = com.CurrentFile
                           OutPath = outPath
  
negative.code:         member _.SourceMap =
              mapGenerator.Force().toJSON()
  
          member _.WriteToFileIfChangedAsync(): Async<unit> = async {
              if memoryStream.Length = 0 then
                  return ()
              elif not(IO.File.Exists(targetPath)) then
                  do! WriteStreamToFileAsync(memoryStream, targetPath)
              else
                  let fileInfo = new IO.FileInfo(targetPath)
                  if fileInfo.Length <> memoryStream.Length then
                      do! WriteStreamToFileAsync(memoryStream, targetPath)
                  else
                      match! IsMemoryStreamEqualToFileAsync() with
                      | false -> do! WriteStreamToFileAsync(memoryStream, targetPath)
                      | true -> return ()
            }
  
      let compileFile (com: CompilerImpl) (cliArgs: CliArgs) pathResolver isSilent = async {
  