anchor.diff:                  !"YUICompressor.NET"
               ]
   }
  -
  -#else
  -#load ".build/boot.fsx"
  +
  +#else
  +#load ".build/boot.fsx"
   open System
   open System.IO
   open System.Net
   open System.Text
  -open Fake
  -open Ionic.Zip
  -
  +open Fake
  +open Ionic.Zip
  +
   module B = IntelliFactory.Build.CommonBuildSetup
   module F = IntelliFactory.Build.FileSystem
   module NG = IntelliFactory.Build.NuGetUtils
  
positive.code: 
  RunTargetOrDefault Build
  
  #endif
  
negative.code:     m.Product <- Some Config.PackageId
      m.VersionSuffix <- Some Config.VersionSuffix
      m.Website <- Some Config.Website
      m
  
  [<AutoOpen>]
  module Extensions =
  
      type B.BuildConfiguration with
          static member Release(v: B.FrameworkVersion)(deps: list<string>) : B.BuildConfiguration =
              {
                  ConfigurationName = "Release"
                  Debug = false
                  FrameworkVersion = v
                  NuGetDependencies =
                      new global.NuGet.PackageDependencySet(
                          v.ToFrameworkName(),
                          [for d in deps -> global.NuGet.PackageDependency(d)]
                      )
              }
  
      type B.Solution with
  
          static member Standard(rootDir: string)(m: B.Metadata)(ps: list<string -> B.Project>) : B.Solution =
              {
                  Metadata = m
                  Projects = [for p in ps -> p rootDir]
                  RootDirectory = rootDir
              }
  
          member this.BuildSync(?opts: B.MSBuildOptions) =
              this.MSBuild(?options=opts)
              |> Async.RunSynchronously
  
          member this.CleanSync(?opts: B.MSBuildOptions) =
              let opts : B.MSBuildOptions =
                  match opts with
                  | Some opts ->
                      { opts with Targets = ["Clean"] }
                  | None ->
                      {
                          BuildConfiguration = None
                          Properties = Map.empty
                          Targets = ["Clean"]
                      }
              this.MSBuild opts
              |> Async.RunSynchronously
  
      type B.Project with
  
          static member FSharp(name: string)(configs: list<B.BuildConfiguration>)(rootDir: string) : B.Project =
              {
                  Name = name
                  MSBuildProjectFilePath = Some (rootDir +/ name +/ (name + ".fsproj"))
                  BuildConfigurations = configs
              }
  
          static member CSharp(name: string)(configs: list<B.BuildConfiguration>)(rootDir: string) : B.Project =
              {
                  Name = name
                  MSBuildProjectFilePath = Some (rootDir +/ name +/ (name + ".csproj"))
                  BuildConfigurations = configs
              }
  
  let RawJavaScriptFiles =
      [
          RootDir +/ "IntelliFactory.JavaScript" +/ "Runtime.js"
          RootDir +/ "IntelliFactory.WebSharper" +/ "Json.js"
      ]
  
  let CompressJavaScript = T "CompressJavaScript" <| fun () ->
      let jc = Yahoo.Yui.Compressor.JavaScriptCompressor()
      for i in RawJavaScriptFiles do
          let cj =
              File.ReadAllText(i)
              |> jc.Compress
          let p = Path.ChangeExtension(i, ".min.js")
          F.TextContent(cj).WriteFile(p)
  
  let CleanCompressedJavaScript = T "CleanCompressedJavaScript" <| fun () ->
      for i in RawJavaScriptFiles do
          let p = Path.ChangeExtension(i, ".min.js")
          File.Delete p
  
  let Deps =
      [
          "IntelliFactory.FastInvoke"
          "IntelliFactory.Xml"
          "Mono.Cecil"
      ]
  
  let C35 = B.BuildConfiguration.Release B.Net35 Deps
  let C40 = B.BuildConfiguration.Release B.Net40 Deps
  
  let Configs = [C35; C40]
  
  let CompilerSolution : B.Solution =
      B.Solution.Standard RootDir Metadata [
          B.Project.FSharp "IntelliFactory.JavaScript" Configs
          B.Project.FSharp "IntelliFactory.JavaScript.Tests" Configs
  