diff --git a/components/dotnet-model/dotnet-model-library-import/src/site/site.xml b/components/dotnet-model/dotnet-model-library-import/src/site/site.xml
index 56d03f7..b70ab0a 100644
--- a/components/dotnet-model/dotnet-model-library-import/src/site/site.xml
+++ b/components/dotnet-model/dotnet-model-library-import/src/site/site.xml
@@ -1,39 +1,39 @@
-<!--
-  ~ Licensed to the Apache Software Foundation (ASF) under one
-  ~ or more contributor license agreements.  See the NOTICE file
-  ~ distributed with this work for additional information
-  ~ regarding copyright ownership.  The ASF licenses this file
-  ~ to you under the Apache License, Version 2.0 (the
-  ~ "License"); you may not use this file except in compliance
-  ~ with the License.  You may obtain a copy of the License at
-  ~
-  ~   http://www.apache.org/licenses/LICENSE-2.0
-  ~
-  ~ Unless required by applicable law or agreed to in writing,
-  ~ software distributed under the License is distributed on an
-  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-  ~ KIND, either express or implied.  See the License for the
-  ~ specific language governing permissions and limitations
-  ~ under the License.
-  -->
-
-<project name="NPanday">
-  <bannerRight>
-    <src>./images/apache-incubator-logo.png</src>
-  </bannerRight>
-
-  <body>
-    <links>
-      <item name="Project Site" href="http://incubator.apache.org/projects/npanday.html"/>
-      <item name="NPanday" href="http://incubator.apache.org/npanday"/>
-      <item name="NPanday SVN" href="http://svn.apache.org/repos/asf/incubator/npanday/"/>
-      <item name="Maven" href="http://maven.apache.org/"/>
-      <item name="Mono Project" href="http://www.mono-project.com/"/>
-      <item name="DotGNU" href="http://dotgnu.org/"/>
-    </links>
-    <menu name="General Info">
-      <item name="About" href="assembly-plugin.html"/>
-    </menu>
-    ${reports}
-  </body>
+<!--
+  ~ Licensed to the Apache Software Foundation (ASF) under one
+  ~ or more contributor license agreements.  See the NOTICE file
+  ~ distributed with this work for additional information
+  ~ regarding copyright ownership.  The ASF licenses this file
+  ~ to you under the Apache License, Version 2.0 (the
+  ~ "License"); you may not use this file except in compliance
+  ~ with the License.  You may obtain a copy of the License at
+  ~
+  ~   http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing,
+  ~ software distributed under the License is distributed on an
+  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  ~ KIND, either express or implied.  See the License for the
+  ~ specific language governing permissions and limitations
+  ~ under the License.
+  -->
+
+<project name="NPanday">
+  <bannerRight>
+    <src>./images/apache-incubator-logo.png</src>
+  </bannerRight>
+
+  <body>
+    <links>
+      <item name="Project Site" href="http://incubator.apache.org/projects/npanday.html"/>
+      <item name="NPanday" href="http://incubator.apache.org/npanday"/>
+      <item name="NPanday SVN" href="http://svn.apache.org/repos/asf/incubator/npanday/"/>
+      <item name="Maven" href="http://maven.apache.org/"/>
+      <item name="Mono Project" href="http://www.mono-project.com/"/>
+      <item name="DotGNU" href="http://dotgnu.org/"/>
+    </links>
+    <menu name="General Info">
+      <item name="About" href="assembly-plugin.html"/>
+    </menu>
+    ${reports}
+  </body>
 </project>
\ No newline at end of file
diff --git a/components/dotnet-model/dotnet-model-library-import/src/test/resources/sample-nuget-imports.xml b/components/dotnet-model/dotnet-model-library-import/src/test/resources/sample-nuget-imports.xml
index c25d225..167e123 100644
--- a/components/dotnet-model/dotnet-model-library-import/src/test/resources/sample-nuget-imports.xml
+++ b/components/dotnet-model/dotnet-model-library-import/src/test/resources/sample-nuget-imports.xml
@@ -1,41 +1,41 @@
-<!--
-  ~ Licensed to the Apache Software Foundation (ASF) under one
-  ~ or more contributor license agreements.  See the NOTICE file
-  ~ distributed with this work for additional information
-  ~ regarding copyright ownership.  The ASF licenses this file
-  ~ to you under the Apache License, Version 2.0 (the
-  ~ "License"); you may not use this file except in compliance
-  ~ with the License.  You may obtain a copy of the License at
-  ~
-  ~   http://www.apache.org/licenses/LICENSE-2.0
-  ~
-  ~ Unless required by applicable law or agreed to in writing,
-  ~ software distributed under the License is distributed on an
-  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-  ~ KIND, either express or implied.  See the License for the
-  ~ specific language governing permissions and limitations
-  ~ under the License.
-  -->
-
-<libs xmlns="http://npanday.apache.org/library-import/1.0.0">
-
-  <nugetSources addNugetGallery="true">
-    <custom>package-source</custom>
-  </nugetSources>
-
-  <nuget>
-    <package>NUnit</package>
-    <version source="2.6.0.12054" mapTo="2.6.0"/>
-    <version source="2.5.10.11092" mapTo="2.5.10"/>
-    <libDirs>
-      <default>net40</default>
-    </libDirs>
-
-    <mapReference
-      name="AssemblyName"
-      ignore="true">
-      <toPackage id="pname" version="1.0" />
-    </mapReference>
-
-  </nuget>
-</libs>
+<!--
+  ~ Licensed to the Apache Software Foundation (ASF) under one
+  ~ or more contributor license agreements.  See the NOTICE file
+  ~ distributed with this work for additional information
+  ~ regarding copyright ownership.  The ASF licenses this file
+  ~ to you under the Apache License, Version 2.0 (the
+  ~ "License"); you may not use this file except in compliance
+  ~ with the License.  You may obtain a copy of the License at
+  ~
+  ~   http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing,
+  ~ software distributed under the License is distributed on an
+  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  ~ KIND, either express or implied.  See the License for the
+  ~ specific language governing permissions and limitations
+  ~ under the License.
+  -->
+
+<libs xmlns="http://npanday.apache.org/library-import/1.0.0">
+
+  <nugetSources addNugetGallery="true">
+    <custom>package-source</custom>
+  </nugetSources>
+
+  <nuget>
+    <package>NUnit</package>
+    <version source="2.6.0.12054" mapTo="2.6.0"/>
+    <version source="2.5.10.11092" mapTo="2.5.10"/>
+    <libDirs>
+      <default>net40</default>
+    </libDirs>
+
+    <mapReference
+      name="AssemblyName"
+      ignore="true">
+      <toPackage id="pname" version="1.0" />
+    </mapReference>
+
+  </nuget>
+</libs>
diff --git a/components/dotnet-msbuild/src/main/resources/META-INF/npanday/executable-plugins.xml b/components/dotnet-msbuild/src/main/resources/META-INF/npanday/executable-plugins.xml
index d284ad0..23ee442 100644
--- a/components/dotnet-msbuild/src/main/resources/META-INF/npanday/executable-plugins.xml
+++ b/components/dotnet-msbuild/src/main/resources/META-INF/npanday/executable-plugins.xml
@@ -1,46 +1,46 @@
-<!--
-  ~ Licensed to the Apache Software Foundation (ASF) under one
-  ~ or more contributor license agreements.  See the NOTICE file
-  ~ distributed with this work for additional information
-  ~ regarding copyright ownership.  The ASF licenses this file
-  ~ to you under the Apache License, Version 2.0 (the
-  ~ "License"); you may not use this file except in compliance
-  ~ with the License.  You may obtain a copy of the License at
-  ~
-  ~   http://www.apache.org/licenses/LICENSE-2.0
-  ~
-  ~ Unless required by applicable law or agreed to in writing,
-  ~ software distributed under the License is distributed on an
-  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-  ~ KIND, either express or implied.  See the License for the
-  ~ specific language governing permissions and limitations
-  ~ under the License.
-  -->
-<executablePlugins>
-  <executablePlugin>
-    <profile>MSBUILD</profile>
-    <pluginClass>npanday.executable.impl.DefaultNetExecutable</pluginClass>
-    <vendor>MICROSOFT</vendor>
-    <executable>msbuild</executable>
-    <frameworkVersions>
-      <frameworkVersion>4.5.1</frameworkVersion>
-      <frameworkVersion>4.5</frameworkVersion>
-      <frameworkVersion>4.0</frameworkVersion>
-      <frameworkVersion>3.5</frameworkVersion>
-      <frameworkVersion>3.0</frameworkVersion>
-      <frameworkVersion>2.0.50727</frameworkVersion>
-    </frameworkVersions>
-    <platforms>
-      <platform>
-        <operatingSystem>Windows</operatingSystem>
-      </platform>
-    </platforms>
-    <probingPaths>
-      <!-- TODO: this should be broken up as CSC is, just means for now you always get newest available tools version, but will target right framework -->
-      <probingPath>${HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\MSBuild\ToolsVersions\12.0@MSBuildToolsPath}</probingPath>
-      <probingPath>${HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\MSBuild\ToolsVersions\4.0@MSBuildToolsPath}</probingPath>
-      <probingPath>${HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\MSBuild\ToolsVersions\3.5@MSBuildToolsPath}</probingPath>
-      <probingPath>${HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\MSBuild\ToolsVersions\2.0@MSBuildToolsPath}</probingPath>
-    </probingPaths>
-  </executablePlugin>
-</executablePlugins>
+<!--
+  ~ Licensed to the Apache Software Foundation (ASF) under one
+  ~ or more contributor license agreements.  See the NOTICE file
+  ~ distributed with this work for additional information
+  ~ regarding copyright ownership.  The ASF licenses this file
+  ~ to you under the Apache License, Version 2.0 (the
+  ~ "License"); you may not use this file except in compliance
+  ~ with the License.  You may obtain a copy of the License at
+  ~
+  ~   http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing,
+  ~ software distributed under the License is distributed on an
+  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  ~ KIND, either express or implied.  See the License for the
+  ~ specific language governing permissions and limitations
+  ~ under the License.
+  -->
+<executablePlugins>
+  <executablePlugin>
+    <profile>MSBUILD</profile>
+    <pluginClass>npanday.executable.impl.DefaultNetExecutable</pluginClass>
+    <vendor>MICROSOFT</vendor>
+    <executable>msbuild</executable>
+    <frameworkVersions>
+      <frameworkVersion>4.5.1</frameworkVersion>
+      <frameworkVersion>4.5</frameworkVersion>
+      <frameworkVersion>4.0</frameworkVersion>
+      <frameworkVersion>3.5</frameworkVersion>
+      <frameworkVersion>3.0</frameworkVersion>
+      <frameworkVersion>2.0.50727</frameworkVersion>
+    </frameworkVersions>
+    <platforms>
+      <platform>
+        <operatingSystem>Windows</operatingSystem>
+      </platform>
+    </platforms>
+    <probingPaths>
+      <!-- TODO: this should be broken up as CSC is, just means for now you always get newest available tools version, but will target right framework -->
+      <probingPath>${HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\MSBuild\ToolsVersions\12.0@MSBuildToolsPath}</probingPath>
+      <probingPath>${HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\MSBuild\ToolsVersions\4.0@MSBuildToolsPath}</probingPath>
+      <probingPath>${HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\MSBuild\ToolsVersions\3.5@MSBuildToolsPath}</probingPath>
+      <probingPath>${HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\MSBuild\ToolsVersions\2.0@MSBuildToolsPath}</probingPath>
+    </probingPaths>
+  </executablePlugin>
+</executablePlugins>
diff --git a/components/dotnet-msbuild/src/main/resources/META-INF/plexus/components.xml b/components/dotnet-msbuild/src/main/resources/META-INF/plexus/components.xml
index 24d8743..b3b0533 100644
--- a/components/dotnet-msbuild/src/main/resources/META-INF/plexus/components.xml
+++ b/components/dotnet-msbuild/src/main/resources/META-INF/plexus/components.xml
@@ -1,23 +1,23 @@
-<!--
-  ~ Licensed to the Apache Software Foundation (ASF) under one
-  ~ or more contributor license agreements.  See the NOTICE file
-  ~ distributed with this work for additional information
-  ~ regarding copyright ownership.  The ASF licenses this file
-  ~ to you under the Apache License, Version 2.0 (the
-  ~ "License"); you may not use this file except in compliance
-  ~ with the License.  You may obtain a copy of the License at
-  ~
-  ~   http://www.apache.org/licenses/LICENSE-2.0
-  ~
-  ~ Unless required by applicable law or agreed to in writing,
-  ~ software distributed under the License is distributed on an
-  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-  ~ KIND, either express or implied.  See the License for the
-  ~ specific language governing permissions and limitations
-  ~ under the License.
-  -->
-<component-set>
-  <components>
-    <!-- created through annotations -->
-  </components>
-</component-set>
+<!--
+  ~ Licensed to the Apache Software Foundation (ASF) under one
+  ~ or more contributor license agreements.  See the NOTICE file
+  ~ distributed with this work for additional information
+  ~ regarding copyright ownership.  The ASF licenses this file
+  ~ to you under the Apache License, Version 2.0 (the
+  ~ "License"); you may not use this file except in compliance
+  ~ with the License.  You may obtain a copy of the License at
+  ~
+  ~   http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing,
+  ~ software distributed under the License is distributed on an
+  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  ~ KIND, either express or implied.  See the License for the
+  ~ specific language governing permissions and limitations
+  ~ under the License.
+  -->
+<component-set>
+  <components>
+    <!-- created through annotations -->
+  </components>
+</component-set>
diff --git a/components/dotnet-nuget/src/main/resources/META-INF/npanday/executable-plugins.xml b/components/dotnet-nuget/src/main/resources/META-INF/npanday/executable-plugins.xml
index 983ee6e..6864806 100644
--- a/components/dotnet-nuget/src/main/resources/META-INF/npanday/executable-plugins.xml
+++ b/components/dotnet-nuget/src/main/resources/META-INF/npanday/executable-plugins.xml
@@ -1,48 +1,48 @@
-<!--
-  ~ Licensed to the Apache Software Foundation (ASF) under one
-  ~ or more contributor license agreements.  See the NOTICE file
-  ~ distributed with this work for additional information
-  ~ regarding copyright ownership.  The ASF licenses this file
-  ~ to you under the Apache License, version 2.0 (the
-  ~ "License"); you may not use this file except in compliance
-  ~ with the License.  You may obtain a copy of the License at
-  ~
-  ~   http://www.apache.org/licenses/LICENSE-2.0
-  ~
-  ~ Unless required by applicable law or agreed to in writing,
-  ~ software distributed under the License is distributed on an
-  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-  ~ KIND, either express or implied.  See the License for the
-  ~ specific language governing permissions and limitations
-  ~ under the License.
-  -->
-
-<executablePlugins>
-    <executablePlugin>
-        <profile>NUGET</profile>
-        <pluginClass>npanday.executable.impl.DefaultNetExecutable</pluginClass>
-
-        <executable>nuget</executable>
-        <executableVersion>1.7</executableVersion>
-
-        <vendor>MICROSOFT</vendor>
-
-        <frameworkVersions>
-            <frameworkVersion>4.5.1</frameworkVersion>
-            <frameworkVersion>4.5</frameworkVersion>
-            <frameworkVersion>4.0</frameworkVersion>
-            <frameworkVersion>3.5</frameworkVersion>
-            <frameworkVersion>2.0</frameworkVersion>
-        </frameworkVersions>
-
-        <probingPaths>
-        </probingPaths>
-
-        <platforms>
-            <platform>
-                <operatingSystem>Windows</operatingSystem>
-            </platform>
-        </platforms>
-
-    </executablePlugin>
-</executablePlugins>
+<!--
+  ~ Licensed to the Apache Software Foundation (ASF) under one
+  ~ or more contributor license agreements.  See the NOTICE file
+  ~ distributed with this work for additional information
+  ~ regarding copyright ownership.  The ASF licenses this file
+  ~ to you under the Apache License, version 2.0 (the
+  ~ "License"); you may not use this file except in compliance
+  ~ with the License.  You may obtain a copy of the License at
+  ~
+  ~   http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing,
+  ~ software distributed under the License is distributed on an
+  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  ~ KIND, either express or implied.  See the License for the
+  ~ specific language governing permissions and limitations
+  ~ under the License.
+  -->
+
+<executablePlugins>
+    <executablePlugin>
+        <profile>NUGET</profile>
+        <pluginClass>npanday.executable.impl.DefaultNetExecutable</pluginClass>
+
+        <executable>nuget</executable>
+        <executableVersion>1.7</executableVersion>
+
+        <vendor>MICROSOFT</vendor>
+
+        <frameworkVersions>
+            <frameworkVersion>4.5.1</frameworkVersion>
+            <frameworkVersion>4.5</frameworkVersion>
+            <frameworkVersion>4.0</frameworkVersion>
+            <frameworkVersion>3.5</frameworkVersion>
+            <frameworkVersion>2.0</frameworkVersion>
+        </frameworkVersions>
+
+        <probingPaths>
+        </probingPaths>
+
+        <platforms>
+            <platform>
+                <operatingSystem>Windows</operatingSystem>
+            </platform>
+        </platforms>
+
+    </executablePlugin>
+</executablePlugins>
diff --git a/components/dotnet-nuget/src/main/resources/META-INF/plexus/components.xml b/components/dotnet-nuget/src/main/resources/META-INF/plexus/components.xml
index 51fad12..5017a28 100644
--- a/components/dotnet-nuget/src/main/resources/META-INF/plexus/components.xml
+++ b/components/dotnet-nuget/src/main/resources/META-INF/plexus/components.xml
@@ -1,24 +1,24 @@
-<!--
-  ~ Licensed to the Apache Software Foundation (ASF) under one
-  ~ or more contributor license agreements.  See the NOTICE file
-  ~ distributed with this work for additional information
-  ~ regarding copyright ownership.  The ASF licenses this file
-  ~ to you under the Apache License, version 2.0 (the
-  ~ "License"); you may not use this file except in compliance
-  ~ with the License.  You may obtain a copy of the License at
-  ~
-  ~   http://www.apache.org/licenses/LICENSE-2.0
-  ~
-  ~ Unless required by applicable law or agreed to in writing,
-  ~ software distributed under the License is distributed on an
-  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-  ~ KIND, either express or implied.  See the License for the
-  ~ specific language governing permissions and limitations
-  ~ under the License.
-  -->
-
-<component-set>
-  <components>
-    <!-- created through annotations -->
-  </components>
-</component-set>
+<!--
+  ~ Licensed to the Apache Software Foundation (ASF) under one
+  ~ or more contributor license agreements.  See the NOTICE file
+  ~ distributed with this work for additional information
+  ~ regarding copyright ownership.  The ASF licenses this file
+  ~ to you under the Apache License, version 2.0 (the
+  ~ "License"); you may not use this file except in compliance
+  ~ with the License.  You may obtain a copy of the License at
+  ~
+  ~   http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing,
+  ~ software distributed under the License is distributed on an
+  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  ~ KIND, either express or implied.  See the License for the
+  ~ specific language governing permissions and limitations
+  ~ under the License.
+  -->
+
+<component-set>
+  <components>
+    <!-- created through annotations -->
+  </components>
+</component-set>
diff --git a/components/dotnet-packaging/src/main/resources/META-INF/plexus/components.xml b/components/dotnet-packaging/src/main/resources/META-INF/plexus/components.xml
index a9c4fa7..8d1ca35 100644
--- a/components/dotnet-packaging/src/main/resources/META-INF/plexus/components.xml
+++ b/components/dotnet-packaging/src/main/resources/META-INF/plexus/components.xml
@@ -1,23 +1,23 @@
-<!--
-  ~ Licensed to the Apache Software Foundation (ASF) under one
-  ~ or more contributor license agreements.  See the NOTICE file
-  ~ distributed with this work for additional information
-  ~ regarding copyright ownership.  The ASF licenses this file
-  ~ to you under the Apache License, Version 2.0 (the
-  ~ "License"); you may not use this file except in compliance
-  ~ with the License.  You may obtain a copy of the License at
-  ~
-  ~   http://www.apache.org/licenses/LICENSE-2.0
-  ~
-  ~ Unless required by applicable law or agreed to in writing,
-  ~ software distributed under the License is distributed on an
-  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-  ~ KIND, either express or implied.  See the License for the
-  ~ specific language governing permissions and limitations
-  ~ under the License.
-  -->
-
-<component-set>
-    <!-- will be generated through annotations -->
-</component-set>
-
+<!--
+  ~ Licensed to the Apache Software Foundation (ASF) under one
+  ~ or more contributor license agreements.  See the NOTICE file
+  ~ distributed with this work for additional information
+  ~ regarding copyright ownership.  The ASF licenses this file
+  ~ to you under the Apache License, Version 2.0 (the
+  ~ "License"); you may not use this file except in compliance
+  ~ with the License.  You may obtain a copy of the License at
+  ~
+  ~   http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing,
+  ~ software distributed under the License is distributed on an
+  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  ~ KIND, either express or implied.  See the License for the
+  ~ specific language governing permissions and limitations
+  ~ under the License.
+  -->
+
+<component-set>
+    <!-- will be generated through annotations -->
+</component-set>
+
diff --git a/dotnet/assemblies/NPanday.ProjectImporter/Engine/src/test/resource/SilverlightApplication1/SilverlightApplication1/Properties/AppManifest.xml b/dotnet/assemblies/NPanday.ProjectImporter/Engine/src/test/resource/SilverlightApplication1/SilverlightApplication1/Properties/AppManifest.xml
index 6712a11..6d0aa76 100644
--- a/dotnet/assemblies/NPanday.ProjectImporter/Engine/src/test/resource/SilverlightApplication1/SilverlightApplication1/Properties/AppManifest.xml
+++ b/dotnet/assemblies/NPanday.ProjectImporter/Engine/src/test/resource/SilverlightApplication1/SilverlightApplication1/Properties/AppManifest.xml
@@ -1,4 +1,4 @@
-﻿<Deployment xmlns="http://schemas.microsoft.com/client/2007/deployment"
+<Deployment xmlns="http://schemas.microsoft.com/client/2007/deployment"
         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
 >
     <Deployment.Parts>
diff --git a/dotnet/assemblies/NPanday.ProjectImporter/Engine/src/test/resource/SilverlightApplication1/SilverlightApplication2/Properties/AppManifest.xml b/dotnet/assemblies/NPanday.ProjectImporter/Engine/src/test/resource/SilverlightApplication1/SilverlightApplication2/Properties/AppManifest.xml
index 1370dca..5d14ace 100644
--- a/dotnet/assemblies/NPanday.ProjectImporter/Engine/src/test/resource/SilverlightApplication1/SilverlightApplication2/Properties/AppManifest.xml
+++ b/dotnet/assemblies/NPanday.ProjectImporter/Engine/src/test/resource/SilverlightApplication1/SilverlightApplication2/Properties/AppManifest.xml
@@ -1,4 +1,4 @@
-﻿<Deployment xmlns="http://schemas.microsoft.com/client/2007/deployment"
+<Deployment xmlns="http://schemas.microsoft.com/client/2007/deployment"
         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
 >
     <Deployment.Parts>
diff --git a/dotnet/assemblies/NPanday.ProjectImporter/Engine/src/test/resource/SilverlightApplication5/SilverlightApplication5/Properties/AppManifest.xml b/dotnet/assemblies/NPanday.ProjectImporter/Engine/src/test/resource/SilverlightApplication5/SilverlightApplication5/Properties/AppManifest.xml
index 6712a11..6d0aa76 100644
--- a/dotnet/assemblies/NPanday.ProjectImporter/Engine/src/test/resource/SilverlightApplication5/SilverlightApplication5/Properties/AppManifest.xml
+++ b/dotnet/assemblies/NPanday.ProjectImporter/Engine/src/test/resource/SilverlightApplication5/SilverlightApplication5/Properties/AppManifest.xml
@@ -1,4 +1,4 @@
-﻿<Deployment xmlns="http://schemas.microsoft.com/client/2007/deployment"
+<Deployment xmlns="http://schemas.microsoft.com/client/2007/deployment"
         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
 >
     <Deployment.Parts>
diff --git a/dotnet/assemblies/NPanday.VisualStudio.Addin/src/main/csharp/log4net.xml b/dotnet/assemblies/NPanday.VisualStudio.Addin/src/main/csharp/log4net.xml
index 8de6726..1d966bd 100644
--- a/dotnet/assemblies/NPanday.VisualStudio.Addin/src/main/csharp/log4net.xml
+++ b/dotnet/assemblies/NPanday.VisualStudio.Addin/src/main/csharp/log4net.xml
@@ -1,4 +1,4 @@
-﻿<?xml version="1.0" encoding="utf-8" ?>
+<?xml version="1.0" encoding="utf-8" ?>
 <log4net>
   <appender name="RollingFile" type="log4net.Appender.RollingFileAppender">
     <file value="${LOCALAPPDATA}/NPanday/npanday-debug.log" />
diff --git a/plugins/application-maven-plugin/src/main/resources/META-INF/plexus/components.xml b/plugins/application-maven-plugin/src/main/resources/META-INF/plexus/components.xml
index b8f6966..9bcca56 100644
--- a/plugins/application-maven-plugin/src/main/resources/META-INF/plexus/components.xml
+++ b/plugins/application-maven-plugin/src/main/resources/META-INF/plexus/components.xml
@@ -1,26 +1,26 @@
-<!--
-  ~ Licensed to the Apache Software Foundation (ASF) under one
-  ~ or more contributor license agreements.  See the NOTICE file
-  ~ distributed with this work for additional information
-  ~ regarding copyright ownership.  The ASF licenses this file
-  ~ to you under the Apache License, Version 2.0 (the
-  ~ "License"); you may not use this file except in compliance
-  ~ with the License.  You may obtain a copy of the License at
-  ~
-  ~   http://www.apache.org/licenses/LICENSE-2.0
-  ~
-  ~ Unless required by applicable law or agreed to in writing,
-  ~ software distributed under the License is distributed on an
-  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-  ~ KIND, either express or implied.  See the License for the
-  ~ specific language governing permissions and limitations
-  ~ under the License.
-  -->
-<component-set>
-  <components>
-    <component>
-      <role>npanday.plugin.aspnet.MixinAsssemblyReader</role>
-      <implementation>npanday.plugin.aspnet.MixinAsssemblyReader</implementation>
-    </component>
-  </components>
-</component-set>
+<!--
+  ~ Licensed to the Apache Software Foundation (ASF) under one
+  ~ or more contributor license agreements.  See the NOTICE file
+  ~ distributed with this work for additional information
+  ~ regarding copyright ownership.  The ASF licenses this file
+  ~ to you under the Apache License, Version 2.0 (the
+  ~ "License"); you may not use this file except in compliance
+  ~ with the License.  You may obtain a copy of the License at
+  ~
+  ~   http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing,
+  ~ software distributed under the License is distributed on an
+  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  ~ KIND, either express or implied.  See the License for the
+  ~ specific language governing permissions and limitations
+  ~ under the License.
+  -->
+<component-set>
+  <components>
+    <component>
+      <role>npanday.plugin.aspnet.MixinAsssemblyReader</role>
+      <implementation>npanday.plugin.aspnet.MixinAsssemblyReader</implementation>
+    </component>
+  </components>
+</component-set>
diff --git a/plugins/application-maven-plugin/src/main/resources/assemblies/application-defaults.xml b/plugins/application-maven-plugin/src/main/resources/assemblies/application-defaults.xml
index 1560660..173416e 100644
--- a/plugins/application-maven-plugin/src/main/resources/assemblies/application-defaults.xml
+++ b/plugins/application-maven-plugin/src/main/resources/assemblies/application-defaults.xml
@@ -1,36 +1,36 @@
-<!--
-  ~ Licensed to the Apache Software Foundation (ASF) under one
-  ~ or more contributor license agreements.  See the NOTICE file
-  ~ distributed with this work for additional information
-  ~ regarding copyright ownership.  The ASF licenses this file
-  ~ to you under the Apache License, Version 2.0 (the
-  ~ "License"); you may not use this file except in compliance
-  ~ with the License.  You may obtain a copy of the License at
-  ~
-  ~   http://www.apache.org/licenses/LICENSE-2.0
-  ~
-  ~ Unless required by applicable law or agreed to in writing,
-  ~ software distributed under the License is distributed on an
-  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-  ~ KIND, either express or implied.  See the License for the
-  ~ specific language governing permissions and limitations
-  ~ under the License.
-  -->
-
-<assembly xmlns="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.2"
-    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-    xsi:schemaLocation="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.2 http://maven.apache.org/xsd/assembly-1.1.2.xsd">
-  <id>application-defaults</id>
-  <includeBaseDirectory>false</includeBaseDirectory>
-  <formats>
-    <format>dir</format>
-  </formats>
-
-  <componentDescriptors>
-    <!--
-     Just specifying bare file names would need a fix for:
-     http://jira.codehaus.org/browse/MASSEMBLY-585
-     -->
-    <componentDescriptor>assemblies/components/application-binaries.xml</componentDescriptor>
-  </componentDescriptors>
+<!--
+  ~ Licensed to the Apache Software Foundation (ASF) under one
+  ~ or more contributor license agreements.  See the NOTICE file
+  ~ distributed with this work for additional information
+  ~ regarding copyright ownership.  The ASF licenses this file
+  ~ to you under the Apache License, Version 2.0 (the
+  ~ "License"); you may not use this file except in compliance
+  ~ with the License.  You may obtain a copy of the License at
+  ~
+  ~   http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing,
+  ~ software distributed under the License is distributed on an
+  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  ~ KIND, either express or implied.  See the License for the
+  ~ specific language governing permissions and limitations
+  ~ under the License.
+  -->
+
+<assembly xmlns="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.2"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.2 http://maven.apache.org/xsd/assembly-1.1.2.xsd">
+  <id>application-defaults</id>
+  <includeBaseDirectory>false</includeBaseDirectory>
+  <formats>
+    <format>dir</format>
+  </formats>
+
+  <componentDescriptors>
+    <!--
+     Just specifying bare file names would need a fix for:
+     http://jira.codehaus.org/browse/MASSEMBLY-585
+     -->
+    <componentDescriptor>assemblies/components/application-binaries.xml</componentDescriptor>
+  </componentDescriptors>
 </assembly>
\ No newline at end of file
diff --git a/plugins/application-maven-plugin/src/main/resources/assemblies/components/application-binaries.xml b/plugins/application-maven-plugin/src/main/resources/assemblies/components/application-binaries.xml
index 44249a2..c711419 100644
--- a/plugins/application-maven-plugin/src/main/resources/assemblies/components/application-binaries.xml
+++ b/plugins/application-maven-plugin/src/main/resources/assemblies/components/application-binaries.xml
@@ -1,36 +1,36 @@
-<!--
-  ~ Licensed to the Apache Software Foundation (ASF) under one
-  ~ or more contributor license agreements.  See the NOTICE file
-  ~ distributed with this work for additional information
-  ~ regarding copyright ownership.  The ASF licenses this file
-  ~ to you under the Apache License, Version 2.0 (the
-  ~ "License"); you may not use this file except in compliance
-  ~ with the License.  You may obtain a copy of the License at
-  ~
-  ~   http://www.apache.org/licenses/LICENSE-2.0
-  ~
-  ~ Unless required by applicable law or agreed to in writing,
-  ~ software distributed under the License is distributed on an
-  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-  ~ KIND, either express or implied.  See the License for the
-  ~ specific language governing permissions and limitations
-  ~ under the License.
-  -->
-
-<component xmlns="http://maven.apache.org/plugins/maven-assembly-plugin/component/1.1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-  xsi:schemaLocation="http://maven.apache.org/plugins/maven-assembly-plugin/component/1.1.2 http://maven.apache.org/xsd/component-1.1.2.xsd">
-  <dependencySets>
-    <dependencySet>
-      <useProjectArtifact>true</useProjectArtifact>
-      <useTransitiveDependencies>true</useTransitiveDependencies>
-      <scope>runtime</scope>
-      <outputFileNameMapping>${artifact.artifactId}.${artifact.extension}</outputFileNameMapping>
-      <outputDirectory></outputDirectory>
-    </dependencySet>
-    <dependencySet>
-      <scope>system</scope>
-      <outputFileNameMapping>${artifact.artifactId}.${artifact.extension}</outputFileNameMapping>
-      <outputDirectory></outputDirectory>
-    </dependencySet>
-  </dependencySets>
-</component>
+<!--
+  ~ Licensed to the Apache Software Foundation (ASF) under one
+  ~ or more contributor license agreements.  See the NOTICE file
+  ~ distributed with this work for additional information
+  ~ regarding copyright ownership.  The ASF licenses this file
+  ~ to you under the Apache License, Version 2.0 (the
+  ~ "License"); you may not use this file except in compliance
+  ~ with the License.  You may obtain a copy of the License at
+  ~
+  ~   http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing,
+  ~ software distributed under the License is distributed on an
+  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  ~ KIND, either express or implied.  See the License for the
+  ~ specific language governing permissions and limitations
+  ~ under the License.
+  -->
+
+<component xmlns="http://maven.apache.org/plugins/maven-assembly-plugin/component/1.1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://maven.apache.org/plugins/maven-assembly-plugin/component/1.1.2 http://maven.apache.org/xsd/component-1.1.2.xsd">
+  <dependencySets>
+    <dependencySet>
+      <useProjectArtifact>true</useProjectArtifact>
+      <useTransitiveDependencies>true</useTransitiveDependencies>
+      <scope>runtime</scope>
+      <outputFileNameMapping>${artifact.artifactId}.${artifact.extension}</outputFileNameMapping>
+      <outputDirectory></outputDirectory>
+    </dependencySet>
+    <dependencySet>
+      <scope>system</scope>
+      <outputFileNameMapping>${artifact.artifactId}.${artifact.extension}</outputFileNameMapping>
+      <outputDirectory></outputDirectory>
+    </dependencySet>
+  </dependencySets>
+</component>
diff --git a/plugins/application-maven-plugin/src/site/site.xml b/plugins/application-maven-plugin/src/site/site.xml
index 7c6ce97..ad61ef9 100644
--- a/plugins/application-maven-plugin/src/site/site.xml
+++ b/plugins/application-maven-plugin/src/site/site.xml
@@ -1,32 +1,32 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-  ~ Licensed to the Apache Software Foundation (ASF) under one
-  ~ or more contributor license agreements.  See the NOTICE file
-  ~ distributed with this work for additional information
-  ~ regarding copyright ownership.  The ASF licenses this file
-  ~ to you under the Apache License, Version 2.0 (the
-  ~ "License"); you may not use this file except in compliance
-  ~ with the License.  You may obtain a copy of the License at
-  ~
-  ~   http://www.apache.org/licenses/LICENSE-2.0
-  ~
-  ~ Unless required by applicable law or agreed to in writing,
-  ~ software distributed under the License is distributed on an
-  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-  ~ KIND, either express or implied.  See the License for the
-  ~ specific language governing permissions and limitations
-  ~ under the License.
-  -->
-<project xmlns="http://maven.apache.org/DECORATION/1.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/DECORATION/1.0.0 http://maven.apache.org/xsd/decoration-1.0.0.xsd">
-  <body>
-    <menu ref="parent" />
-
-    <menu name="Overview">
-      <item name="About" href="index.html"/>
-      <item name="Usage" href="usage.html"/>
-      <item name="Goals" href="plugin-info.html"/>
-    </menu>
-
-    <menu ref="reports" />
-  </body>
-</project>
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+  ~ Licensed to the Apache Software Foundation (ASF) under one
+  ~ or more contributor license agreements.  See the NOTICE file
+  ~ distributed with this work for additional information
+  ~ regarding copyright ownership.  The ASF licenses this file
+  ~ to you under the Apache License, Version 2.0 (the
+  ~ "License"); you may not use this file except in compliance
+  ~ with the License.  You may obtain a copy of the License at
+  ~
+  ~   http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing,
+  ~ software distributed under the License is distributed on an
+  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  ~ KIND, either express or implied.  See the License for the
+  ~ specific language governing permissions and limitations
+  ~ under the License.
+  -->
+<project xmlns="http://maven.apache.org/DECORATION/1.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/DECORATION/1.0.0 http://maven.apache.org/xsd/decoration-1.0.0.xsd">
+  <body>
+    <menu ref="parent" />
+
+    <menu name="Overview">
+      <item name="About" href="index.html"/>
+      <item name="Usage" href="usage.html"/>
+      <item name="Goals" href="plugin-info.html"/>
+    </menu>
+
+    <menu ref="reports" />
+  </body>
+</project>
diff --git a/plugins/custom-lifecycle-maven-plugin/src/site/site.xml b/plugins/custom-lifecycle-maven-plugin/src/site/site.xml
index fdb23ea..c437989 100644
--- a/plugins/custom-lifecycle-maven-plugin/src/site/site.xml
+++ b/plugins/custom-lifecycle-maven-plugin/src/site/site.xml
@@ -1,32 +1,32 @@
-<?xml version="1.0" encoding="UTF-8"?>
-
-<!--
-  ~ Licensed to the Apache Software Foundation (ASF) under one
-  ~ or more contributor license agreements.  See the NOTICE file
-  ~ distributed with this work for additional information
-  ~ regarding copyright ownership.  The ASF licenses this file
-  ~ to you under the Apache License, Version 2.0 (the
-  ~ "License"); you may not use this file except in compliance
-  ~ with the License.  You may obtain a copy of the License at
-  ~
-  ~   http://www.apache.org/licenses/LICENSE-2.0
-  ~
-  ~ Unless required by applicable law or agreed to in writing,
-  ~ software distributed under the License is distributed on an
-  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-  ~ KIND, either express or implied.  See the License for the
-  ~ specific language governing permissions and limitations
-  ~ under the License.
-  -->
-<project xmlns="http://maven.apache.org/DECORATION/1.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/DECORATION/1.0.0 http://maven.apache.org/xsd/decoration-1.0.0.xsd">
-  <body>
-    <menu ref="parent" />
-
-    <menu name="Overview">
-      <item name="About" href="index.html"/>
-      <item name="Goals" href="plugin-info.html"/>
-    </menu>
-
-    <menu ref="reports" />
-  </body>
-</project>
+<?xml version="1.0" encoding="UTF-8"?>
+
+<!--
+  ~ Licensed to the Apache Software Foundation (ASF) under one
+  ~ or more contributor license agreements.  See the NOTICE file
+  ~ distributed with this work for additional information
+  ~ regarding copyright ownership.  The ASF licenses this file
+  ~ to you under the Apache License, Version 2.0 (the
+  ~ "License"); you may not use this file except in compliance
+  ~ with the License.  You may obtain a copy of the License at
+  ~
+  ~   http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing,
+  ~ software distributed under the License is distributed on an
+  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  ~ KIND, either express or implied.  See the License for the
+  ~ specific language governing permissions and limitations
+  ~ under the License.
+  -->
+<project xmlns="http://maven.apache.org/DECORATION/1.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/DECORATION/1.0.0 http://maven.apache.org/xsd/decoration-1.0.0.xsd">
+  <body>
+    <menu ref="parent" />
+
+    <menu name="Overview">
+      <item name="About" href="index.html"/>
+      <item name="Goals" href="plugin-info.html"/>
+    </menu>
+
+    <menu ref="reports" />
+  </body>
+</project>
diff --git a/plugins/library-importer-maven-plugin/src/it/IT001_InstallPackages/nunit.lib.xml b/plugins/library-importer-maven-plugin/src/it/IT001_InstallPackages/nunit.lib.xml
index 89c7e05..9c5953c 100644
--- a/plugins/library-importer-maven-plugin/src/it/IT001_InstallPackages/nunit.lib.xml
+++ b/plugins/library-importer-maven-plugin/src/it/IT001_InstallPackages/nunit.lib.xml
@@ -1,27 +1,27 @@
-<!--
-  ~ Licensed to the Apache Software Foundation (ASF) under one
-  ~ or more contributor license agreements.  See the NOTICE file
-  ~ distributed with this work for additional information
-  ~ regarding copyright ownership.  The ASF licenses this file
-  ~ to you under the Apache License, version 2.0 (the
-  ~ "License"); you may not use this file except in compliance
-  ~ with the License.  You may obtain a copy of the License at
-  ~
-  ~   http://www.apache.org/licenses/LICENSE-2.0
-  ~
-  ~ Unless required by applicable law or agreed to in writing,
-  ~ software distributed under the License is distributed on an
-  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-  ~ KIND, either express or implied.  See the License for the
-  ~ specific language governing permissions and limitations
-  ~ under the License.
-  -->
-
-<libs xmlns="http://npanday.apache.org/library-import/1.0.0">
-  <nuget>
-    <package>NUnit</package>
-
-    <version source="2.6.0.12054" mapTo="2.6.0"/>
-    <version source="2.5.10.11092" mapTo="2.5.10"/>
-  </nuget>
+<!--
+  ~ Licensed to the Apache Software Foundation (ASF) under one
+  ~ or more contributor license agreements.  See the NOTICE file
+  ~ distributed with this work for additional information
+  ~ regarding copyright ownership.  The ASF licenses this file
+  ~ to you under the Apache License, version 2.0 (the
+  ~ "License"); you may not use this file except in compliance
+  ~ with the License.  You may obtain a copy of the License at
+  ~
+  ~   http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing,
+  ~ software distributed under the License is distributed on an
+  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  ~ KIND, either express or implied.  See the License for the
+  ~ specific language governing permissions and limitations
+  ~ under the License.
+  -->
+
+<libs xmlns="http://npanday.apache.org/library-import/1.0.0">
+  <nuget>
+    <package>NUnit</package>
+
+    <version source="2.6.0.12054" mapTo="2.6.0"/>
+    <version source="2.5.10.11092" mapTo="2.5.10"/>
+  </nuget>
 </libs>
\ No newline at end of file
diff --git a/plugins/library-importer-maven-plugin/src/it/IT002_GeneratePoms/nunit.lib.xml b/plugins/library-importer-maven-plugin/src/it/IT002_GeneratePoms/nunit.lib.xml
index 66a6161..f5424b4 100644
--- a/plugins/library-importer-maven-plugin/src/it/IT002_GeneratePoms/nunit.lib.xml
+++ b/plugins/library-importer-maven-plugin/src/it/IT002_GeneratePoms/nunit.lib.xml
@@ -1,25 +1,25 @@
-<!--
-  ~ Licensed to the Apache Software Foundation (ASF) under one
-  ~ or more contributor license agreements.  See the NOTICE file
-  ~ distributed with this work for additional information
-  ~ regarding copyright ownership.  The ASF licenses this file
-  ~ to you under the Apache License, version 2.0 (the
-  ~ "License"); you may not use this file except in compliance
-  ~ with the License.  You may obtain a copy of the License at
-  ~
-  ~   http://www.apache.org/licenses/LICENSE-2.0
-  ~
-  ~ Unless required by applicable law or agreed to in writing,
-  ~ software distributed under the License is distributed on an
-  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-  ~ KIND, either express or implied.  See the License for the
-  ~ specific language governing permissions and limitations
-  ~ under the License.
-  -->
-
-<libs xmlns="http://npanday.apache.org/library-import/1.0.0">
-  <nuget>
-    <package>NUnit</package>
-    <version source="2.6.0.12054" mapTo="2.6.0"/>
-  </nuget>
+<!--
+  ~ Licensed to the Apache Software Foundation (ASF) under one
+  ~ or more contributor license agreements.  See the NOTICE file
+  ~ distributed with this work for additional information
+  ~ regarding copyright ownership.  The ASF licenses this file
+  ~ to you under the Apache License, version 2.0 (the
+  ~ "License"); you may not use this file except in compliance
+  ~ with the License.  You may obtain a copy of the License at
+  ~
+  ~   http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing,
+  ~ software distributed under the License is distributed on an
+  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  ~ KIND, either express or implied.  See the License for the
+  ~ specific language governing permissions and limitations
+  ~ under the License.
+  -->
+
+<libs xmlns="http://npanday.apache.org/library-import/1.0.0">
+  <nuget>
+    <package>NUnit</package>
+    <version source="2.6.0.12054" mapTo="2.6.0"/>
+  </nuget>
 </libs>
\ No newline at end of file
diff --git a/plugins/library-importer-maven-plugin/src/it/IT003_MultipleLibDirs/fluentassertions.lib.xml b/plugins/library-importer-maven-plugin/src/it/IT003_MultipleLibDirs/fluentassertions.lib.xml
index 8b6de3f..5cdb3b7 100644
--- a/plugins/library-importer-maven-plugin/src/it/IT003_MultipleLibDirs/fluentassertions.lib.xml
+++ b/plugins/library-importer-maven-plugin/src/it/IT003_MultipleLibDirs/fluentassertions.lib.xml
@@ -1,28 +1,28 @@
-<!--
-  ~ Licensed to the Apache Software Foundation (ASF) under one
-  ~ or more contributor license agreements.  See the NOTICE file
-  ~ distributed with this work for additional information
-  ~ regarding copyright ownership.  The ASF licenses this file
-  ~ to you under the Apache License, version 2.0 (the
-  ~ "License"); you may not use this file except in compliance
-  ~ with the License.  You may obtain a copy of the License at
-  ~
-  ~   http://www.apache.org/licenses/LICENSE-2.0
-  ~
-  ~ Unless required by applicable law or agreed to in writing,
-  ~ software distributed under the License is distributed on an
-  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-  ~ KIND, either express or implied.  See the License for the
-  ~ specific language governing permissions and limitations
-  ~ under the License.
-  -->
-
-<libs xmlns="http://npanday.apache.org/library-import/1.0.0">
-  <nuget>
-    <package>FluentAssertions</package>
-    <version source="1.7.1.1" mapTo="1.7.1"/>
-    <libDirs>
-      <default>net40</default>
-    </libDirs>
-  </nuget>
+<!--
+  ~ Licensed to the Apache Software Foundation (ASF) under one
+  ~ or more contributor license agreements.  See the NOTICE file
+  ~ distributed with this work for additional information
+  ~ regarding copyright ownership.  The ASF licenses this file
+  ~ to you under the Apache License, version 2.0 (the
+  ~ "License"); you may not use this file except in compliance
+  ~ with the License.  You may obtain a copy of the License at
+  ~
+  ~   http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing,
+  ~ software distributed under the License is distributed on an
+  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  ~ KIND, either express or implied.  See the License for the
+  ~ specific language governing permissions and limitations
+  ~ under the License.
+  -->
+
+<libs xmlns="http://npanday.apache.org/library-import/1.0.0">
+  <nuget>
+    <package>FluentAssertions</package>
+    <version source="1.7.1.1" mapTo="1.7.1"/>
+    <libDirs>
+      <default>net40</default>
+    </libDirs>
+  </nuget>
 </libs>
\ No newline at end of file
diff --git a/plugins/library-importer-maven-plugin/src/it/IT004_PackageWithDependencies/common.logging.lib.xml b/plugins/library-importer-maven-plugin/src/it/IT004_PackageWithDependencies/common.logging.lib.xml
index bc3b7d6..115b76d 100644
--- a/plugins/library-importer-maven-plugin/src/it/IT004_PackageWithDependencies/common.logging.lib.xml
+++ b/plugins/library-importer-maven-plugin/src/it/IT004_PackageWithDependencies/common.logging.lib.xml
@@ -1,42 +1,42 @@
-<!--
-  ~ Licensed to the Apache Software Foundation (ASF) under one
-  ~ or more contributor license agreements.  See the NOTICE file
-  ~ distributed with this work for additional information
-  ~ regarding copyright ownership.  The ASF licenses this file
-  ~ to you under the Apache License, version 2.0 (the
-  ~ "License"); you may not use this file except in compliance
-  ~ with the License.  You may obtain a copy of the License at
-  ~
-  ~   http://www.apache.org/licenses/LICENSE-2.0
-  ~
-  ~ Unless required by applicable law or agreed to in writing,
-  ~ software distributed under the License is distributed on an
-  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-  ~ KIND, either express or implied.  See the License for the
-  ~ specific language governing permissions and limitations
-  ~ under the License.
-  -->
-
-<libs xmlns="http://npanday.apache.org/library-import/1.0.0">
-  <nuget>
-    <package>Common.Logging</package>
-    <version source="2.0.0"/>
-    <libDirs>
-      <default>2.0</default>
-    </libDirs>
-  </nuget>
-  <nuget>
-    <package>Common.Logging.Log4Net</package>
-    <version source="2.0.1"/>
-    <libDirs>
-      <default>net20</default>
-    </libDirs>
-  </nuget>
-  <nuget>
-    <package>log4net</package>
-    <version source="1.2.10" />
-    <libDirs>
-      <default>2.0</default>
-    </libDirs>
-  </nuget>
+<!--
+  ~ Licensed to the Apache Software Foundation (ASF) under one
+  ~ or more contributor license agreements.  See the NOTICE file
+  ~ distributed with this work for additional information
+  ~ regarding copyright ownership.  The ASF licenses this file
+  ~ to you under the Apache License, version 2.0 (the
+  ~ "License"); you may not use this file except in compliance
+  ~ with the License.  You may obtain a copy of the License at
+  ~
+  ~   http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing,
+  ~ software distributed under the License is distributed on an
+  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  ~ KIND, either express or implied.  See the License for the
+  ~ specific language governing permissions and limitations
+  ~ under the License.
+  -->
+
+<libs xmlns="http://npanday.apache.org/library-import/1.0.0">
+  <nuget>
+    <package>Common.Logging</package>
+    <version source="2.0.0"/>
+    <libDirs>
+      <default>2.0</default>
+    </libDirs>
+  </nuget>
+  <nuget>
+    <package>Common.Logging.Log4Net</package>
+    <version source="2.0.1"/>
+    <libDirs>
+      <default>net20</default>
+    </libDirs>
+  </nuget>
+  <nuget>
+    <package>log4net</package>
+    <version source="1.2.10" />
+    <libDirs>
+      <default>2.0</default>
+    </libDirs>
+  </nuget>
 </libs>
\ No newline at end of file
diff --git a/plugins/library-importer-maven-plugin/src/it/IT005_CustomDependencyIgnore/autofac.mvc.lib.xml b/plugins/library-importer-maven-plugin/src/it/IT005_CustomDependencyIgnore/autofac.mvc.lib.xml
index ad43ae0..4cc48f0 100644
--- a/plugins/library-importer-maven-plugin/src/it/IT005_CustomDependencyIgnore/autofac.mvc.lib.xml
+++ b/plugins/library-importer-maven-plugin/src/it/IT005_CustomDependencyIgnore/autofac.mvc.lib.xml
@@ -1,40 +1,40 @@
-<!--
-  ~ Licensed to the Apache Software Foundation (ASF) under one
-  ~ or more contributor license agreements.  See the NOTICE file
-  ~ distributed with this work for additional information
-  ~ regarding copyright ownership.  The ASF licenses this file
-  ~ to you under the Apache License, Version 2.0 (the
-  ~ "License"); you may not use this file except in compliance
-  ~ with the License.  You may obtain a copy of the License at
-  ~
-  ~   http://www.apache.org/licenses/LICENSE-2.0
-  ~
-  ~ Unless required by applicable law or agreed to in writing,
-  ~ software distributed under the License is distributed on an
-  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-  ~ KIND, either express or implied.  See the License for the
-  ~ specific language governing permissions and limitations
-  ~ under the License.
-  -->
-
-<libs xmlns="http://npanday.apache.org/library-import/1.0.0">
-  <nuget>
-    <package>Autofac</package>
-    <version source="2.6.1.841" mapTo="2.6.1"/>
-    <libDirs>
-      <default>net35</default>
-    </libDirs>
-  </nuget>
-  <nuget>
-    <package>Autofac.Mvc3</package>
-    <version source="2.6.1.841" mapTo="2.6.1"/>
-    <libDirs>
-      <default>net40</default>
-    </libDirs>
-
-    <mapReference
-      name="Microsoft.Web.Infrastructure"
-      ignore="true"/>
-
-  </nuget>
+<!--
+  ~ Licensed to the Apache Software Foundation (ASF) under one
+  ~ or more contributor license agreements.  See the NOTICE file
+  ~ distributed with this work for additional information
+  ~ regarding copyright ownership.  The ASF licenses this file
+  ~ to you under the Apache License, Version 2.0 (the
+  ~ "License"); you may not use this file except in compliance
+  ~ with the License.  You may obtain a copy of the License at
+  ~
+  ~   http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing,
+  ~ software distributed under the License is distributed on an
+  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  ~ KIND, either express or implied.  See the License for the
+  ~ specific language governing permissions and limitations
+  ~ under the License.
+  -->
+
+<libs xmlns="http://npanday.apache.org/library-import/1.0.0">
+  <nuget>
+    <package>Autofac</package>
+    <version source="2.6.1.841" mapTo="2.6.1"/>
+    <libDirs>
+      <default>net35</default>
+    </libDirs>
+  </nuget>
+  <nuget>
+    <package>Autofac.Mvc3</package>
+    <version source="2.6.1.841" mapTo="2.6.1"/>
+    <libDirs>
+      <default>net40</default>
+    </libDirs>
+
+    <mapReference
+      name="Microsoft.Web.Infrastructure"
+      ignore="true"/>
+
+  </nuget>
 </libs>
\ No newline at end of file
diff --git a/plugins/library-importer-maven-plugin/src/it/IT006_CustomSource/nunit.lib.xml b/plugins/library-importer-maven-plugin/src/it/IT006_CustomSource/nunit.lib.xml
index 3492199..75a873e 100644
--- a/plugins/library-importer-maven-plugin/src/it/IT006_CustomSource/nunit.lib.xml
+++ b/plugins/library-importer-maven-plugin/src/it/IT006_CustomSource/nunit.lib.xml
@@ -1,30 +1,30 @@
-<!--
-  ~ Licensed to the Apache Software Foundation (ASF) under one
-  ~ or more contributor license agreements.  See the NOTICE file
-  ~ distributed with this work for additional information
-  ~ regarding copyright ownership.  The ASF licenses this file
-  ~ to you under the Apache License, Version 2.0 (the
-  ~ "License"); you may not use this file except in compliance
-  ~ with the License.  You may obtain a copy of the License at
-  ~
-  ~   http://www.apache.org/licenses/LICENSE-2.0
-  ~
-  ~ Unless required by applicable law or agreed to in writing,
-  ~ software distributed under the License is distributed on an
-  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-  ~ KIND, either express or implied.  See the License for the
-  ~ specific language governing permissions and limitations
-  ~ under the License.
-  -->
-
-<libs xmlns="http://npanday.apache.org/library-import/1.0.0">
-
-  <nugetSources addNugetGallery="false">
-    <custom>package-source</custom>
-  </nugetSources>
-
-  <nuget>
-    <package>NUnit</package>
-    <version source="2.5.10.11092" mapTo="2.5.10"/>
-  </nuget>
+<!--
+  ~ Licensed to the Apache Software Foundation (ASF) under one
+  ~ or more contributor license agreements.  See the NOTICE file
+  ~ distributed with this work for additional information
+  ~ regarding copyright ownership.  The ASF licenses this file
+  ~ to you under the Apache License, Version 2.0 (the
+  ~ "License"); you may not use this file except in compliance
+  ~ with the License.  You may obtain a copy of the License at
+  ~
+  ~   http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing,
+  ~ software distributed under the License is distributed on an
+  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  ~ KIND, either express or implied.  See the License for the
+  ~ specific language governing permissions and limitations
+  ~ under the License.
+  -->
+
+<libs xmlns="http://npanday.apache.org/library-import/1.0.0">
+
+  <nugetSources addNugetGallery="false">
+    <custom>package-source</custom>
+  </nugetSources>
+
+  <nuget>
+    <package>NUnit</package>
+    <version source="2.5.10.11092" mapTo="2.5.10"/>
+  </nuget>
 </libs>
\ No newline at end of file
diff --git a/plugins/library-importer-maven-plugin/src/it/IT007_InstallToCustomLocalRepository/nunit.lib.xml b/plugins/library-importer-maven-plugin/src/it/IT007_InstallToCustomLocalRepository/nunit.lib.xml
index e6b4485..c87406a 100644
--- a/plugins/library-importer-maven-plugin/src/it/IT007_InstallToCustomLocalRepository/nunit.lib.xml
+++ b/plugins/library-importer-maven-plugin/src/it/IT007_InstallToCustomLocalRepository/nunit.lib.xml
@@ -1,30 +1,30 @@
-<!--
-  ~ Licensed to the Apache Software Foundation (ASF) under one
-  ~ or more contributor license agreements.  See the NOTICE file
-  ~ distributed with this work for additional information
-  ~ regarding copyright ownership.  The ASF licenses this file
-  ~ to you under the Apache License, Version 2.0 (the
-  ~ "License"); you may not use this file except in compliance
-  ~ with the License.  You may obtain a copy of the License at
-  ~
-  ~   http://www.apache.org/licenses/LICENSE-2.0
-  ~
-  ~ Unless required by applicable law or agreed to in writing,
-  ~ software distributed under the License is distributed on an
-  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-  ~ KIND, either express or implied.  See the License for the
-  ~ specific language governing permissions and limitations
-  ~ under the License.
-  -->
-
-<libs xmlns="http://npanday.apache.org/library-import/1.0.0">
-
-  <nugetSources addNugetGallery="false">
-    <custom>package-source</custom>
-  </nugetSources>
-
-  <nuget>
-    <package>NUnit</package>
-    <version source="2.6.0.12054" mapTo="2.6.0"/>
-  </nuget>
+<!--
+  ~ Licensed to the Apache Software Foundation (ASF) under one
+  ~ or more contributor license agreements.  See the NOTICE file
+  ~ distributed with this work for additional information
+  ~ regarding copyright ownership.  The ASF licenses this file
+  ~ to you under the Apache License, Version 2.0 (the
+  ~ "License"); you may not use this file except in compliance
+  ~ with the License.  You may obtain a copy of the License at
+  ~
+  ~   http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing,
+  ~ software distributed under the License is distributed on an
+  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  ~ KIND, either express or implied.  See the License for the
+  ~ specific language governing permissions and limitations
+  ~ under the License.
+  -->
+
+<libs xmlns="http://npanday.apache.org/library-import/1.0.0">
+
+  <nugetSources addNugetGallery="false">
+    <custom>package-source</custom>
+  </nugetSources>
+
+  <nuget>
+    <package>NUnit</package>
+    <version source="2.6.0.12054" mapTo="2.6.0"/>
+  </nuget>
 </libs>
\ No newline at end of file
diff --git a/plugins/library-importer-maven-plugin/src/it/IT008_DeployToCustomLocalRepository/nunit.lib.xml b/plugins/library-importer-maven-plugin/src/it/IT008_DeployToCustomLocalRepository/nunit.lib.xml
index e6b4485..c87406a 100644
--- a/plugins/library-importer-maven-plugin/src/it/IT008_DeployToCustomLocalRepository/nunit.lib.xml
+++ b/plugins/library-importer-maven-plugin/src/it/IT008_DeployToCustomLocalRepository/nunit.lib.xml
@@ -1,30 +1,30 @@
-<!--
-  ~ Licensed to the Apache Software Foundation (ASF) under one
-  ~ or more contributor license agreements.  See the NOTICE file
-  ~ distributed with this work for additional information
-  ~ regarding copyright ownership.  The ASF licenses this file
-  ~ to you under the Apache License, Version 2.0 (the
-  ~ "License"); you may not use this file except in compliance
-  ~ with the License.  You may obtain a copy of the License at
-  ~
-  ~   http://www.apache.org/licenses/LICENSE-2.0
-  ~
-  ~ Unless required by applicable law or agreed to in writing,
-  ~ software distributed under the License is distributed on an
-  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-  ~ KIND, either express or implied.  See the License for the
-  ~ specific language governing permissions and limitations
-  ~ under the License.
-  -->
-
-<libs xmlns="http://npanday.apache.org/library-import/1.0.0">
-
-  <nugetSources addNugetGallery="false">
-    <custom>package-source</custom>
-  </nugetSources>
-
-  <nuget>
-    <package>NUnit</package>
-    <version source="2.6.0.12054" mapTo="2.6.0"/>
-  </nuget>
+<!--
+  ~ Licensed to the Apache Software Foundation (ASF) under one
+  ~ or more contributor license agreements.  See the NOTICE file
+  ~ distributed with this work for additional information
+  ~ regarding copyright ownership.  The ASF licenses this file
+  ~ to you under the Apache License, Version 2.0 (the
+  ~ "License"); you may not use this file except in compliance
+  ~ with the License.  You may obtain a copy of the License at
+  ~
+  ~   http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing,
+  ~ software distributed under the License is distributed on an
+  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  ~ KIND, either express or implied.  See the License for the
+  ~ specific language governing permissions and limitations
+  ~ under the License.
+  -->
+
+<libs xmlns="http://npanday.apache.org/library-import/1.0.0">
+
+  <nugetSources addNugetGallery="false">
+    <custom>package-source</custom>
+  </nugetSources>
+
+  <nuget>
+    <package>NUnit</package>
+    <version source="2.6.0.12054" mapTo="2.6.0"/>
+  </nuget>
 </libs>
\ No newline at end of file
diff --git a/plugins/library-importer-maven-plugin/src/it/IT009_ImporterLifecycle/nunit.lib.xml b/plugins/library-importer-maven-plugin/src/it/IT009_ImporterLifecycle/nunit.lib.xml
index e6b4485..c87406a 100644
--- a/plugins/library-importer-maven-plugin/src/it/IT009_ImporterLifecycle/nunit.lib.xml
+++ b/plugins/library-importer-maven-plugin/src/it/IT009_ImporterLifecycle/nunit.lib.xml
@@ -1,30 +1,30 @@
-<!--
-  ~ Licensed to the Apache Software Foundation (ASF) under one
-  ~ or more contributor license agreements.  See the NOTICE file
-  ~ distributed with this work for additional information
-  ~ regarding copyright ownership.  The ASF licenses this file
-  ~ to you under the Apache License, Version 2.0 (the
-  ~ "License"); you may not use this file except in compliance
-  ~ with the License.  You may obtain a copy of the License at
-  ~
-  ~   http://www.apache.org/licenses/LICENSE-2.0
-  ~
-  ~ Unless required by applicable law or agreed to in writing,
-  ~ software distributed under the License is distributed on an
-  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-  ~ KIND, either express or implied.  See the License for the
-  ~ specific language governing permissions and limitations
-  ~ under the License.
-  -->
-
-<libs xmlns="http://npanday.apache.org/library-import/1.0.0">
-
-  <nugetSources addNugetGallery="false">
-    <custom>package-source</custom>
-  </nugetSources>
-
-  <nuget>
-    <package>NUnit</package>
-    <version source="2.6.0.12054" mapTo="2.6.0"/>
-  </nuget>
+<!--
+  ~ Licensed to the Apache Software Foundation (ASF) under one
+  ~ or more contributor license agreements.  See the NOTICE file
+  ~ distributed with this work for additional information
+  ~ regarding copyright ownership.  The ASF licenses this file
+  ~ to you under the Apache License, Version 2.0 (the
+  ~ "License"); you may not use this file except in compliance
+  ~ with the License.  You may obtain a copy of the License at
+  ~
+  ~   http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing,
+  ~ software distributed under the License is distributed on an
+  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  ~ KIND, either express or implied.  See the License for the
+  ~ specific language governing permissions and limitations
+  ~ under the License.
+  -->
+
+<libs xmlns="http://npanday.apache.org/library-import/1.0.0">
+
+  <nugetSources addNugetGallery="false">
+    <custom>package-source</custom>
+  </nugetSources>
+
+  <nuget>
+    <package>NUnit</package>
+    <version source="2.6.0.12054" mapTo="2.6.0"/>
+  </nuget>
 </libs>
\ No newline at end of file
diff --git a/plugins/library-importer-maven-plugin/src/main/resources/META-INF/npanday/executable-plugins.xml b/plugins/library-importer-maven-plugin/src/main/resources/META-INF/npanday/executable-plugins.xml
index 372dd8a..3480b7f 100644
--- a/plugins/library-importer-maven-plugin/src/main/resources/META-INF/npanday/executable-plugins.xml
+++ b/plugins/library-importer-maven-plugin/src/main/resources/META-INF/npanday/executable-plugins.xml
@@ -1,49 +1,49 @@
-<!--
-  ~ Licensed to the Apache Software Foundation (ASF) under one
-  ~ or more contributor license agreements.  See the NOTICE file
-  ~ distributed with this work for additional information
-  ~ regarding copyright ownership.  The ASF licenses this file
-  ~ to you under the Apache License, version 2.0 (the
-  ~ "License"); you may not use this file except in compliance
-  ~ with the License.  You may obtain a copy of the License at
-  ~
-  ~   http://www.apache.org/licenses/LICENSE-2.0
-  ~
-  ~ Unless required by applicable law or agreed to in writing,
-  ~ software distributed under the License is distributed on an
-  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-  ~ KIND, either express or implied.  See the License for the
-  ~ specific language governing permissions and limitations
-  ~ under the License.
-  -->
-
-<executablePlugins xmlns="http://npanday.apache.org/executables/1.5.0">
-
-  <executablePlugin>
-    <profile>MANIFESTINFO</profile>
-    <pluginClass>npanday.executable.impl.DefaultNetExecutable</pluginClass>
-
-    <executable>manifestinfo</executable>
-    <executableVersion>1.0</executableVersion>
-
-    <vendor>MICROSOFT</vendor>
-
-    <frameworkVersions>
-      <frameworkVersion>4.5.1</frameworkVersion>
-      <frameworkVersion>4.5</frameworkVersion>
-      <frameworkVersion>4.0</frameworkVersion>
-      <frameworkVersion>3.5</frameworkVersion>
-      <frameworkVersion>2.0</frameworkVersion>
-    </frameworkVersions>
-
-    <probingPaths>
-    </probingPaths>
-
-    <platforms>
-      <platform>
-        <operatingSystem>Windows</operatingSystem>
-      </platform>
-    </platforms>
-
-  </executablePlugin>
-</executablePlugins>
+<!--
+  ~ Licensed to the Apache Software Foundation (ASF) under one
+  ~ or more contributor license agreements.  See the NOTICE file
+  ~ distributed with this work for additional information
+  ~ regarding copyright ownership.  The ASF licenses this file
+  ~ to you under the Apache License, version 2.0 (the
+  ~ "License"); you may not use this file except in compliance
+  ~ with the License.  You may obtain a copy of the License at
+  ~
+  ~   http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing,
+  ~ software distributed under the License is distributed on an
+  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  ~ KIND, either express or implied.  See the License for the
+  ~ specific language governing permissions and limitations
+  ~ under the License.
+  -->
+
+<executablePlugins xmlns="http://npanday.apache.org/executables/1.5.0">
+
+  <executablePlugin>
+    <profile>MANIFESTINFO</profile>
+    <pluginClass>npanday.executable.impl.DefaultNetExecutable</pluginClass>
+
+    <executable>manifestinfo</executable>
+    <executableVersion>1.0</executableVersion>
+
+    <vendor>MICROSOFT</vendor>
+
+    <frameworkVersions>
+      <frameworkVersion>4.5.1</frameworkVersion>
+      <frameworkVersion>4.5</frameworkVersion>
+      <frameworkVersion>4.0</frameworkVersion>
+      <frameworkVersion>3.5</frameworkVersion>
+      <frameworkVersion>2.0</frameworkVersion>
+    </frameworkVersions>
+
+    <probingPaths>
+    </probingPaths>
+
+    <platforms>
+      <platform>
+        <operatingSystem>Windows</operatingSystem>
+      </platform>
+    </platforms>
+
+  </executablePlugin>
+</executablePlugins>
diff --git a/plugins/library-importer-maven-plugin/src/main/resources/META-INF/plexus/components.xml b/plugins/library-importer-maven-plugin/src/main/resources/META-INF/plexus/components.xml
index 63b34a0..b2dc8c8 100644
--- a/plugins/library-importer-maven-plugin/src/main/resources/META-INF/plexus/components.xml
+++ b/plugins/library-importer-maven-plugin/src/main/resources/META-INF/plexus/components.xml
@@ -1,26 +1,26 @@
-<!--
-  ~ Licensed to the Apache Software Foundation (ASF) under one
-  ~ or more contributor license agreements.  See the NOTICE file
-  ~ distributed with this work for additional information
-  ~ regarding copyright ownership.  The ASF licenses this file
-  ~ to you under the Apache License, version 2.0 (the
-  ~ "License"); you may not use this file except in compliance
-  ~ with the License.  You may obtain a copy of the License at
-  ~
-  ~   http://www.apache.org/licenses/LICENSE-2.0
-  ~
-  ~ Unless required by applicable law or agreed to in writing,
-  ~ software distributed under the License is distributed on an
-  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-  ~ KIND, either express or implied.  See the License for the
-  ~ specific language governing permissions and limitations
-  ~ under the License.
-  -->
-
-<component-set>
-  <!--  
-  The contents of this file are generated on generate-resources
-  by 'src/main/scripts/plexus_components_xml.groovy' in order
-  to avoid endless violations of DRY.
-  -->
-</component-set>
+<!--
+  ~ Licensed to the Apache Software Foundation (ASF) under one
+  ~ or more contributor license agreements.  See the NOTICE file
+  ~ distributed with this work for additional information
+  ~ regarding copyright ownership.  The ASF licenses this file
+  ~ to you under the Apache License, version 2.0 (the
+  ~ "License"); you may not use this file except in compliance
+  ~ with the License.  You may obtain a copy of the License at
+  ~
+  ~   http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing,
+  ~ software distributed under the License is distributed on an
+  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  ~ KIND, either express or implied.  See the License for the
+  ~ specific language governing permissions and limitations
+  ~ under the License.
+  -->
+
+<component-set>
+  <!--  
+  The contents of this file are generated on generate-resources
+  by 'src/main/scripts/plexus_components_xml.groovy' in order
+  to avoid endless violations of DRY.
+  -->
+</component-set>
diff --git a/plugins/library-importer-maven-plugin/src/site/site.xml b/plugins/library-importer-maven-plugin/src/site/site.xml
index 914cf2d..a86e528 100644
--- a/plugins/library-importer-maven-plugin/src/site/site.xml
+++ b/plugins/library-importer-maven-plugin/src/site/site.xml
@@ -1,34 +1,34 @@
-<?xml version="1.0" encoding="UTF-8"?>
-
-<!--
-  ~ Licensed to the Apache Software Foundation (ASF) under one
-  ~ or more contributor license agreements.  See the NOTICE file
-  ~ distributed with this work for additional information
-  ~ regarding copyright ownership.  The ASF licenses this file
-  ~ to you under the Apache License, version 2.0 (the
-  ~ "License"); you may not use this file except in compliance
-  ~ with the License.  You may obtain a copy of the License at
-  ~
-  ~   http://www.apache.org/licenses/LICENSE-2.0
-  ~
-  ~ Unless required by applicable law or agreed to in writing,
-  ~ software distributed under the License is distributed on an
-  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-  ~ KIND, either express or implied.  See the License for the
-  ~ specific language governing permissions and limitations
-  ~ under the License.
-  -->
-<project xmlns="http://maven.apache.org/DECORATION/1.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/DECORATION/1.0.0 http://maven.apache.org/xsd/decoration-1.0.0.xsd">
-  <body>
-    <menu ref="parent" />
-
-    <menu name="Overview">
-      <item name="About" href="index.html"/>
-      <item name="Goals" href="plugin-info.html"/>
-      <item name="Usage" href="usage.html"/>
-      <item name="Nuget Mapping" href="nuget-mapping.html"/>
-    </menu>
-
-    <menu ref="reports" />
-  </body>
-</project>
+<?xml version="1.0" encoding="UTF-8"?>
+
+<!--
+  ~ Licensed to the Apache Software Foundation (ASF) under one
+  ~ or more contributor license agreements.  See the NOTICE file
+  ~ distributed with this work for additional information
+  ~ regarding copyright ownership.  The ASF licenses this file
+  ~ to you under the Apache License, version 2.0 (the
+  ~ "License"); you may not use this file except in compliance
+  ~ with the License.  You may obtain a copy of the License at
+  ~
+  ~   http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing,
+  ~ software distributed under the License is distributed on an
+  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  ~ KIND, either express or implied.  See the License for the
+  ~ specific language governing permissions and limitations
+  ~ under the License.
+  -->
+<project xmlns="http://maven.apache.org/DECORATION/1.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/DECORATION/1.0.0 http://maven.apache.org/xsd/decoration-1.0.0.xsd">
+  <body>
+    <menu ref="parent" />
+
+    <menu name="Overview">
+      <item name="About" href="index.html"/>
+      <item name="Goals" href="plugin-info.html"/>
+      <item name="Usage" href="usage.html"/>
+      <item name="Nuget Mapping" href="nuget-mapping.html"/>
+    </menu>
+
+    <menu ref="reports" />
+  </body>
+</project>
diff --git a/plugins/maven-fxcop-plugin/Output.xml b/plugins/maven-fxcop-plugin/Output.xml
index 40af631..b04909d 100644
--- a/plugins/maven-fxcop-plugin/Output.xml
+++ b/plugins/maven-fxcop-plugin/Output.xml
@@ -1,4 +1,4 @@
-﻿<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <?xml-stylesheet type="text/xsl" href="http://www.gotdotnet.com/team/fxcop//xsl/1.35/FxCopReport.xsl"?>
 <!--
 Licensed to the Apache Software Foundation (ASF) under one
diff --git a/plugins/netplugins/NPanday.Plugin.Devenv/javabinding/src/site/site.xml b/plugins/netplugins/NPanday.Plugin.Devenv/javabinding/src/site/site.xml
index 6e16b56..2d2fbaa 100644
--- a/plugins/netplugins/NPanday.Plugin.Devenv/javabinding/src/site/site.xml
+++ b/plugins/netplugins/NPanday.Plugin.Devenv/javabinding/src/site/site.xml
@@ -1,31 +1,31 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-  ~ Licensed to the Apache Software Foundation (ASF) under one
-  ~ or more contributor license agreements.  See the NOTICE file
-  ~ distributed with this work for additional information
-  ~ regarding copyright ownership.  The ASF licenses this file
-  ~ to you under the Apache License, Version 2.0 (the
-  ~ "License"); you may not use this file except in compliance
-  ~ with the License.  You may obtain a copy of the License at
-  ~
-  ~   http://www.apache.org/licenses/LICENSE-2.0
-  ~
-  ~ Unless required by applicable law or agreed to in writing,
-  ~ software distributed under the License is distributed on an
-  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-  ~ KIND, either express or implied.  See the License for the
-  ~ specific language governing permissions and limitations
-  ~ under the License.
-  -->
-<project xmlns="http://maven.apache.org/DECORATION/1.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/DECORATION/1.0.0 http://maven.apache.org/xsd/decoration-1.0.0.xsd">
-  <body>
-    <menu ref="parent" />
-
-    <menu name="Overview">
-      <item name="About" href="index.html"/>
-      <item name="Goals" href="plugin-info.html"/>
-    </menu>
-
-    <menu ref="reports" />
-  </body>
-</project>
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+  ~ Licensed to the Apache Software Foundation (ASF) under one
+  ~ or more contributor license agreements.  See the NOTICE file
+  ~ distributed with this work for additional information
+  ~ regarding copyright ownership.  The ASF licenses this file
+  ~ to you under the Apache License, Version 2.0 (the
+  ~ "License"); you may not use this file except in compliance
+  ~ with the License.  You may obtain a copy of the License at
+  ~
+  ~   http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing,
+  ~ software distributed under the License is distributed on an
+  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  ~ KIND, either express or implied.  See the License for the
+  ~ specific language governing permissions and limitations
+  ~ under the License.
+  -->
+<project xmlns="http://maven.apache.org/DECORATION/1.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/DECORATION/1.0.0 http://maven.apache.org/xsd/decoration-1.0.0.xsd">
+  <body>
+    <menu ref="parent" />
+
+    <menu name="Overview">
+      <item name="About" href="index.html"/>
+      <item name="Goals" href="plugin-info.html"/>
+    </menu>
+
+    <menu ref="reports" />
+  </body>
+</project>
diff --git a/plugins/netplugins/NPanday.Plugin.Msbuild/javabinding/src/site/site.xml b/plugins/netplugins/NPanday.Plugin.Msbuild/javabinding/src/site/site.xml
index 6e16b56..2d2fbaa 100644
--- a/plugins/netplugins/NPanday.Plugin.Msbuild/javabinding/src/site/site.xml
+++ b/plugins/netplugins/NPanday.Plugin.Msbuild/javabinding/src/site/site.xml
@@ -1,31 +1,31 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-  ~ Licensed to the Apache Software Foundation (ASF) under one
-  ~ or more contributor license agreements.  See the NOTICE file
-  ~ distributed with this work for additional information
-  ~ regarding copyright ownership.  The ASF licenses this file
-  ~ to you under the Apache License, Version 2.0 (the
-  ~ "License"); you may not use this file except in compliance
-  ~ with the License.  You may obtain a copy of the License at
-  ~
-  ~   http://www.apache.org/licenses/LICENSE-2.0
-  ~
-  ~ Unless required by applicable law or agreed to in writing,
-  ~ software distributed under the License is distributed on an
-  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-  ~ KIND, either express or implied.  See the License for the
-  ~ specific language governing permissions and limitations
-  ~ under the License.
-  -->
-<project xmlns="http://maven.apache.org/DECORATION/1.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/DECORATION/1.0.0 http://maven.apache.org/xsd/decoration-1.0.0.xsd">
-  <body>
-    <menu ref="parent" />
-
-    <menu name="Overview">
-      <item name="About" href="index.html"/>
-      <item name="Goals" href="plugin-info.html"/>
-    </menu>
-
-    <menu ref="reports" />
-  </body>
-</project>
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+  ~ Licensed to the Apache Software Foundation (ASF) under one
+  ~ or more contributor license agreements.  See the NOTICE file
+  ~ distributed with this work for additional information
+  ~ regarding copyright ownership.  The ASF licenses this file
+  ~ to you under the Apache License, Version 2.0 (the
+  ~ "License"); you may not use this file except in compliance
+  ~ with the License.  You may obtain a copy of the License at
+  ~
+  ~   http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing,
+  ~ software distributed under the License is distributed on an
+  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  ~ KIND, either express or implied.  See the License for the
+  ~ specific language governing permissions and limitations
+  ~ under the License.
+  -->
+<project xmlns="http://maven.apache.org/DECORATION/1.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/DECORATION/1.0.0 http://maven.apache.org/xsd/decoration-1.0.0.xsd">
+  <body>
+    <menu ref="parent" />
+
+    <menu name="Overview">
+      <item name="About" href="index.html"/>
+      <item name="Goals" href="plugin-info.html"/>
+    </menu>
+
+    <menu ref="reports" />
+  </body>
+</project>
diff --git a/plugins/netplugins/NPanday.Plugin.Settings/javabinding/src/site/site.xml b/plugins/netplugins/NPanday.Plugin.Settings/javabinding/src/site/site.xml
index 6e16b56..2d2fbaa 100644
--- a/plugins/netplugins/NPanday.Plugin.Settings/javabinding/src/site/site.xml
+++ b/plugins/netplugins/NPanday.Plugin.Settings/javabinding/src/site/site.xml
@@ -1,31 +1,31 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-  ~ Licensed to the Apache Software Foundation (ASF) under one
-  ~ or more contributor license agreements.  See the NOTICE file
-  ~ distributed with this work for additional information
-  ~ regarding copyright ownership.  The ASF licenses this file
-  ~ to you under the Apache License, Version 2.0 (the
-  ~ "License"); you may not use this file except in compliance
-  ~ with the License.  You may obtain a copy of the License at
-  ~
-  ~   http://www.apache.org/licenses/LICENSE-2.0
-  ~
-  ~ Unless required by applicable law or agreed to in writing,
-  ~ software distributed under the License is distributed on an
-  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-  ~ KIND, either express or implied.  See the License for the
-  ~ specific language governing permissions and limitations
-  ~ under the License.
-  -->
-<project xmlns="http://maven.apache.org/DECORATION/1.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/DECORATION/1.0.0 http://maven.apache.org/xsd/decoration-1.0.0.xsd">
-  <body>
-    <menu ref="parent" />
-
-    <menu name="Overview">
-      <item name="About" href="index.html"/>
-      <item name="Goals" href="plugin-info.html"/>
-    </menu>
-
-    <menu ref="reports" />
-  </body>
-</project>
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+  ~ Licensed to the Apache Software Foundation (ASF) under one
+  ~ or more contributor license agreements.  See the NOTICE file
+  ~ distributed with this work for additional information
+  ~ regarding copyright ownership.  The ASF licenses this file
+  ~ to you under the Apache License, Version 2.0 (the
+  ~ "License"); you may not use this file except in compliance
+  ~ with the License.  You may obtain a copy of the License at
+  ~
+  ~   http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing,
+  ~ software distributed under the License is distributed on an
+  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  ~ KIND, either express or implied.  See the License for the
+  ~ specific language governing permissions and limitations
+  ~ under the License.
+  -->
+<project xmlns="http://maven.apache.org/DECORATION/1.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/DECORATION/1.0.0 http://maven.apache.org/xsd/decoration-1.0.0.xsd">
+  <body>
+    <menu ref="parent" />
+
+    <menu name="Overview">
+      <item name="About" href="index.html"/>
+      <item name="Goals" href="plugin-info.html"/>
+    </menu>
+
+    <menu ref="reports" />
+  </body>
+</project>
diff --git a/plugins/netplugins/NPanday.Plugin.SysRef/javabinding/src/site/site.xml b/plugins/netplugins/NPanday.Plugin.SysRef/javabinding/src/site/site.xml
index 6e16b56..2d2fbaa 100644
--- a/plugins/netplugins/NPanday.Plugin.SysRef/javabinding/src/site/site.xml
+++ b/plugins/netplugins/NPanday.Plugin.SysRef/javabinding/src/site/site.xml
@@ -1,31 +1,31 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-  ~ Licensed to the Apache Software Foundation (ASF) under one
-  ~ or more contributor license agreements.  See the NOTICE file
-  ~ distributed with this work for additional information
-  ~ regarding copyright ownership.  The ASF licenses this file
-  ~ to you under the Apache License, Version 2.0 (the
-  ~ "License"); you may not use this file except in compliance
-  ~ with the License.  You may obtain a copy of the License at
-  ~
-  ~   http://www.apache.org/licenses/LICENSE-2.0
-  ~
-  ~ Unless required by applicable law or agreed to in writing,
-  ~ software distributed under the License is distributed on an
-  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-  ~ KIND, either express or implied.  See the License for the
-  ~ specific language governing permissions and limitations
-  ~ under the License.
-  -->
-<project xmlns="http://maven.apache.org/DECORATION/1.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/DECORATION/1.0.0 http://maven.apache.org/xsd/decoration-1.0.0.xsd">
-  <body>
-    <menu ref="parent" />
-
-    <menu name="Overview">
-      <item name="About" href="index.html"/>
-      <item name="Goals" href="plugin-info.html"/>
-    </menu>
-
-    <menu ref="reports" />
-  </body>
-</project>
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+  ~ Licensed to the Apache Software Foundation (ASF) under one
+  ~ or more contributor license agreements.  See the NOTICE file
+  ~ distributed with this work for additional information
+  ~ regarding copyright ownership.  The ASF licenses this file
+  ~ to you under the Apache License, Version 2.0 (the
+  ~ "License"); you may not use this file except in compliance
+  ~ with the License.  You may obtain a copy of the License at
+  ~
+  ~   http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing,
+  ~ software distributed under the License is distributed on an
+  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  ~ KIND, either express or implied.  See the License for the
+  ~ specific language governing permissions and limitations
+  ~ under the License.
+  -->
+<project xmlns="http://maven.apache.org/DECORATION/1.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/DECORATION/1.0.0 http://maven.apache.org/xsd/decoration-1.0.0.xsd">
+  <body>
+    <menu ref="parent" />
+
+    <menu name="Overview">
+      <item name="About" href="index.html"/>
+      <item name="Goals" href="plugin-info.html"/>
+    </menu>
+
+    <menu ref="reports" />
+  </body>
+</project>
diff --git a/pom.xml b/pom.xml
index 190c2e9..c2f6fac 100644
--- a/pom.xml
+++ b/pom.xml
@@ -1,4 +1,4 @@
-﻿<?xml version="1.0" encoding="UTF-8"?>
+<?xml version="1.0" encoding="UTF-8"?>
 
 <!--
 Licensed to the Apache Software Foundation (ASF) under one
