diff --git a/distro-source/core/src/gwt-module.dtd b/distro-source/core/src/gwt-module.dtd
index 3f61ace..9598534 100644
--- a/distro-source/core/src/gwt-module.dtd
+++ b/distro-source/core/src/gwt-module.dtd
@@ -1,85 +1,85 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--                                                                        -->
-<!-- Copyright 2007 Google Inc.                                             -->
-<!-- Licensed under the Apache License, Version 2.0 (the "License"); you    -->
-<!-- may not use this file except in compliance with the License. You may   -->
-<!-- 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. License for the specific language governing permissions and   -->
-<!-- limitations under the License.                                         -->
-
-<!-- The module root element -->
-<!ELEMENT module (inherits | source | public | super-source | entry-point | 
-  stylesheet | script | servlet | replace-with | generate-with |
-  define-property | extend-property | set-property | property-provider)*>
-<!-- Inherit the contents of another module -->
-<!ELEMENT inherits EMPTY>
-<!ATTLIST inherits
-	name CDATA #REQUIRED
->
-<!-- Specify the source path, relative to the classpath location of the module descriptor -->
-<!ELEMENT source (include | exclude)*>
-<!ATTLIST source
-	path CDATA #REQUIRED
-		includes CDATA #IMPLIED
-		excludes CDATA #IMPLIED
-		defaultexclude (yes | no) "yes"
-		casesensitive (true | false) "true"
->
-<!-- Specify the public resource path, relative to the classpath location of the module descriptor -->
-<!ELEMENT public (include | exclude)*>
-<!ATTLIST public
-	path CDATA #REQUIRED
-		includes CDATA #IMPLIED
-		excludes CDATA #IMPLIED
-		defaultexclude (yes | no) "yes"
-		casesensitive (true | false) "true"
->
-<!-- Specify a source path that rebases subpackages into the root namespace -->
-<!ELEMENT super-source (include | exclude)*>
-<!ATTLIST super-source
-	path CDATA #REQUIRED
-		includes CDATA #IMPLIED
-		excludes CDATA #IMPLIED
-		defaultexclude (yes | no) "yes"
-		casesensitive (true | false) "true"
->
-<!ELEMENT include EMPTY>
-<!ATTLIST include
-	name CDATA #REQUIRED
->
-<!ELEMENT exclude EMPTY>
-<!ATTLIST exclude
-	name CDATA #REQUIRED
->
-
-<!-- Define a module entry point -->
-<!ELEMENT entry-point EMPTY>
-<!ATTLIST entry-point
-	class CDATA #REQUIRED
+<?xml version="1.0" encoding="UTF-8"?>
+<!--                                                                        -->
+<!-- Copyright 2007 Google Inc.                                             -->
+<!-- Licensed under the Apache License, Version 2.0 (the "License"); you    -->
+<!-- may not use this file except in compliance with the License. You may   -->
+<!-- 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. License for the specific language governing permissions and   -->
+<!-- limitations under the License.                                         -->
+
+<!-- The module root element -->
+<!ELEMENT module (inherits | source | public | super-source | entry-point | 
+  stylesheet | script | servlet | replace-with | generate-with |
+  define-property | extend-property | set-property | property-provider)*>
+<!-- Inherit the contents of another module -->
+<!ELEMENT inherits EMPTY>
+<!ATTLIST inherits
+	name CDATA #REQUIRED
+>
+<!-- Specify the source path, relative to the classpath location of the module descriptor -->
+<!ELEMENT source (include | exclude)*>
+<!ATTLIST source
+	path CDATA #REQUIRED
+		includes CDATA #IMPLIED
+		excludes CDATA #IMPLIED
+		defaultexclude (yes | no) "yes"
+		casesensitive (true | false) "true"
+>
+<!-- Specify the public resource path, relative to the classpath location of the module descriptor -->
+<!ELEMENT public (include | exclude)*>
+<!ATTLIST public
+	path CDATA #REQUIRED
+		includes CDATA #IMPLIED
+		excludes CDATA #IMPLIED
+		defaultexclude (yes | no) "yes"
+		casesensitive (true | false) "true"
+>
+<!-- Specify a source path that rebases subpackages into the root namespace -->
+<!ELEMENT super-source (include | exclude)*>
+<!ATTLIST super-source
+	path CDATA #REQUIRED
+		includes CDATA #IMPLIED
+		excludes CDATA #IMPLIED
+		defaultexclude (yes | no) "yes"
+		casesensitive (true | false) "true"
+>
+<!ELEMENT include EMPTY>
+<!ATTLIST include
+	name CDATA #REQUIRED
+>
+<!ELEMENT exclude EMPTY>
+<!ATTLIST exclude
+	name CDATA #REQUIRED
 >
 
-<!-- Preload a stylesheet before executing the GWT application -->
-<!ELEMENT stylesheet EMPTY>
-<!ATTLIST stylesheet
-	src CDATA #REQUIRED
->
-<!-- Preload an external JavaScript file before executing the GWT application -->
-<!ELEMENT script (#PCDATA)>
-<!ATTLIST script
-	src CDATA #REQUIRED
->
-<!-- Map a named servlet class to a module-relative path in hosted mode -->
-<!ELEMENT servlet EMPTY>
-<!ATTLIST servlet 
-	path CDATA #REQUIRED
-	class CDATA #REQUIRED
->
+<!-- Define a module entry point -->
+<!ELEMENT entry-point EMPTY>
+<!ATTLIST entry-point
+	class CDATA #REQUIRED
+>
+
+<!-- Preload a stylesheet before executing the GWT application -->
+<!ELEMENT stylesheet EMPTY>
+<!ATTLIST stylesheet
+	src CDATA #REQUIRED
+>
+<!-- Preload an external JavaScript file before executing the GWT application -->
+<!ELEMENT script (#PCDATA)>
+<!ATTLIST script
+	src CDATA #REQUIRED
+>
+<!-- Map a named servlet class to a module-relative path in hosted mode -->
+<!ELEMENT servlet EMPTY>
+<!ATTLIST servlet 
+	path CDATA #REQUIRED
+	class CDATA #REQUIRED
+>
 
 <!-- Sets the default linker to use in the absence of a -target flag -->
 <!ELEMENT set-linker EMPTY>
@@ -94,64 +94,64 @@
   class CDATA #REQUIRED
   name CDATA #REQUIRED
 >
-
-<!--                 ^^^ Commonly-used elements ^^^                -->
-<!--                VVV Deferred binding elements VVV              -->
-
-<!-- Define a property and allowable values (comma-separated identifiers) -->
-<!ELEMENT define-property EMPTY>
-<!ATTLIST define-property
-	name CDATA #REQUIRED
-	values CDATA #REQUIRED
->
-<!-- Set the value of a previously-defined property -->
-<!ELEMENT set-property EMPTY>
-<!ATTLIST set-property
-	name CDATA #REQUIRED
-	value CDATA #REQUIRED
->
-<!-- Add additional allowable values to a property -->
-<!ELEMENT extend-property EMPTY>
-<!ATTLIST extend-property
-	name CDATA #REQUIRED
-	values CDATA #REQUIRED
->
-<!-- Define a JavaScript fragment that will return the value for the named property at runtime -->
-<!ELEMENT property-provider (#PCDATA)>
-<!ATTLIST property-provider
-	name CDATA #REQUIRED
->
-<!-- All possible predicates -->
-<!ENTITY % predicates "when-property-is | when-type-assignable | when-type-is | all | any | none">
-<!-- Deferred binding assignment to substitute a named class -->
-<!ELEMENT replace-with (%predicates;)*>
-<!ATTLIST replace-with
-	class CDATA #REQUIRED
->
-<!-- Deferred binding assignment to substitute a generated class -->
-<!ELEMENT generate-with (%predicates;)*>
-<!ATTLIST generate-with
-	class CDATA #REQUIRED
->
-<!-- Deferred binding predicate that is true when a named property has a given value-->
-<!ELEMENT when-property-is EMPTY>
-<!ATTLIST when-property-is
-	name CDATA #REQUIRED
-	value CDATA #REQUIRED
->
-<!-- Deferred binding predicate that is true for types in the type system that are assignable to the specified type -->
-<!ELEMENT when-type-assignable EMPTY>
-<!ATTLIST when-type-assignable
-	class CDATA #REQUIRED
->
-<!-- Deferred binding predicate that is true for exactly one type in the type system -->
-<!ELEMENT when-type-is EMPTY>
-<!ATTLIST when-type-is
-	class CDATA #REQUIRED
->
-<!-- Predicate that ANDs all child conditions -->
-<!ELEMENT all (%predicates;)*>
-<!-- Predicate that ORs all child conditions -->
-<!ELEMENT any (%predicates;)*>
-<!-- Predicate that NANDs all child conditions -->
-<!ELEMENT none (%predicates;)*>
+
+<!--                 ^^^ Commonly-used elements ^^^                -->
+<!--                VVV Deferred binding elements VVV              -->
+
+<!-- Define a property and allowable values (comma-separated identifiers) -->
+<!ELEMENT define-property EMPTY>
+<!ATTLIST define-property
+	name CDATA #REQUIRED
+	values CDATA #REQUIRED
+>
+<!-- Set the value of a previously-defined property -->
+<!ELEMENT set-property EMPTY>
+<!ATTLIST set-property
+	name CDATA #REQUIRED
+	value CDATA #REQUIRED
+>
+<!-- Add additional allowable values to a property -->
+<!ELEMENT extend-property EMPTY>
+<!ATTLIST extend-property
+	name CDATA #REQUIRED
+	values CDATA #REQUIRED
+>
+<!-- Define a JavaScript fragment that will return the value for the named property at runtime -->
+<!ELEMENT property-provider (#PCDATA)>
+<!ATTLIST property-provider
+	name CDATA #REQUIRED
+>
+<!-- All possible predicates -->
+<!ENTITY % predicates "when-property-is | when-type-assignable | when-type-is | all | any | none">
+<!-- Deferred binding assignment to substitute a named class -->
+<!ELEMENT replace-with (%predicates;)*>
+<!ATTLIST replace-with
+	class CDATA #REQUIRED
+>
+<!-- Deferred binding assignment to substitute a generated class -->
+<!ELEMENT generate-with (%predicates;)*>
+<!ATTLIST generate-with
+	class CDATA #REQUIRED
+>
+<!-- Deferred binding predicate that is true when a named property has a given value-->
+<!ELEMENT when-property-is EMPTY>
+<!ATTLIST when-property-is
+	name CDATA #REQUIRED
+	value CDATA #REQUIRED
+>
+<!-- Deferred binding predicate that is true for types in the type system that are assignable to the specified type -->
+<!ELEMENT when-type-assignable EMPTY>
+<!ATTLIST when-type-assignable
+	class CDATA #REQUIRED
+>
+<!-- Deferred binding predicate that is true for exactly one type in the type system -->
+<!ELEMENT when-type-is EMPTY>
+<!ATTLIST when-type-is
+	class CDATA #REQUIRED
+>
+<!-- Predicate that ANDs all child conditions -->
+<!ELEMENT all (%predicates;)*>
+<!-- Predicate that ORs all child conditions -->
+<!ELEMENT any (%predicates;)*>
+<!-- Predicate that NANDs all child conditions -->
+<!ELEMENT none (%predicates;)*>
