anchor.diff:  #load "src/paket.fsx"
   #load "src/core.fsx"
   
  -// Translate the type given as #1 using module name #2 
  +// Translate the type given as #1 using module name #2
   // and save the result to a file specified in #3
  -let atomModules = 
  -  [ typeof<Core.Core>, "AtomFSharpCore", "src/core/lib/core.js"; 
  +let atomModules =
  +  [ typeof<Core.Core>, "AtomFSharpCore", "src/core/lib/core.js";
       typeof<Paket.Paket>, "AtomFSharpPaket", "src/paket/lib/paket.js" ]
   
   // --------------------------------------------------------------------------------------
  
positive.code:     CleanDir (typings @@ "temp")
  
      // Get all definitions and their dependencies (and source code without <reference> tags)
      let tsDefinitions = 
        let reg = System.Text.RegularExpressions.Regex("reference.*path=\"([^\"]*)\"") // "
        let defs = Directory.EnumerateFiles(typings, "*.d.ts", SearchOption.AllDirectories)
        [ for def in defs ->
            let lines = File.ReadAllLines(def)
            let deps, lines = 
              [ for line in lines do
                  let mtch = reg.Match(line)
                  if mtch.Success then 
                    let depName = Path.GetFileName(mtch.Groups.[1].Value)
                    if not (noInline.Contains depName) then yield true, depName
                   else yield false, line ] |> List.partition fst
  
negative.code:     /// Creates "(fun p1 .. pn -> <body>)" and "[p1; ..; pn]"
      /// (which is used when generating boxed lambdas that pass parameters to the actual function)
      let createParameterPassing (m:MethodBase) =
        let paramVars = m.GetParameters() |> Array.mapi (fun i p -> Var(sprintf "p%d" i, p.ParameterType))
        let paramArgs = [ for v in paramVars -> Expr.Var(v) ]
        let lambdaConstr = paramVars |> Seq.fold (fun fn var -> fun body -> Expr.Lambda(var, fn body)) id
        lambdaConstr, paramArgs
  
      let exportFunctions =
        [ for m in meths ->
            let tv = new Var("this", typ)
  