anchor.diff:      let inferIndent (text: string) =
           let countleadingWhitespace (str: string) =
               let rec loop acc =
  -                if acc >= str.Length then acc 
  -                elif not (Char.IsWhiteSpace str.[acc]) then acc 
  +                if acc >= str.Length then acc
  +                elif not (Char.IsWhiteSpace str.[acc]) then acc
                   else loop (acc+1)
               loop 0
   
           // To find the smallest indentation, an empty line can't serve as the seed
           let lines = String.getLines text
   
  -        let rec tryFindStartingLine idx  = 
  +        let rec tryFindStartingLine idx  =
               if idx >= lines.Length then None  // return None if all the lines are blank
  -            elif String.IsNullOrWhiteSpace lines.[idx] then tryFindStartingLine (idx+1) 
  +            elif String.IsNullOrWhiteSpace lines.[idx] then tryFindStartingLine (idx+1)
               else Some idx // found suitable starting line
   
           match tryFindStartingLine 0 with
           | None -> 0
           | Some startIndex ->
               if lines = [||] then 0 else
  -            let minIndent = 
  +            let minIndent =
                   let seed = countleadingWhitespace lines.[startIndex]
  -                (seed, lines.[startIndex..]) 
  -                ||> Array.fold (fun indent line -> 
  +                (seed, lines.[startIndex..])
  +                ||> Array.fold (fun indent line ->
                       if String.IsNullOrWhiteSpace line then indent // skip over empty lines, we don't want them skewing our min
                       else countleadingWhitespace line |> min indent)
               minIndent
  
positive.code: open System.Windows.Media
  open System.Windows
  open System.Windows.Controls
  
  let [<Literal>] private UpdateDelay = 200us
  let [<Literal>] private MaxTooltipLines = 25
  
  type ScopedSpan = Scope * SnapshotSpan
  
  /// A colored outlining hint control similar to 
  /// https://github.com/dotnet/roslyn/blob/57aaa6c9d8bc1995edfc261b968777666172f1b8/src/EditorFeatures/Core/Implementation/Outlining/OutliningTaggerProvider.Tag.cs
  type OutliningControl(createView: ITextBuffer -> IWpfTextView, createBuffer) as self =
      inherit ContentControl()
     
      do self.IsVisibleChanged.Add (fun (e: DependencyPropertyChangedEventArgs) ->
          match e.NewValue, self.Content with
          | (:? bool as nowVisible), null ->
  
negative.code:     /// viewUpdate -=> doUpdate -=> triggerUpdate -=> tagsChanged -=> getTags
      let getTags (normalizedSnapshotSpans: NormalizedSnapshotSpanCollection) : IOutliningRegionTag ITagSpan seq =
          match Seq.isEmpty normalizedSnapshotSpans, Array.isEmpty scopedSnapSpans with
          | false, false ->
              let newSnapshot = (Seq.head normalizedSnapshotSpans).Snapshot
              if newSnapshot.Version <> (snd scopedSnapSpans.[0]).Snapshot.Version then
                  scopedSnapSpans <- scopedSnapSpans
                                     |> Array.map (fun (scp,spn) ->
                                          scp, spn.TranslateTo (newSnapshot, SpanTrackingMode.EdgeExclusive))
              scopedSnapSpans
              |> Seq.filter (snd >> normalizedSnapshotSpans.IntersectsWith)
              |> Seq.map createTagSpan
          | true , _
          | _    , true -> Seq.empty
  
  
      // Construct tags on creation
      do  tagTrigger()
  
  
      interface ITagger<IOutliningRegionTag> with
          member __.GetTags spans =
              protectOrDefault (fun _ -> getTags spans) Seq.empty
  
          [<CLIEvent>]
          member __.TagsChanged = tagsChanged.Publish
  
      interface IDisposable with
          member __.Dispose() =
              scopedSnapSpans <- [||]
              docEventListener.Dispose ()
  