anchor.diff:  
   let corePropsPath = sprintf "package/services/metadata/core-properties/%s.psmdcp" corePropsId
   
  -let corePropsDoc (core : CompleteCoreInfo) = 
  +let corePropsDoc (core : CompleteCoreInfo) =
       let declaration = XDeclaration("1.0", "UTF-8", "yes")
       let ns = XNamespace.Get "http://schemas.openxmlformats.org/package/2006/metadata/core-properties"
       let dc = XNamespace.Get "http://purl.org/dc/elements/1.1/"
       let dcterms = XNamespace.Get "http://purl.org/dc/terms/"
       let xsi = XNamespace.Get "http://www.w3.org/2001/XMLSchema-instance"
  -    let root = 
  +    let root =
           XElement
  -            (ns + "Relationships", XAttribute(XName.Get "xmlns", ns.NamespaceName), 
  -             XAttribute(XNamespace.Xmlns + "dc", dc.NamespaceName), 
  -             XAttribute(XNamespace.Xmlns + "dcterms", dcterms.NamespaceName), 
  +            (ns + "Relationships", XAttribute(XName.Get "xmlns", ns.NamespaceName),
  +             XAttribute(XNamespace.Xmlns + "dc", dc.NamespaceName),
  +             XAttribute(XNamespace.Xmlns + "dcterms", dcterms.NamespaceName),
                XAttribute(XNamespace.Xmlns + "xsi", xsi.NamespaceName))
  -    
  -    let (!!) (ns : XNamespace) name value = 
  +
  +    let (!!) (ns : XNamespace) name value =
           let node = XElement(ns + name)
           node.SetValue value
           root.Add node
  
positive.code: open System.IO.Compression
  open Paket
  open System.Text
  open System.Xml
  
  let nuspecId = "nuspec"
  let corePropsId = "coreProp"
  let contentTypePath = "[Content_Types].xml"
  
  let contentTypeDoc fileList = 
      let declaration = XDeclaration("1.0", "UTF-8", "yes")
      let ns = XNamespace.Get "http://schemas.openxmlformats.org/package/2006/content-types"
      let root = XElement(ns + "Types")
      
      let defaultNode extension contentType =
          let def = XElement(ns + "Default")
          def.SetAttributeValue(XName.Get "Extension", extension)
          def.SetAttributeValue(XName.Get "ContentType", contentType)
          def
      
      let knownExtensions = 
          Map.ofList [ "rels", "application/vnd.openxmlformats-package.relationships+xml"
                       "psmdcp", "application/vnd.openxmlformats-package.core-properties+xml" ]
      
      let ext path = Path.GetExtension(path).TrimStart([| '.' |]).ToLowerInvariant()
      
      let fType ext = 
          knownExtensions
          |> Map.tryFind ext
          |> function 
          | Some ft -> ft
          | None -> "application/octet"
      
      let contentTypes = 
          fileList
          |> Seq.choose (fun f -> 
                 let e = ext f
                 if String.IsNullOrWhiteSpace e then 
                   None
                 else Some(e, fType e))
          |> Seq.distinct
          |> Seq.iter (fun (ex, ct) -> defaultNode ex ct |> root.Add)
      
      XDocument(declaration, box root)
  
  let nuspecDoc (info:CompleteInfo) = 
      let core,optional = info
      let declaration = XDeclaration("1.0", "UTF-8", "yes")
      let ns = XNamespace.Get "http://schemas.microsoft.com/packaging/2011/10/nuspec.xsd"
      let root = XElement(ns + "package")
      
      let addChildNode (parent : XElement) name value = 
          let node = XElement(ns + name)
          node.SetValue value
          parent.Add node
      
      let metadataNode = XElement(ns + "metadata")
      root.Add metadataNode
      let (!!) = addChildNode metadataNode
      
      let (!!?) nodeName strOpt = 
          match strOpt with
          | Some s -> addChildNode metadataNode nodeName s
          | None -> ()
      
      let buildFrameworkReferencesNode libName = 
          let element = XElement(ns + "frameworkAssembly")
          element.SetAttributeValue(XName.Get "assemblyName", libName)
          element
      
      let buildFrameworkReferencesNode frameworkAssembliesList = 
          if frameworkAssembliesList = [] then () else
          let d = XElement(ns + "frameworkAssemblies")
          frameworkAssembliesList |> List.iter (buildFrameworkReferencesNode >> d.Add)
          metadataNode.Add d
  
      let buildDependencyNode (Id, (VersionRequirement(range, _))) = 
          let dep = XElement(ns + "dependency")
          dep.SetAttributeValue(XName.Get "id", Id)
  
  
negative.code:         | "0" -> ()
          | versionStr -> dep.SetAttributeValue(XName.Get "version", versionStr)
          dep
  
      let buildDependenciesNode dependencyList =
          if dependencyList = [] then () else
          let d = XElement(ns + "dependencies")
          dependencyList |> List.iter (buildDependencyNode >> d.Add)
          metadataNode.Add d
  
      let buildReferenceNode (fileName) =
          let dep = XElement(ns + "reference")
          dep.SetAttributeValue(XName.Get "file", fileName)
          dep
  
      let buildReferencesNode referenceList =
          if referenceList = [] then () else
          let d = XElement(ns + "references")
          referenceList |> List.iter (buildReferenceNode >> d.Add)
          metadataNode.Add d
  
      !! "id" core.Id
      match core.Version with
      | Some v -> !! "version" <| v.ToString()
  