Merge lp:~zorba-coders/zorba/update3.0_data-cleaning-module into lp:zorba/data-cleaning-module

[Juan Zacarias]

Changes for Update 3.0

Changes for Update 3.0

[Chris Hillery (ceejatec)]

1. Need to put <p/> tags between doc paragraphs, including after leading short description. (Remove <br/> tags.)

2. The error in currency-convert() should be in the module's own namespace/prefix, with ALL-CAPS name.

3. Based on the test cases, some other functions also raise errors, but those are not documented.

review: Needs Fixing

[lp:~zorba-coders/zorba/update3.0_data-cleaning-module]

48. By Juan Zacarias on 2013-06-19

Reverted update 3.0 changes.

49. By Juan Zacarias on 2013-06-19

Updated module to 3.0, updated documentation and changed module's namespace.

50. By Juan Zacarias on 2013-06-19

Added error to documentation.

51. By Juan Zacarias on 2013-06-19

Changed error name to caps

[Juan Zacarias (juan457)]

Changes done

[Chris Hillery (ceejatec)]

review: Approve

[Juan Zacarias (juan457)]

review: Approve

[Zorba Build Bot (zorba-buildbot)]

Validation queue starting for the following merge proposals:
https://code.launchpad.net/~zorba-coders/zorba/update3.0_data-cleaning-module/+merge/170213

Progress dashboard at http://jenkins.lambda.nu/view/ValidationQueue

[Zorba Build Bot (zorba-buildbot)]

Validation queue result for https://code.launchpad.net/~zorba-coders/zorba/update3.0_data-cleaning-module/+merge/170213

Stage "TestZorbaUbuntu" failed.
2 tests failed (8345 total tests run).

Check test results at http://jenkins.lambda.nu/job/TestZorbaUbuntu/59/testReport/ to view the results.

[lp:~zorba-coders/zorba/update3.0_data-cleaning-module]

52. By Chris Hillery on 2013-07-10

Fixed <p> typos.

[Zorba Build Bot (zorba-buildbot)]

Validation queue starting for the following merge proposals:
https://code.launchpad.net/~zorba-coders/zorba/update3.0_data-cleaning-module/+merge/170213

Progress dashboard at http://jenkins.lambda.nu/view/ValidationQueue

[Zorba Build Bot (zorba-buildbot)]

Validation queue succeeded - proposal merged!

[Bruno Martins (bgmartins)]

review: Approve

=== removed file 'src/CMakeLists.txt'
--- src/CMakeLists.txt	2011-07-26 10:43:16 +0000
+++ src/CMakeLists.txt	1970-01-01 00:00:00 +0000
@@ -1,20 +0,0 @@
-# Copyright 2006-2008 The FLWOR Foundation.
-# 
-# Licensed 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.
-
-# all external module libraries are generated in the directory
-# of the corresponding .xq file
-MESSAGE(STATUS "Add com")
-ADD_SUBDIRECTORY(com)
-
-MESSAGE(STATUS "End modules")

=== renamed file 'src/com/zorba-xquery/www/modules/data-cleaning/CMakeLists.txt' => 'src/CMakeLists.txt'
--- src/com/zorba-xquery/www/modules/data-cleaning/CMakeLists.txt	2011-08-07 20:36:50 +0000
+++ src/CMakeLists.txt	2013-07-10 00:51:26 +0000
@@ -12,29 +12,29 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-DECLARE_ZORBA_MODULE (URI "http://www.zorba-xquery.com/modules/data-cleaning/character-based-string-similarity"
+DECLARE_ZORBA_MODULE (URI "http://zorba.io/modules/data-cleaning/character-based-string-similarity"
                       VERSION 2.0 FILE "character-based-string-similarity.xq")
 
-DECLARE_ZORBA_MODULE (URI "http://www.zorba-xquery.com/modules/data-cleaning/consolidation"
+DECLARE_ZORBA_MODULE (URI "http://zorba.io/modules/data-cleaning/consolidation"
                       VERSION 2.0 FILE "consolidation.xq")
 
 DECLARE_ZORBA_SCHEMA( FILE whitepages_schema.xsd
                       URI "http://api.whitepages.com/schema/")
                       
-DECLARE_ZORBA_MODULE (URI "http://www.zorba-xquery.com/modules/data-cleaning/conversion"
+DECLARE_ZORBA_MODULE (URI "http://zorba.io/modules/data-cleaning/conversion"
                       VERSION 2.0 FILE "conversion.xq")
 
-DECLARE_ZORBA_MODULE (URI "http://www.zorba-xquery.com/modules/data-cleaning/hybrid-string-similarity"
+DECLARE_ZORBA_MODULE (URI "http://zorba.io/modules/data-cleaning/hybrid-string-similarity"
                       VERSION 2.0 FILE "hybrid-string-similarity.xq")
 
-DECLARE_ZORBA_MODULE (URI "http://www.zorba-xquery.com/modules/data-cleaning/normalization"
+DECLARE_ZORBA_MODULE (URI "http://zorba.io/modules/data-cleaning/normalization"
                       VERSION 2.0 FILE "normalization.xq")
 
-DECLARE_ZORBA_MODULE (URI "http://www.zorba-xquery.com/modules/data-cleaning/phonetic-string-similarity"
+DECLARE_ZORBA_MODULE (URI "http://zorba.io/modules/data-cleaning/phonetic-string-similarity"
                       VERSION 2.0 FILE "phonetic-string-similarity.xq")
 
-DECLARE_ZORBA_MODULE (URI "http://www.zorba-xquery.com/modules/data-cleaning/set-similarity"
+DECLARE_ZORBA_MODULE (URI "http://zorba.io/modules/data-cleaning/set-similarity"
                       VERSION 2.0 FILE "set-similarity.xq")
 
-DECLARE_ZORBA_MODULE (URI "http://www.zorba-xquery.com/modules/data-cleaning/token-based-string-similarity"
+DECLARE_ZORBA_MODULE (URI "http://zorba.io/modules/data-cleaning/token-based-string-similarity"
                       VERSION 2.0 FILE "token-based-string-similarity.xq")

=== renamed file 'src/com/zorba-xquery/www/modules/data-cleaning/character-based-string-similarity.xq' => 'src/character-based-string-similarity.xq'
--- src/com/zorba-xquery/www/modules/data-cleaning/character-based-string-similarity.xq	2012-09-28 13:34:20 +0000
+++ src/character-based-string-similarity.xq	2013-07-10 00:51:26 +0000
@@ -2,7 +2,7 @@
 
 (:
  : Copyright 2006-2009 The FLWOR Foundation.
- :
+ :                      
  : Licensed 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
@@ -17,35 +17,32 @@
  :)
 
 (:~
- : This library module provides character-based string similarity functions 
+ : <p>This library module provides character-based string similarity functions 
  : that view strings as sequences of characters, generally computing a similarity score
  : that corresponds to the cost of transforming one string into another.
- :
  : These functions are particularly useful for matching near duplicate strings  
- : in the presence of typographical errors. 
- :
- : The logic contained in this module is not specific to any particular XQuery implementation.
+ : in the presence of typographical errors. </p>
+ : <p>The logic contained in this module is not specific to any particular XQuery implementation.</p>
  :
  : @author Bruno Martins and Diogo Simões
  : @project Zorba/Data Cleaning/Character-Based String Similarity
  :)
 
-module namespace simc = "http://www.zorba-xquery.com/modules/data-cleaning/character-based-string-similarity";
+module namespace simc = "http://zorba.io/modules/data-cleaning/character-based-string-similarity";
 
 declare namespace ver = "http://www.zorba-xquery.com/options/versioning";
 declare option ver:module-version "2.0";
 
 (:~
- : Returns the edit distance between two strings.
- :
- : This distance, also refered to as the Levenshtein distance, is defined as the minimum number 
+ : <p>Returns the edit distance between two strings.</p>
+ : <p/>
+ : <p>This distance, also refered to as the Levenshtein distance, is defined as the minimum number 
  : of edits needed to transform one string into the other, with the allowable edit operations 
- : being insertion, deletion, or substitution of a single character.
- :
- : <br/>
- : Example usage : <code>edit-distance("FLWOR", "FLOWER")</code>
- : <br/>
- : The function invocation in the example above returns : <code>2</code>
+ : being insertion, deletion, or substitution of a single character.</p>
+ : <p/>
+ : <p>Example usage : <code>edit-distance("FLWOR", "FLOWER")</code></p>
+ : <p/>
+ : <p>The function invocation in the example above returns : <code>2</code></p>
  :
  : @param $s1 The first string.
  : @param $s2 The second string.
@@ -63,17 +60,16 @@
 };
 
 (:~
- : Returns the Jaro similarity coefficient between two strings.
- :
- : This similarity coefficient is based on the number of transposed characters and on a 
+ : <p>Returns the Jaro similarity coefficient between two strings.</p>
+ : <p/>
+ : <p>This similarity coefficient is based on the number of transposed characters and on a 
  : weighted sum of the percentage of matched characters held within the strings. The higher 
  : the Jaro-Winkler value is, the more similar the strings are. The coefficient is 
- : normalized such that 0 equates to no similarity and 1 is an exact match.
- :
- : <br/>
- : Example usage : <code>jaro("FLWOR Found.", "FLWOR Foundation")</code>
- : <br/>
- : The function invocation in the example above returns : <code>0.5853174603174603</code>
+ : normalized such that 0 equates to no similarity and 1 is an exact match.</p>
+ : <p/>
+ : <p>Example usage : <code>jaro("FLWOR Found.", "FLWOR Foundation")</code></p>
+ : <p/>
+ : <p>The function invocation in the example above returns : <code>0.5853174603174603</code></p>
  :
  : @param $s1 The first string.
  : @param $s2 The second string.
@@ -97,15 +93,14 @@
 };
 
 (:~
- : Returns the Jaro-Winkler similarity coefficient between two strings.
- :
- : This similarity coefficient corresponds to an extension of the Jaro similarity coefficient that weights or
- : penalizes strings based on their similarity at the beginning of the string, up to a given prefix size.
- :
- : <br/>
- : Example usage : <code>jaro-winkler("DWAYNE", "DUANE", 4, 0.1 )</code>
- : <br/>
- : The function invocation in the example above returns : <code>0.8577777777777778</code>
+ : <p>Returns the Jaro-Winkler similarity coefficient between two strings.</p>
+ : <p/>
+ : <p>This similarity coefficient corresponds to an extension of the Jaro similarity coefficient that weights or
+ : penalizes strings based on their similarity at the beginning of the string, up to a given prefix size.</p>
+ : <p/>
+ : <p>Example usage : <code>jaro-winkler("DWAYNE", "DUANE", 4, 0.1 )</code></p>
+ : <p/>
+ : <p>The function invocation in the example above returns : <code>0.8577777777777778</code></p>
  :
  : @param $s1 The first string.
  : @param $s2 The second string.
@@ -122,16 +117,15 @@
 };
 
 (:~
- : Returns the Needleman-Wunsch distance between two strings.
- :
- : The Needleman-Wunsch distance is similar to the basic edit distance metric, adding a 
+ : <p>Returns the Needleman-Wunsch distance between two strings.</p>
+ : <p/>
+ : <p>The Needleman-Wunsch distance is similar to the basic edit distance metric, adding a 
  : variable cost adjustment to the cost of a gap (i.e., an insertion or deletion) in the 
- : distance metric.
- :
- : <br/>
- : Example usage : <code>needleman-wunsch("KAK", "KQRK", 1, 1)</code>
- : <br/>
- : The function invocation in the example above returns : <code>0</code>
+ : distance metric.</p>
+ : <p/>
+ : <p>Example usage : <code>needleman-wunsch("KAK", "KQRK", 1, 1)</code></p>
+ : <p/>
+ : <p>The function invocation in the example above returns : <code>0</code></p>
  :
  : @param $s1 The first string.
  : @param $s2 The second string.
@@ -152,12 +146,11 @@
 };
 
 (:~
- : Returns the Smith-Waterman distance between two strings.
- :
- : <br/>
- : Example usage : <code>smith-waterman("ACACACTA", "AGCACACA", 2, 1)</code>
- : <br/>
- : The function invocation in the example above returns : <code>12</code>
+ : <p>Returns the Smith-Waterman distance between two strings.</p>
+ : <p/>
+ : <p>Example usage : <code>smith-waterman("ACACACTA", "AGCACACA", 2, 1)</code></p>
+ : <p/>
+ : <p>The function invocation in the example above returns : <code>12</code></p>
  :
  : @param $s1 The first string.
  : @param $s2 The second string.

=== removed directory 'src/com'
=== removed file 'src/com/CMakeLists.txt'
--- src/com/CMakeLists.txt	2011-10-06 08:17:41 +0000
+++ src/com/CMakeLists.txt	1970-01-01 00:00:00 +0000
@@ -1,17 +0,0 @@
-# Copyright 2006-2008 The FLWOR Foundation.
-# 
-# Licensed 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.
-
-# all external module libraries are generated in the directory
-# of the corresponding .xq file
-ADD_SUBDIRECTORY(zorba-xquery)

=== removed directory 'src/com/zorba-xquery'
=== removed file 'src/com/zorba-xquery/CMakeLists.txt'
--- src/com/zorba-xquery/CMakeLists.txt	2011-10-06 08:17:41 +0000
+++ src/com/zorba-xquery/CMakeLists.txt	1970-01-01 00:00:00 +0000
@@ -1,17 +0,0 @@
-# Copyright 2006-2008 The FLWOR Foundation.
-# 
-# Licensed 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.
-
-# all external module libraries are generated in the directory
-# of the corresponding .xq file
-ADD_SUBDIRECTORY(www)

=== removed directory 'src/com/zorba-xquery/www'
=== removed file 'src/com/zorba-xquery/www/CMakeLists.txt'
--- src/com/zorba-xquery/www/CMakeLists.txt	2011-10-06 08:17:41 +0000
+++ src/com/zorba-xquery/www/CMakeLists.txt	1970-01-01 00:00:00 +0000
@@ -1,17 +0,0 @@
-# Copyright 2006-2008 The FLWOR Foundation.
-# 
-# Licensed 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.
-
-# all external module libraries are generated in the directory
-# of the corresponding .xq file
-ADD_SUBDIRECTORY(modules)

=== removed directory 'src/com/zorba-xquery/www/modules'
=== removed file 'src/com/zorba-xquery/www/modules/CMakeLists.txt'
--- src/com/zorba-xquery/www/modules/CMakeLists.txt	2011-10-06 08:17:41 +0000
+++ src/com/zorba-xquery/www/modules/CMakeLists.txt	1970-01-01 00:00:00 +0000
@@ -1,17 +0,0 @@
-# Copyright 2006-2008 The FLWOR Foundation.
-# 
-# Licensed 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.
-
-# all external module libraries are generated in the directory
-# of the corresponding .xq file
-ADD_SUBDIRECTORY(data-cleaning)

=== removed directory 'src/com/zorba-xquery/www/modules/data-cleaning'
=== renamed file 'src/com/zorba-xquery/www/modules/data-cleaning/consolidation.xq' => 'src/consolidation.xq'
--- src/com/zorba-xquery/www/modules/data-cleaning/consolidation.xq	2012-11-28 18:23:07 +0000
+++ src/consolidation.xq	2013-07-10 00:51:26 +0000
@@ -17,33 +17,33 @@
  :)
 
 (:~
- : This library module provides data consolidation functions that generally take as input a sequence of XML nodes
- : and apply some rule in order do decide which node is better suited to represent the entire sequence.
- :
- : The logic contained in this module is not specific to any particular XQuery implementation, 
+ : <p>This library module provides data consolidation functions that generally take as input a sequence of XML nodes
+ : and apply some rule in order do decide which node is better suited to represent the entire sequence.</p>
+ : <p/>
+ : <p>The logic contained in this module is not specific to any particular XQuery implementation, 
  : although the consolidation functions based on matching sequences against XPath expressions require 
- : some form of dynamic evaluation for XPath expressions.
+ : some form of dynamic evaluation for XPath expressions.</p>
  :
  : @author Bruno Martins
  : @project Zorba/Data Cleaning/Consolidation
  :)
 
-module namespace con = "http://www.zorba-xquery.com/modules/data-cleaning/consolidation";
+module namespace con = "http://zorba.io/modules/data-cleaning/consolidation";
 
-import module namespace set = "http://www.zorba-xquery.com/modules/data-cleaning/set-similarity";
-import module namespace simc = "http://www.zorba-xquery.com/modules/data-cleaning/character-based-string-similarity";
+import module namespace set = "http://zorba.io/modules/data-cleaning/set-similarity";
+import module namespace simc = "http://zorba.io/modules/data-cleaning/character-based-string-similarity";
 
 declare namespace ver = "http://www.zorba-xquery.com/options/versioning";
 declare option ver:module-version "2.0";
 
 (:~
- : Returns the single most frequent node in a sequence of nodes provided as input.
- : If more then one answer is possible, returns the first node according to the order of the input sequence.
- :
- : <br/>
- : Example usage : <code>most-frequent( ( "a", "a", "b") )</code>
- : <br/>
- : The function invocation in the example above returns : <code>("a")</code>
+ : <p>Returns the single most frequent node in a sequence of nodes provided as input.</p>
+ : <p>If more then one answer is possible, returns the first node according to the order of the input sequence.</p>
+ : <p/>
+ : 
+ : <p>Example usage : <code>most-frequent( ( "a", "a", "b") )</code></p>
+ : <p/>
+ : <p>The function invocation in the example above returns : <code>("a")</code></p>
  :
  : @param $s A sequence of nodes.
  : @return The most frequent node in the input sequence.
@@ -54,13 +54,13 @@
 };
 
 (:~
- : Returns the single less frequent node in a sequence of nodes provided as input.
- : If more then one answer is possible, return the first node according to the order of the input sequence.
- :
- : <br/>
- : Example usage : <code>least-frequent( ( "a", "a", "b") )</code>
- : <br/>
- : The function invocation in the example above returns : <code>("b")</code>
+ : <p>Returns the single less frequent node in a sequence of nodes provided as input.</p>
+ : <p>If more then one answer is possible, return the first node according to the order of the input sequence.</p>
+ : <p/>
+ : 
+ : <p>Example usage : <code>least-frequent( ( "a", "a", "b") )</code></p>
+ : <p/>
+ : <p>The function invocation in the example above returns : <code>("b")</code></p>
  :
  : @param $s A sequence of nodes.
  : @return The least frequent node in the input sequence.
@@ -72,13 +72,13 @@
 };
 
 (:~
- : Returns the single longest string, in terms of the number of characters, in a sequence of strings provided as input.
- : If more then one answer is possible, return the first string according to the order of the input sequence.
- :
- : <br/>
- : Example usage : <code>con:longest( ( "a", "aa", "aaa") )</code>
- : <br/>
- : The function invocation in the example above returns : <code>("aaa")</code>
+ : <p>Returns the single longest string, in terms of the number of characters, in a sequence of strings provided as input.</p>
+ : <p>If more then one answer is possible, return the first string according to the order of the input sequence.</p>
+ : <p/>
+ : 
+ : <p>Example usage : <code>con:longest( ( "a", "aa", "aaa") )</code></p>
+ : <p/>
+ : <p>The function invocation in the example above returns : <code>("aaa")</code></p>
  :
  : @param $s A sequence of strings.
  : @return The longest string in the input sequence.
@@ -90,13 +90,13 @@
 };
 
 (:~
- : Returns the single shortest string, in terms of the number of characters, in a sequence of strings provided as input.
- : If more then one answer is possible, return the first string according to the order of the input sequence.
- :
- : <br/>
- : Example usage : <code>shortest( ( "a", "aa", "aaa") )</code>
- : <br/>
- : The function invocation in the example above returns : <code>("a")</code>
+ : <p>Returns the single shortest string, in terms of the number of characters, in a sequence of strings provided as input.</p>
+ : <p>If more then one answer is possible, return the first string according to the order of the input sequence.</p>
+ : <p/>
+ : 
+ : <p>Example usage : <code>shortest( ( "a", "aa", "aaa") )</code></p>
+ : <p/>
+ : <p>The function invocation in the example above returns : <code>("a")</code></p>
  :
  : @param $s A sequence of strings.
  : @return The shortest string in the input sequence.
@@ -108,13 +108,13 @@
 };
 
 (:~
- : Returns the single longest string, in terms of the number of tokens, in a sequence of strings provided as input.
- : If more then one answer is possible, return the first string according to the order of the input sequence.
- :
- : <br/>
- : Example usage : <code>most-tokens( ( "a b c", "a b", "a"), " +" )</code>
- : <br/>
- : The function invocation in the example above returns : <code>("a b c")</code>
+ : <p>Returns the single longest string, in terms of the number of tokens, in a sequence of strings provided as input.</p>
+ : <p>If more then one answer is possible, return the first string according to the order of the input sequence.</p>
+ : <p/>
+ : 
+ : <p>Example usage : <code>most-tokens( ( "a b c", "a b", "a"), " +" )</code></p>
+ : <p/>
+ : <p>The function invocation in the example above returns : <code>("a b c")</code></p>
  :
  : @param $s A sequence of strings.
  : @param $r A regular expression forming the delimiter character(s) which mark the boundaries between adjacent tokens.
@@ -127,13 +127,13 @@
 };
 
 (:~
- : Returns the single shortest string, in terms of the number of tokens, in a sequence of strings provided as input.
- : If more then one answer is possible, return the first string according to the order of the input sequence.
- :
- : <br/>
- : Example usage : <code>least-tokens( ( "a b c", "a b", "a"), " +" )</code>
- : <br/>
- : The function invocation in the example above returns : <code>("a")</code>
+ : <p>Returns the single shortest string, in terms of the number of tokens, in a sequence of strings provided as input.</p>
+ : <p>If more then one answer is possible, return the first string according to the order of the input sequence.</p>
+ : <p/>
+ : 
+ : <p>Example usage : <code>least-tokens( ( "a b c", "a b", "a"), " +" )</code></p>
+ : <p/>
+ : <p>The function invocation in the example above returns : <code>("a")</code></p>
  :
  : @param $s A sequence of strings.
  : @param $r A regular expression forming the delimiter character(s) which mark the boundaries between adjacent tokens.
@@ -146,12 +146,12 @@
 };
 
 (:~
- : Returns the strings from an input sequence of strings that match a particular regular expression.
- :
- : <br/>
- : Example usage : <code>matching( ( "a A b", "c AAA d", "e BB f"), "A+" )</code>
- : <br/>
- : The function invocation in the example above returns : <code>( "a A b", "c AAA d")</code>
+ : <p>Returns the strings from an input sequence of strings that match a particular regular expression.</p>
+ : <p/>
+ : 
+ : <p>Example usage : <code>matching( ( "a A b", "c AAA d", "e BB f"), "A+" )</code></p>
+ : <p/>
+ : <p>The function invocation in the example above returns : <code>( "a A b", "c AAA d")</code></p>
  :
  : @param $s A sequence of strings.
  : @param $r The regular expression to be used in the matching.
@@ -163,14 +163,14 @@
 };
 
 (:~
- : Returns the single string, from an input sequence of strings, that appears more frequently as part
- : of the other strings in the sequence. If no such string exists, the function returns an empty sequence.
- : If more then one answer is possible, the function returns the first string according to the order of the input sequence.
- :
- : <br/>
- : Example usage : <code>super-string( ( "aaa bbb ccc", "aaa bbb", "aaa ddd", "eee fff" ) )</code>
- : <br/>
- : The function invocation in the example above returns : <code>( "aaa bbb" )</code>
+ : <p>Returns the single string, from an input sequence of strings, that appears more frequently as part
+ : of the other strings in the sequence. If no such string exists, the function returns an empty sequence.</p>
+ : <p>If more then one answer is possible, the function returns the first string according to the order of the input sequence.</p>
+ : <p/>
+ : 
+ : <p>Example usage : <code>super-string( ( "aaa bbb ccc", "aaa bbb", "aaa ddd", "eee fff" ) )</code></p>
+ : <p/>
+ : <p>The function invocation in the example above returns : <code>( "aaa bbb" )</code></p>
  :
  : @param $s A sequence of strings.
  : @return The string that appears more frequently as part of the other strings in the sequence.
@@ -187,15 +187,15 @@
 };
 
 (:~
- : Returns the single most similar string, in terms of the edit distance metric towards an input string, 
+ : <p>Returns the single most similar string, in terms of the edit distance metric towards an input string, 
  : in a sequence of strings provided as input. If more than one string has a maximum similarity (a minimum 
  : value for the edit distance metric), the function return the first string according to the order of the 
- : input sequence.
- :
- : <br/>
- : Example usage : <code>most-similar-edit-distance( ( "aaabbbccc", "aaabbb", "eeefff" ), "aaab" )</code>
- : <br/>
- : The function invocation in the example above returns : <code>( "aaabbb" )</code>
+ : input sequence.</p>
+ : <p/>
+ : 
+ : <p>Example usage : <code>most-similar-edit-distance( ( "aaabbbccc", "aaabbb", "eeefff" ), "aaab" )</code></p>
+ : <p/>
+ : <p>The function invocation in the example above returns : <code>( "aaabbb" )</code></p>
  :
  : @param $s A sequence of strings.
  : @param $m The string towards which we want to measure the edit distance.
@@ -208,14 +208,14 @@
 };
 
 (:~
- : Returns the single least similar string, in terms of the edit distance metric towards an input string, 
+ : <p>Returns the single least similar string, in terms of the edit distance metric towards an input string, 
  : in a sequence of strings provided as input. If more than one string has a minimum similarity (a maximum 
- : value for the edit distance metric), return the first string according to the order of the input sequence.
- :
- : <br/>
- : Example usage : <code>least-similar-edit-distance( ( "aaabbbccc", "aaabbb", "eeefff" ), "aaab" )</code>
- : <br/>
- : The function invocation in the example above returns : <code>( "eeefff" )</code>
+ : value for the edit distance metric), return the first string according to the order of the input sequence.</p>
+ : <p/>
+ : 
+ : <p>Example usage : <code>least-similar-edit-distance( ( "aaabbbccc", "aaabbb", "eeefff" ), "aaab" )</code></p>
+ : <p/>
+ : <p>The function invocation in the example above returns : <code>( "eeefff" )</code></p>
  :
  : @param $s A sequence of strings.
  : @param $m The string towards which we want to measure the edit distance.
@@ -228,14 +228,14 @@
 };
 
 (:~
- : Returns the single node having the largest number of descending elements (sub-elements at any given depth) 
- : in a sequence of nodes provided as input.
- : If more then one answer is possible, return the first node according to the order of the input sequence.
- :
- : <br/>
- : Example usage : <code>most-elements( ( &lt;a&gt;&lt;b/&gt;&lt;/a&gt;, &lt;a/&gt;, &lt;b/&gt;) )</code>
- : <br/>
- : The function invocation in the example above returns : <code>(&lt;a&gt;&lt;b/&gt;&lt;/a&gt;)</code>
+ : <p>Returns the single node having the largest number of descending elements (sub-elements at any given depth) 
+ : in a sequence of nodes provided as input.</p>
+ : <p>If more then one answer is possible, return the first node according to the order of the input sequence.</p>
+ : <p/>
+ : 
+ : <p>Example usage : <code>most-elements( ( &lt;a&gt;&lt;b/&gt;&lt;/a&gt;, &lt;a/&gt;, &lt;b/&gt;) )</code></p>
+ : <p/>
+ : <p>The function invocation in the example above returns : <code>(&lt;a&gt;&lt;b/&gt;&lt;/a&gt;)</code></p>
  :
  : @param $s A sequence of nodes.
  : @return The node having the largest number of descending elements in the input sequence.
@@ -246,14 +246,14 @@
 };
 
 (:~
- : Returns the single node having the largest number of descending attributes (attributes at any given depth) 
- : in a sequence of nodes provided as input.
- : If more then one answer is possible, return the first node according to the order of the input sequence.
- :
- : <br/>
- : Example usage : <code>most-attributes( ( &lt;a att1="a1" att2="a2"/&gt;, &lt;b att1="a1" /&gt;, &lt;c/&gt; ) )</code>
- : <br/>
- : The function invocation in the example above returns : <code>(&lt;a att1="a1" att2="a2"/&gt;)</code>
+ : <p>Returns the single node having the largest number of descending attributes (attributes at any given depth) 
+ : in a sequence of nodes provided as input.</p>
+ : <p>If more then one answer is possible, return the first node according to the order of the input sequence.</p>
+ : <p/>
+ : 
+ : <p>Example usage : <code>most-attributes( ( &lt;a att1="a1" att2="a2"/&gt;, &lt;b att1="a1" /&gt;, &lt;c/&gt; ) )</code></p>
+ : <p/>
+ : <p>The function invocation in the example above returns : <code>(&lt;a att1="a1" att2="a2"/&gt;)</code></p>
  :
  : @param $s A sequence of nodes.
  : @return The node having the largest number of descending attributes in the input sequence.
@@ -264,14 +264,14 @@
 };
 
 (:~
- : Returns the single node having the largest number of descending nodes (sub-nodes at any given depth) in a 
- : sequence of nodes provided as input.
- : If more then one answer is possible, return the first node according to the order of the input sequence.
- :
- : <br/>
- : Example usage : <code>most-nodes( ( &lt;a&gt;&lt;b/&gt;&lt;/a&gt;, &lt;a/&gt;, &lt;b/&gt;) )</code>
- : <br/>
- : The function invocation in the example above returns : <code>(&lt;a&gt;&lt;b/&gt;&lt;/a&gt;)</code>
+ : <p>Returns the single node having the largest number of descending nodes (sub-nodes at any given depth) in a 
+ : sequence of nodes provided as input.</p>
+ : <p>If more then one answer is possible, return the first node according to the order of the input sequence.</p>
+ : <p/>
+ : 
+ : <p>Example usage : <code>most-nodes( ( &lt;a&gt;&lt;b/&gt;&lt;/a&gt;, &lt;a/&gt;, &lt;b/&gt;) )</code></p>
+ : <p/>
+ : <p>The function invocation in the example above returns : <code>(&lt;a&gt;&lt;b/&gt;&lt;/a&gt;)</code></p>
  :
  : @param $s A sequence of nodes.
  : @return The node having the largest number of descending nodes in the input sequence.
@@ -282,14 +282,14 @@
 };
 
 (:~
- : Returns the single node having the smallest number of descending elements (sub-elements at any given depth) 
- : in a sequence of nodes provided as input.
- : If more then one answer is possible, return the first node according to the order of the input sequence.
- :
- : <br/>
- : Example usage : <code>least-elements( ( &lt;a&gt;&lt;b/&gt;&lt;/a&gt;, &lt;b&gt;&lt;c/&gt;&lt;/b&gt;, &lt;d/&gt;) )</code>
- : <br/>
- : The function invocation in the example above returns : <code>(&lt;d/&gt;)</code>
+ : <p>Returns the single node having the smallest number of descending elements (sub-elements at any given depth) 
+ : in a sequence of nodes provided as input.</p>
+ : <p>If more then one answer is possible, return the first node according to the order of the input sequence.</p>
+ : <p/>
+ : 
+ : <p>Example usage : <code>least-elements( ( &lt;a&gt;&lt;b/&gt;&lt;/a&gt;, &lt;b&gt;&lt;c/&gt;&lt;/b&gt;, &lt;d/&gt;) )</code></p>
+ : <p/>
+ : <p>The function invocation in the example above returns : <code>(&lt;d/&gt;)</code></p>
  :
  : @param $s A sequence of nodes.
  : @return The node having the smallest number of descending elements in the input sequence.
@@ -300,14 +300,14 @@
 };
 
 (:~
- : Returns the single node having the smallest number of descending attributes (attributes at any given depth) 
- : in a sequence of nodes provided as input.
- : If more then one answer is possible, return the first node according to the order of the input sequence.
- :
- : <br/>
- : Example usage : <code>least-attributes( ( &lt;a att1="a1" att2="a2"/&gt;, &lt;b att1="a1" /&gt;, &lt;c/&gt; ) )</code>
- : <br/>
- : The function invocation in the example above returns : <code>(&lt;c/&gt;)</code>
+ : <p>Returns the single node having the smallest number of descending attributes (attributes at any given depth) 
+ : in a sequence of nodes provided as input.</p>
+ : <p>If more then one answer is possible, return the first node according to the order of the input sequence.</p>                  
+ : <p/>
+ : 
+ : <p>Example usage : <code>least-attributes( ( &lt;a att1="a1" att2="a2"/&gt;, &lt;b att1="a1" /&gt;, &lt;c/&gt; ) )</code></p>
+ : <p/>
+ : <p>The function invocation in the example above returns : <code>(&lt;c/&gt;)</code></p>
  :
  : @param $s A sequence of nodes.
  : @return The node having the smallest number of descending attributes in the input sequence.
@@ -318,14 +318,14 @@
 };
 
 (:~
- : Returns the single node having the smallest number of descending nodes (sub-nodes at any given depth) 
- : in a sequence of nodes provided as input.
- : If more then one answer is possible, return the first node according to the order of the input sequence.
- :
- : <br/>
- : Example usage : <code>least-nodes( ( &lt;a&gt;&lt;b/&gt;&lt;/a&gt;, &lt;b&gt;&lt;c/&gt;&lt;/b&gt;, &lt;d/&gt;) )</code>
- : <br/>
- : The function invocation in the example above returns : <code>(&lt;d/&gt;)</code>
+ : <p>Returns the single node having the smallest number of descending nodes (sub-nodes at any given depth) 
+ : in a sequence of nodes provided as input.</p>
+ : <p>If more then one answer is possible, return the first node according to the order of the input sequence.</p>
+ : <p/>
+ : 
+ : <p>Example usage : <code>least-nodes( ( &lt;a&gt;&lt;b/&gt;&lt;/a&gt;, &lt;b&gt;&lt;c/&gt;&lt;/b&gt;, &lt;d/&gt;) )</code></p>
+ : <p/>
+ : <p>The function invocation in the example above returns : <code>(&lt;d/&gt;)</code></p>
  :
  : @param $s A sequence of nodes.
  : @return The node having the smallest number of descending nodes in the input sequence.
@@ -336,14 +336,14 @@
 };
 
 (:~
- : Returns the single node having the largest number of distinct descending elements (sub-elements at any 
- : given depth) in a sequence of nodes provided as input.
- : If more then one answer is possible, return the first node according to the order of the input sequence.
- :
- : <br/>
- : Example usage : <code>most-distinct-elements( ( &lt;a&gt;&lt;b/&gt;&lt;c/&gt;&lt;d/&gt;&lt;/a&gt;, &lt;a&gt;&lt;b/&gt;&lt;b/&gt;&lt;c/&gt;&lt;/a&gt;, &lt;a/&gt; ) )</code>
- : <br/>
- : The function invocation in the example above returns : <code>(&lt;a&gt;&lt;b/&gt;&lt;c/&gt;&lt;d/&gt;&lt;/a&gt;)</code>
+ : <p>Returns the single node having the largest number of distinct descending elements (sub-elements at any 
+ : given depth) in a sequence of nodes provided as input.</p>
+ : <p>If more then one answer is possible, return the first node according to the order of the input sequence.</p>
+ : <p/>
+ : 
+ : <p>Example usage : <code>most-distinct-elements( ( &lt;a&gt;&lt;b/&gt;&lt;c/&gt;&lt;d/&gt;&lt;/a&gt;, &lt;a&gt;&lt;b/&gt;&lt;b/&gt;&lt;c/&gt;&lt;/a&gt;, &lt;a/&gt; ) )</code></p>
+ : <p/>
+ : <p>The function invocation in the example above returns : <code>(&lt;a&gt;&lt;b/&gt;&lt;c/&gt;&lt;d/&gt;&lt;/a&gt;)</code></p>
  :
  : @param $s A sequence of nodes.
  : @return The node having the largest number of distinct descending elements in the input sequence.
@@ -354,14 +354,14 @@
 };
 
 (:~
- : Returns the single node having the largest number of distinct descending attributes (attributes at any 
- : given depth) in a sequence of nodes provided as input.
- : If more then one answer is possible, return the first node according to the order of the input sequence.
- :
- : <br/>
- : Example usage : <code>most-distinct-attributes( ( &lt;a att1="a1" att2="a2" att3="a3"/&gt;, &lt;a att1="a1" att2="a2"&gt;&lt;b att2="a2" /&gt;&lt;/a&gt;, &lt;c/&gt; ) )</code>
- : <br/>
- : The function invocation in the example above returns : <code>(&lt;a att1="a1" att2="a2" att3="a3"/&gt;)</code>
+ : <p>Returns the single node having the largest number of distinct descending attributes (attributes at any 
+ : given depth) in a sequence of nodes provided as input.</p>
+ : <p>If more then one answer is possible, return the first node according to the order of the input sequence.</p>
+ : <p/>
+ : 
+ : <p>Example usage : <code>most-distinct-attributes( ( &lt;a att1="a1" att2="a2" att3="a3"/&gt;, &lt;a att1="a1" att2="a2"&gt;&lt;b att2="a2" /&gt;&lt;/a&gt;, &lt;c/&gt; ) )</code></p>
+ : <p/>
+ : <p>The function invocation in the example above returns : <code>(&lt;a att1="a1" att2="a2" att3="a3"/&gt;)</code></p>
  :
  : @param $s A sequence of nodes.
  : @return The node having the largest number of distinct descending attributes in the input sequence.
@@ -372,14 +372,14 @@
 };
 
 (:~
- : Returns the single node having the largest number of distinct descending nodes (sub-nodes at any given depth) in 
- : a sequence of nodes provided as input.
- : If more then one answer is possible, return the first node according to the order of the input sequence.
- :
- : <br/>
- : Example usage : <code>most-distinct-nodes( ( &lt;a>&lt;b/>&lt;/a&gt;, &lt;a>&lt;a/&gt;&lt;/a&gt;, &lt;b/&gt;) )</code>
- : <br/>
- : The function invocation in the example above returns : <code>(&lt;a&gt;&lt;b/&gt;&lt;/a&gt;)</code>
+ : <p>Returns the single node having the largest number of distinct descending nodes (sub-nodes at any given depth) in 
+ : a sequence of nodes provided as input.</p>
+ : <p>If more then one answer is possible, return the first node according to the order of the input sequence.</p>
+ : <p/>
+ : 
+ : <p>Example usage : <code>most-distinct-nodes( ( &lt;a>&lt;b/>&lt;/a&gt;, &lt;a>&lt;a/&gt;&lt;/a&gt;, &lt;b/&gt;) )</code></p>
+ : <p/>
+ : <p>The function invocation in the example above returns : <code>(&lt;a&gt;&lt;b/&gt;&lt;/a&gt;)</code></p>
  :
  : @param $s A sequence of nodes.
  : @return The node having the largest number of distinct descending nodes in the input sequence.
@@ -390,14 +390,14 @@
 };
 
 (:~
- : Returns the single node having the smallest number of distinct descending elements (sub-elements at any 
- : given depth) in a sequence of nodes provided as input.
- : If more then one answer is possible, return the first node according to the order of the input sequence.
- :
- : <br/>
- : Example usage : <code> least-distinct-elements( ( &lt;a>&lt;b/&gt;&lt;/a&gt;, &lt;b&gt;&lt;c/&gt;&lt;/b&gt;, &lt;d/&gt;) ) </code>
- : <br/>
- : The function invocation in the example above returns : <code> (&lt;d/&gt;) </code>
+ : <p>Returns the single node having the smallest number of distinct descending elements (sub-elements at any 
+ : given depth) in a sequence of nodes provided as input.</p>
+ : <p>If more then one answer is possible, return the first node according to the order of the input sequence.</p>
+ : <p/>
+ : 
+ : <p>Example usage : <code> least-distinct-elements( ( &lt;a>&lt;b/&gt;&lt;/a&gt;, &lt;b&gt;&lt;c/&gt;&lt;/b&gt;, &lt;d/&gt;) ) </code></p>
+ : <p/>
+ : <p>The function invocation in the example above returns : <code> (&lt;d/&gt;) </code></p>
  :
  : @param $s A sequence of nodes.
  : @return The node having the smallest number of distinct descending elements in the input sequence.
@@ -408,14 +408,14 @@
 };
 
 (:~
- : Returns the single node having the smallest number of distinct descending attributes (attributes at any 
- : given depth) in a sequence of nodes provided as input.
- : If more then one answer is possible, return the first node according to the order of the input sequence.
- :
- : <br/>
- : Example usage : <code> least-distinct-attributes( ( &lt;a att1="a1" att2="a2"/&gt;, &lt;b att1="a1" /&gt;, &lt;c/&gt; ) ) </code>
- : <br/>
- : The function invocation in the example above returns : <code> (&lt;c/&gt;) </code>
+ : <p>Returns the single node having the smallest number of distinct descending attributes (attributes at any 
+ : given depth) in a sequence of nodes provided as input.</p>
+ : <p>If more then one answer is possible, return the first node according to the order of the input sequence.</p>
+ : <p/>
+ : 
+ : <p>Example usage : <code> least-distinct-attributes( ( &lt;a att1="a1" att2="a2"/&gt;, &lt;b att1="a1" /&gt;, &lt;c/&gt; ) ) </code></p>
+ : <p/>
+ : <p>The function invocation in the example above returns : <code> (&lt;c/&gt;) </code></p>
  :
  : @param $s A sequence of nodes.
  : @return The node having the smallest number of distinct descending attributes in the input sequence.
@@ -426,14 +426,14 @@
 };
 
 (:~
- : Returns the single node having the smallest number of distinct descending nodes (sub-nodes at any given depth) 
- : in a sequence of nodes provided as input.
- : If more then one answer is possible, return the first node according to the order of the input sequence.
- :
- : <br/>
- : Example usage : <code> least-distinct-nodes( ( &lt;a&gt;&lt;b/&gt;&lt;/a&gt;, &lt;b&gt;&lt;c/&gt;&lt;/b&gt;, &lt;d/&gt;) ) </code>
- : <br/>
- : The function invocation in the example above returns : <code> (&lt;d/&gt;) </code>
+ : <p>Returns the single node having the smallest number of distinct descending nodes (sub-nodes at any given depth) 
+ : in a sequence of nodes provided as input.</p>                                                                      
+ : <p>If more then one answer is possible, return the first node according to the order of the input sequence.</p>
+ : <p/>
+ : 
+ : <p>Example usage : <code> least-distinct-nodes( ( &lt;a&gt;&lt;b/&gt;&lt;/a&gt;, &lt;b&gt;&lt;c/&gt;&lt;/b&gt;, &lt;d/&gt;) ) </code></p>
+ : <p/>
+ : <p>The function invocation in the example above returns : <code> (&lt;d/&gt;) </code></p>
  :
  : @param $s A sequence of nodes.
  : @return The node having the smallest number of distinct descending nodes in the input sequence.
@@ -444,13 +444,13 @@
 };
 
 (:~
- : Returns the elements from an input sequence of elements that, when matched to a given set of XPath expressions,
- : produce a non-empty set of nodes in all the cases.
- :
- : <br/>
- : Example usage : <code> all-xpaths( ( &lt;a&gt;&lt;b/&gt;&lt;/a&gt;, &lt;c&gt;&lt;d/&gt;&lt;/c&gt;, &lt;d/&gt;), (".//b") ) </code>
- : <br/>
- : The function invocation in the example above returns : <code> (&lt;a&gt;&lt;b/&gt;&lt;/a&gt;) </code>
+ : <p>Returns the elements from an input sequence of elements that, when matched to a given set of XPath expressions,
+ : produce a non-empty set of nodes in all the cases.</p>
+ : <p/>
+ : 
+ : <p>Example usage : <code> all-xpaths( ( &lt;a&gt;&lt;b/&gt;&lt;/a&gt;, &lt;c&gt;&lt;d/&gt;&lt;/c&gt;, &lt;d/&gt;), (".//b") ) </code></p>
+ : <p/>
+ : <p>The function invocation in the example above returns : <code> (&lt;a&gt;&lt;b/&gt;&lt;/a&gt;) </code></p>
  :
  : @param $s A sequence of elements.
  : @param $paths A sequence of strings denoting XPath expressions.
@@ -470,13 +470,13 @@
 };
 
 (:~
- : Returns the elements from a sequence of elements that, when matched to a given set of XPath expressions,
- : produce a non-empty set of nodes for some of the cases.
- :
- : <br/>
- : Example usage : <code> some-xpaths( ( &lt;a&gt;&lt;b/&gt;&lt;/a&gt;, &lt;d&gt;&lt;c/&gt;&lt;/d&gt;, &lt;d/&gt;), (".//b", ".//c") ) </code>
- : <br/>
- : The function invocation in the example above returns : <code> ( &lt;a&gt;&lt;b/&gt;&lt;/a&gt; , &lt;d&gt;&lt;c/&gt;&lt;/d&gt; ) </code>
+ : <p>Returns the elements from a sequence of elements that, when matched to a given set of XPath expressions,
+ : produce a non-empty set of nodes for some of the cases.</p>
+ : <p/>
+ : 
+ : <p>Example usage : <code> some-xpaths( ( &lt;a&gt;&lt;b/&gt;&lt;/a&gt;, &lt;d&gt;&lt;c/&gt;&lt;/d&gt;, &lt;d/&gt;), (".//b", ".//c") ) </code></p>
+ : <p/>
+ : <p>The function invocation in the example above returns : <code> ( &lt;a&gt;&lt;b/&gt;&lt;/a&gt; , &lt;d&gt;&lt;c/&gt;&lt;/d&gt; ) </code></p>
  :
  : @param $s A sequence of elements.
  : @param $paths A sequence of strings denoting XPath expressions.
@@ -497,14 +497,14 @@
 };
 
 (:~
- : Returns the single element from an input sequence of elements that matches the largest number of 
- : XPath expressions from a given set, producing a non-empty set of nodes.
- : If more then one answer is possible, return the first element according to the order of the input sequence.
- :
- : <br/>
- : Example usage : <code> most-xpaths( ( &lt;a&gt;&lt;b/&gt;&lt;/a&gt;, &lt;d&gt;&lt;c/&gt;&lt;b/&gt;&lt;/d&gt;, &lt;d/&gt;) , (".//b", ".//c") ) </code>
- : <br/>
- : The function invocation in the example above returns : <code> ( &lt;d&gt;&lt;c/&gt;&lt;b/&gt;&lt;/d&gt; ) </code>
+ : <p>Returns the single element from an input sequence of elements that matches the largest number of 
+ : XPath expressions from a given set, producing a non-empty set of nodes.</p>
+ : <p>If more then one answer is possible, return the first element according to the order of the input sequence.</p>
+ : <p/>
+ : 
+ : <p>Example usage : <code> most-xpaths( ( &lt;a&gt;&lt;b/&gt;&lt;/a&gt;, &lt;d&gt;&lt;c/&gt;&lt;b/&gt;&lt;/d&gt;, &lt;d/&gt;) , (".//b", ".//c") ) </code></p>
+ : <p/>
+ : <p>The function invocation in the example above returns : <code> ( &lt;d&gt;&lt;c/&gt;&lt;b/&gt;&lt;/d&gt; ) </code></p>
  :
  : @param $s A sequence of elements.
  : @param $paths A sequence of strings denoting XPath expressions.
@@ -524,18 +524,18 @@
   return $str
  )[1]
  :)
- ""
+ ""                                                                
 };
 
 (:~
- : Returns the single element from an input sequence of elements that matches the smallest number of 
- : XPath expressions from a given set, producing a non-empty set of nodes.
- : If more then one answer is possible, return the first element according to the order of the input sequence.
- :
- : <br/>
- : Example usage : <code> least-xpaths( ( &lt;a&gt;&lt;b/&gt;&lt;/a&gt;, &lt;d&gt;&lt;c/&gt;&lt;b/&gt;&lt;/d&gt;, &lt;d/&gt;) , (".//b", ".//c") ) </code>
- : <br/>
- : The function invocation in the example above returns : <code> ( $lt;d/&gt; ) </code>
+ : <p>Returns the single element from an input sequence of elements that matches the smallest number of 
+ : XPath expressions from a given set, producing a non-empty set of nodes.</p>
+ : <p>If more then one answer is possible, return the first element according to the order of the input sequence.</p>
+ : <p/>
+ : 
+ : <p>Example usage : <code> least-xpaths( ( &lt;a&gt;&lt;b/&gt;&lt;/a&gt;, &lt;d&gt;&lt;c/&gt;&lt;b/&gt;&lt;/d&gt;, &lt;d/&gt;) , (".//b", ".//c") ) </code></p>
+ : <p/>
+ : <p>The function invocation in the example above returns : <code> ( $lt;d/&gt; ) </code></p>
  :
  : @param $s A sequence of elements.
  : @param $paths A sequence of strings denoting XPath expressions.
@@ -559,18 +559,18 @@
 };
 
 (:~
- : Returns the nodes from an input sequence of nodes that validate against a given XML Schema.
- :
- : <br/>
- : Example usage : <code> validating-schema ( ( &lt;a/&gt; , &lt;b/&gt; ), &lt;xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"&gt;&lt;xs:element name="a" /&gt;&lt;/xs:schema&gt; ) </code>
- : <br/>
- : The function invocation in the example above returns : <code> ( &lt;a/&gt; ) </code>
+ : <p>Returns the nodes from an input sequence of nodes that validate against a given XML Schema.</p>
+ : <p/>
+ : 
+ : <p>Example usage : <code> validating-schema ( ( &lt;a/&gt; , &lt;b/&gt; ), &lt;xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"&gt;&lt;xs:element name="a" /&gt;&lt;/xs:schema&gt; ) </code></p>
+ : <p/>
+ : <p>The function invocation in the example above returns : <code> ( &lt;a/&gt; ) </code></p>
  :
  : @param $s A sequence of elements.
  : @param $schema An element encoding an XML Schema.
  : @return The nodes that validate against the XML Schema.
  :
- : <br/><br/><b> Attention : This function is still not implemented. </b> <br/>
+ : <b> Attention : This function is still not implemented. </b> 
  :
  :)
 declare function con:validating-schema ( $s as element()*, $schema as element() ) as element()*{

=== renamed file 'src/com/zorba-xquery/www/modules/data-cleaning/conversion.xq' => 'src/conversion.xq'
--- src/com/zorba-xquery/www/modules/data-cleaning/conversion.xq	2012-09-28 13:34:20 +0000
+++ src/conversion.xq	2013-07-10 00:51:26 +0000
@@ -17,16 +17,16 @@
  :)
 
 (:~
- : This library module provides data conversion functions for processing calendar dates, 
- : temporal values, currency values, units of measurement, location names and postal addresses.
- :
- : The logic contained in this module is not specific to any particular XQuery implementation.
+ : <p>This library module provides data conversion functions for processing calendar dates, 
+ : temporal values, currency values, units of measurement, location names and postal addresses.</p>
+ : <p/>
+ : <p>The logic contained in this module is not specific to any particular XQuery implementation.</p>
  :
  : @author Bruno Martins and Diogo Simões
  : @project Zorba/Data Cleaning/Conversion
  :)
 
-module namespace conversion = "http://www.zorba-xquery.com/modules/data-cleaning/conversion";
+module namespace conversion = "http://zorba.io/modules/data-cleaning/conversion";
 
 declare namespace exref = "http://www.ecb.int/vocabulary/2002-08-01/eurofxref";
 declare namespace an = "http://www.zorba-xquery.com/annotations";
@@ -40,12 +40,12 @@
 declare namespace ver = "http://www.zorba-xquery.com/options/versioning";
 declare option ver:module-version "2.0";
 
-(:~ The key to be used when accessing the White Pages Web service :)
+(:~ <p>The key to be used when accessing the White Pages Web service</p> :)
 declare variable $conversion:key := "06ea2f21cc15602b6a3e242e3225a81a";
 
 (:~
- : Uses a White-pages Web service to discover information about a given name, 
- : returning a sequence of strings for the phone numbers associated to the name.
+ : <p>Uses a White-pages Web service to discover information about a given name, 
+ : returning a sequence of strings for the phone numbers associated to the name.</p>
  :
  :
  : @param $name The name of person or organization.
@@ -61,8 +61,8 @@
 };
 
 (:~
- : Uses a White-pages Web service to discover information about a given name, 
- : returning a sequence of strings for the addresses associated to the name.
+ : <p>Uses a White-pages Web service to discover information about a given name, 
+ : returning a sequence of strings for the addresses associated to the name.</p>
  :
  :
  : @param $name The name of person or organization.
@@ -83,8 +83,8 @@
 
 
 (:~
- : Uses a White-pages Web service to discover information about a given phone number, 
- : returning a sequence of strings for the name associated to the phone number.
+ : <p>Uses a White-pages Web service to discover information about a given phone number, 
+ : returning a sequence of strings for the name associated to the phone number.</p>
  :
  :
  : @param $phone-number A string with 10 digits corresponding to the phone number.
@@ -98,8 +98,8 @@
 };
 
 (:~
- : Uses a White-pages Web service to discover information about a given phone number, 
- : returning a string for the address associated to the phone number.
+ : <p>Uses a White-pages Web service to discover information about a given phone number, 
+ : returning a string for the address associated to the phone number.</p>
  :
  :
  : @param $phone-number A string with 10 digits corresponding to the phone number.
@@ -120,8 +120,8 @@
 };
 
 (:~
- : Uses a White-pages Web service to discover information about a given address, 
- : returning a sequence of strings for the names associated to the address.
+ : <p>Uses a White-pages Web service to discover information about a given address, 
+ : returning a sequence of strings for the names associated to the address.</p>
  :
  :
  : @param $address A string corresponding to the address (ex: 5655 E Gaskill Rd, Willcox, AZ, US).
@@ -146,8 +146,8 @@
 };
 
 (:~
- : Uses a White-pages Web service to discover information about a given address, 
- : returning a sequence of strings for the phone number associated to the address.
+ : <p>Uses a White-pages Web service to discover information about a given address, 
+ : returning a sequence of strings for the phone number associated to the address.</p>
  :
  :
  : @param $address A string corresponding to the address (ex: 5655 E Gaskill Rd, Willcox, AZ, US).
@@ -180,8 +180,8 @@
 };
 
 (:~
- : Conversion function for units of measurement, acting as a wrapper over the CuppaIT WebService.
- : <br/>
+ : <p>Conversion function for units of measurement, acting as a wrapper over the CuppaIT WebService.</p>
+ : 
  :
  :
  : @param $v The amount we wish to convert.
@@ -296,7 +296,7 @@
 };
 
 (:~
- : Placename to geospatial coordinates converter, acting as a wrapper over the Yahoo! geocoder service.
+ : <p>Placename to geospatial coordinates converter, acting as a wrapper over the Yahoo! geocoder service.</p>
  :
  : 
  : @param $q A sequence of strings corresponding to the different components (e.g., street, city, country, etc.) of the place name.
@@ -313,7 +313,7 @@
 };
 
 (:~
- : Geospatial coordinates to placename converter, acting as a wrapper over the Yahoo! reverse geocoder service.
+ : <p>Geospatial coordinates to placename converter, acting as a wrapper over the Yahoo! reverse geocoder service.</p>
  :
  :
  : @param $lat Geospatial latitude.
@@ -337,9 +337,9 @@
 };
 
 (:~
- : Currency conversion function, acting as a wrapper over the WebService from the European Central Bank.
- :
- : WebService documentation at http://www.ecb.int/stats/exchange/eurofxref/html/index.en.html
+ : <p>Currency conversion function, acting as a wrapper over the WebService from the European Central Bank.</p>
+ : <p/>
+ : <p>WebService documentation at <a src="http://www.ecb.int/stats/exchange/eurofxref/html/index.en.html">http://www.ecb.int/stats/exchange/eurofxref/html/index.en.html</a></p>
  :
  :
  : @param $v The amount we wish to convert.
@@ -347,7 +347,7 @@
  : @param $m2 The target currency (e.g., "USD").
  : @param $date The reference date.
  : @return The value resulting from the conversion.
- : @error conversion:notsupported if the date, the source currency type or the target currency type are not known to the service.
+ : @error conversion:NOTSUPPORTED if the date, the source currency type or the target currency type are not known to the service.
  : @see http://www.ecb.int/stats/exchange/eurofxref/html/index.en.html
  : @example test/Queries/data-cleaning/conversion/currency-convert.xq
  :)
@@ -361,17 +361,17 @@
  let $fromEUR := if ( $m2="EUR" ) then (xs:double(1.0)) else ( $doc//exref:Cube[xs:string(@currency)=$m2]/xs:double(@rate) )
  let $result  := ($v div $toEUR) * $fromEUR
  return if (matches(string($result),"-?[0-9]+(\.[0-9]+)?")) then ($result) 
-        else (error(QName('http://www.zorba-xquery.com/modules/data-cleaning/conversion', 'conversion:notsupported'), data($result)))
+        else (error(QName('http://zorba.io/modules/data-cleaning/conversion', 'conversion:NOTSUPPORTED'), data($result)))
 };
 
 (:~
- : Uses a whois service to discover information about a given domain name, returning a sequence of strings 
- : for the phone numbers associated to the name.
+ : <p>Uses a whois service to discover information about a given domain name, returning a sequence of strings 
+ : for the phone numbers associated to the name.</p>
  :
  : @param $addr A string with the domain.
  : @return A sequence of strings for the phone numbers associated to the domain name.
  :
- : <br/><br/><b> Attention : This function is still not implemented. </b> <br/>
+ : <p><b> Attention : This function is still not implemented. </b></p> 
  :
  :)
 declare function conversion:phone-from-domain ( $domain as xs:string ) as xs:string*{
@@ -379,13 +379,13 @@
 };
 
 (:~
- : Uses a whois service to discover information about a given domain name, returning a sequence of strings 
- : for the addresses associated to the name.
+ : <p>Uses a whois service to discover information about a given domain name, returning a sequence of strings 
+ : for the addresses associated to the name.</p>
  :
  : @param $addr A string with the domain.
  : @return A sequence of strings for the addresses associated to the domain name.
  :
- : <br/><br/><b> Attention : This function is still not implemented. </b> <br/>
+ : <p><b> Attention : This function is still not implemented. </b></p> 
  :
  :)
 declare function conversion:address-from-domain ( $domain as xs:string ) as xs:string*{
@@ -393,13 +393,13 @@
 };
 
 (:~
- : Uses a whois service to discover information about a given domain name, returning a sequence of strings 
- : for the person or organization names associated to the name.
+ : <p>Uses a whois service to discover information about a given domain name, returning a sequence of strings 
+ : for the person or organization names associated to the name.</p>
  :
  : @param $addr A string with the domain.
  : @return A sequence of strings for the person or organization names associated to the domain name.
  :
- : <br/><br/><b> Attention : This function is still not implemented. </b> <br/>
+ : <p><b> Attention : This function is still not implemented. </b></p> 
  :
  :)
 declare function conversion:name-from-domain ( $domain as xs:string ) as xs:string*{

=== renamed file 'src/com/zorba-xquery/www/modules/data-cleaning/hybrid-string-similarity.xq' => 'src/hybrid-string-similarity.xq'
--- src/com/zorba-xquery/www/modules/data-cleaning/hybrid-string-similarity.xq	2012-09-28 13:34:20 +0000
+++ src/hybrid-string-similarity.xq	2013-07-10 00:51:26 +0000
@@ -17,43 +17,43 @@
  :)
 
 (:~
- : This library module provides hybrid string similarity functions, combining the properties of 
- : character-based string similarity functions and token-based string similarity functions.
- : 
- : The logic contained in this module is not specific to any particular XQuery implementation,
+ : <p>This library module provides hybrid string similarity functions, combining the properties of 
+ : character-based string similarity functions and token-based string similarity functions.</p>
+ : <p/>
+ : <p>The logic contained in this module is not specific to any particular XQuery implementation,
  : although the module requires the trigonometic functions of XQuery 3.0 or a math extension 
- : function such as sqrt($x as numeric) for computing the square root.
+ : function such as sqrt($x as numeric) for computing the square root.</p>
  :
  : @author Bruno Martins and Diogo Simões
  : @project Zorba/Data Cleaning/Hybrid String Similarity
  :)
 
-module namespace simh = "http://www.zorba-xquery.com/modules/data-cleaning/hybrid-string-similarity";
+module namespace simh = "http://zorba.io/modules/data-cleaning/hybrid-string-similarity";
 
-(: In the QizX os Saxon XQuery engines, it is possible to call external functions from the Java math library :)
-(: declare namespace math = "java:java.lang.Math"; :)
+(: <p>In the QizX os Saxon XQuery engines, it is possible to call external functions from the Java math library :)
+(: declare namespace math = "java:java.lang.Math";</p> :)
 declare namespace math = "http://www.w3.org/2005/xpath-functions/math";
 
-import module namespace set  = "http://www.zorba-xquery.com/modules/data-cleaning/set-similarity";
-import module namespace simt = "http://www.zorba-xquery.com/modules/data-cleaning/token-based-string-similarity";
-import module namespace simc = "http://www.zorba-xquery.com/modules/data-cleaning/character-based-string-similarity";
-import module namespace simp = "http://www.zorba-xquery.com/modules/data-cleaning/phonetic-string-similarity";
+import module namespace set  = "http://zorba.io/modules/data-cleaning/set-similarity";
+import module namespace simt = "http://zorba.io/modules/data-cleaning/token-based-string-similarity";
+import module namespace simc = "http://zorba.io/modules/data-cleaning/character-based-string-similarity";
+import module namespace simp = "http://zorba.io/modules/data-cleaning/phonetic-string-similarity";
 
 declare namespace ver = "http://www.zorba-xquery.com/options/versioning";
 declare option ver:module-version "2.0";
 
 (:~
- : Returns the cosine similarity coefficient between sets of tokens extracted from two strings.
- :
- : The tokens from each string are weighted according to their occurence frequency (i.e., weighted according to the
- : term-frequency heuristic from Information Retrieval).
- : The Soundex phonetic similarity function is used to discover token identity, which is equivalent to saying that
- : this function returns the cosine similarity coefficient between sets of Soundex keys.
- :
- : <br/>
- : Example usage : <code> soft-cosine-tokens-soundex("ALEKSANDER SMITH", "ALEXANDER SMYTH", " +") </code>
- : <br/>
- : The function invocation in the example above returns : <code> 1.0 </code>
+ : <p>Returns the cosine similarity coefficient between sets of tokens extracted from two strings.</p>
+ : <p/>
+ : <p>The tokens from each string are weighted according to their occurence frequency (i.e., weighted according to the
+ : term-frequency heuristic from Information Retrieval).</p>
+ : <p>The Soundex phonetic similarity function is used to discover token identity, which is equivalent to saying that
+ : this function returns the cosine similarity coefficient between sets of Soundex keys.</p>
+ : <p/>
+ : 
+ : <p>Example usage : <code> soft-cosine-tokens-soundex("ALEKSANDER SMITH", "ALEXANDER SMYTH", " +") </code></p>
+ : <p/>
+ : <p>The function invocation in the example above returns : <code> 1.0 </code></p>
  :
  : @param $s1 The first string.
  : @param $s2 The second string.
@@ -68,16 +68,16 @@
 };
 
 (:~
- : Returns the cosine similarity coefficient between sets of tokens extracted from two strings. 
- : The tokens from each string are weighted according to their occurence frequency (i.e., weighted according to the
- : term-frequency heuristic from Information Retrieval).
- : The Metaphone phonetic similarity function is used to discover token identity, which is equivalent to saying that
- : this function returns the cosine similarity coefficient between sets of Metaphone keys.
- :
- : <br/>
- : Example usage : <code> soft-cosine-tokens-metaphone("ALEKSANDER SMITH", "ALEXANDER SMYTH", " +" ) </code>
- : <br/>
- : The function invocation in the example above returns : <code> 1.0 </code>
+ : <p>Returns the cosine similarity coefficient between sets of tokens extracted from two strings.</p> 
+ : <p>The tokens from each string are weighted according to their occurence frequency (i.e., weighted according to the
+ : term-frequency heuristic from Information Retrieval).</p>
+ : <p>The Metaphone phonetic similarity function is used to discover token identity, which is equivalent to saying that
+ : this function returns the cosine similarity coefficient between sets of Metaphone keys.</p>
+ : <p/>
+ : 
+ : <p>Example usage : <code> soft-cosine-tokens-metaphone("ALEKSANDER SMITH", "ALEXANDER SMYTH", " +" ) </code></p>
+ : <p/>
+ : <p>The function invocation in the example above returns : <code> 1.0 </code></p>
  :
  : @param $s1 The first string.
  : @param $s2 The second string.
@@ -92,16 +92,16 @@
 };
 
 (:~
- : Returns the cosine similarity coefficient between sets of tokens extracted from two strings. 
- : The tokens from each string are weighted according to their occurence frequency (i.e., weighted according to the
- : term-frequency heuristic from Information Retrieval).
- : The Edit Distance similarity function is used to discover token identity, and tokens having an edit distance 
- : bellow a given threshold are considered as matching tokens.
- :
- : <br/>
- : Example usage : <code> soft-cosine-tokens-edit-distance("The FLWOR Foundation", "FLWOR Found.", " +", 0 ) </code>
- : <br/>
- : The function invocation in the example above returns : <code> 0.408248290463863 </code>
+ : <p>Returns the cosine similarity coefficient between sets of tokens extracted from two strings.</p> 
+ : <p>The tokens from each string are weighted according to their occurence frequency (i.e., weighted according to the
+ : term-frequency heuristic from Information Retrieval).</p>
+ : <p>The Edit Distance similarity function is used to discover token identity, and tokens having an edit distance 
+ : bellow a given threshold are considered as matching tokens.</p>
+ : <p/>
+ : 
+ : <p>Example usage : <code> soft-cosine-tokens-edit-distance("The FLWOR Foundation", "FLWOR Found.", " +", 0 ) </code></p>
+ : <p/>
+ : <p>The function invocation in the example above returns : <code> 0.408248290463863 </code></p>
  :
  : @param $s1 The first string.
  : @param $s2 The second string.
@@ -128,16 +128,16 @@
 };
 
 (:~
- : Returns the cosine similarity coefficient between sets of tokens extracted from two strings. 
- : The tokens from each string are weighted according to their occurence frequency (i.e., weighted according to the
- : term-frequency heuristic from Information Retrieval).
- : The Jaro similarity function is used to discover token identity, and tokens having a Jaro similarity above
- : a given threshold are considered as matching tokens.
- :
- : <br/>
- : Example usage : <code> soft-cosine-tokens-jaro("The FLWOR Foundation", "FLWOR Found.", " +", 1 ) </code>
- : <br/>
- : The function invocation in the example above returns : <code> 0.5 </code>
+ : <p>Returns the cosine similarity coefficient between sets of tokens extracted from two strings.</p> 
+ : <p>The tokens from each string are weighted according to their occurence frequency (i.e., weighted according to the
+ : term-frequency heuristic from Information Retrieval).</p>
+ : <p>The Jaro similarity function is used to discover token identity, and tokens having a Jaro similarity above
+ : a given threshold are considered as matching tokens.</p>
+ : <p/>
+ : 
+ : <p>Example usage : <code> soft-cosine-tokens-jaro("The FLWOR Foundation", "FLWOR Found.", " +", 1 ) </code></p>
+ : <p/>
+ : <p>The function invocation in the example above returns : <code> 0.5 </code></p>
  :
  : @param $s1 The first string.
  : @param $s2 The second string.
@@ -162,16 +162,16 @@
 };
 
 (:~
- : Returns the cosine similarity coefficient between sets of tokens extracted from two strings. 
- : The tokens from each string are weighted according to their occurence frequency (i.e., weighted according to the
- : term-frequency heuristic from Information Retrieval).
- : The Jaro-Winkler similarity function is used to discover token identity, and tokens having a Jaro-Winkler
- : similarity above a given threshold are considered as matching tokens.
- :
- : <br/>
- : Example usage : <code> soft-cosine-tokens-jaro-winkler("The FLWOR Foundation", "FLWOR Found.", " +", 1, 4, 0.1 ) </code>
- : <br/>
- : The function invocation in the example above returns : <code> 0.45 </code>
+ : <p>Returns the cosine similarity coefficient between sets of tokens extracted from two strings.</p> 
+ : <p>The tokens from each string are weighted according to their occurence frequency (i.e., weighted according to the
+ : term-frequency heuristic from Information Retrieval).</p>
+ : <p>The Jaro-Winkler similarity function is used to discover token identity, and tokens having a Jaro-Winkler
+ : similarity above a given threshold are considered as matching tokens.</p>
+ : <p/>
+ : 
+ : <p>Example usage : <code> soft-cosine-tokens-jaro-winkler("The FLWOR Foundation", "FLWOR Found.", " +", 1, 4, 0.1 ) </code></p>
+ : <p/>
+ : <p>The function invocation in the example above returns : <code> 0.45 </code></p>
  :
  : @param $s1 The first string.
  : @param $s2 The second string.
@@ -198,13 +198,13 @@
 };
 
 (:~
- : Returns the Monge-Elkan similarity coefficient between two strings, using the Jaro-Winkler 
- : similarity function to discover token identity.
- :
- : <br/>
- : Example usage : <code> monge-elkan-jaro-winkler("Comput. Sci. and Eng. Dept., University of California, San Diego", "Department of Computer Scinece, Univ. Calif., San Diego", 4, 0.1) </code>
- : <br/>
- : The function invocation in the example above returns : <code> 0.992 </code>
+ : <p>Returns the Monge-Elkan similarity coefficient between two strings, using the Jaro-Winkler</p> 
+ : <p>similarity function to discover token identity.</p>
+ : <p/>
+ : 
+ : <p>Example usage : <code> monge-elkan-jaro-winkler("Comput. Sci. and Eng. Dept., University of California, San Diego", "Department of Computer Scinece, Univ. Calif., San Diego", 4, 0.1) </code></p>
+ : <p/>
+ : <p>The function invocation in the example above returns : <code> 0.992 </code></p>
  :
  : @param $s1 The first string.
  : @param $s2 The second string.

=== renamed file 'src/com/zorba-xquery/www/modules/data-cleaning/normalization.xq' => 'src/normalization.xq'
--- src/com/zorba-xquery/www/modules/data-cleaning/normalization.xq	2012-09-28 13:34:20 +0000
+++ src/normalization.xq	2013-07-10 00:51:26 +0000
@@ -17,18 +17,17 @@
  :)
 
 (:~
- : This library module provides data normalization functions for processing calendar dates, 
+ : <p>This library module provides data normalization functions for processing calendar dates, 
  : temporal values, currency values, units of measurement, location names and postal addresses.
- :
- : These functions are particularly useful for converting different data representations into cannonical formats.
- :
- : The logic contained in this module is not specific to any particular XQuery implementation.
+ : These functions are particularly useful for converting different data representations into cannonical formats.</p>
+ :
+ : <p>The logic contained in this module is not specific to any particular XQuery implementation.</p>
  :
  : @author Bruno Martins and Diogo Simões
  : @project Zorba/Data Cleaning/Normalization
  :)
 
-module namespace normalization = "http://www.zorba-xquery.com/modules/data-cleaning/normalization";
+module namespace normalization = "http://zorba.io/modules/data-cleaning/normalization";
 
 import module namespace http = "http://www.zorba-xquery.com/modules/http-client";
 
@@ -37,8 +36,8 @@
 declare option ver:module-version "2.0";
 
 (:~
- : Converts a given string representation of a date value into a date representation valid according 
- : to the corresponding XML Schema type.
+ : <p>Converts a given string representation of a date value into a date representation valid according 
+ : to the corresponding XML Schema type.</p>
  :
  :
  : @param $sd The string representation for the date
@@ -47,18 +46,18 @@
  : by a single letter or 'O' or 'E' and then a single letter. Any character in the format string that is not part of a conversion 
  : specification is interpreted literally, and the string '%%' gives '%'. The supported conversion specifications are as follows:
  : <pre>
- : '%b' Abbreviated month name in the current locale.<br/>
- : '%B' Full month name in the current locale.<br/>
- : '%d' Day of the month as decimal number (01-31).<br/>
- : '%m' Month as decimal number (01-12).<br/>
- : '%x' Date, locale-specific.<br/>
- : '%y' Year without century (00-99).<br/>
- : '%Y' Year with century.<br/>
- : '%C' Century (00-99): the integer part of the year divided by 100.<br/>
- : '%D' Locale-specific date format such as '%m/%d/%y'.<br/>
- : '%e' Day of the month as decimal number (1-31), with a leading pace for a single-digit number.<br/>
- : '%F' Equivalent to %Y-%m-%d (the ISO 8601 date format).<br/>
- : '%h' Equivalent to '%b'.<br/> 
+ : '%b' Abbreviated month name in the current locale.
+ : '%B' Full month name in the current locale.
+ : '%d' Day of the month as decimal number (01-31).
+ : '%m' Month as decimal number (01-12).
+ : '%x' Date, locale-specific.
+ : '%y' Year without century (00-99).
+ : '%Y' Year with century.
+ : '%C' Century (00-99): the integer part of the year divided by 100.
+ : '%D' Locale-specific date format such as '%m/%d/%y'.
+ : '%e' Day of the month as decimal number (1-31), with a leading pace for a single-digit number.
+ : '%F' Equivalent to %Y-%m-%d (the ISO 8601 date format).
+ : '%h' Equivalent to '%b'. 
  :</pre>
  :
  : @return The date value resulting from the conversion.
@@ -147,8 +146,8 @@
 };
 
 (:~
- : Converts a given string representation of a time value into a time representation valid according to 
- : the corresponding XML Schema type.
+ : <p>Converts a given string representation of a time value into a time representation valid according to 
+ : the corresponding XML Schema type.</p>
  :
  :
  : @param $sd The string representation for the time.
@@ -156,13 +155,13 @@
  : conversion specifications. In the format string, a conversion specification is introduced by '%', usually followed by a single 
  : letter or 'O' or 'E' and then a single letter. Any character in the format string that is not part of a conversion specification 
  : is interpreted literally, and the string '%%' gives '%'. The supported conversion specifications are as follows:
- :
+ : <p/>
  : <pre class="ace-static">
  : '%H' Hours as decimal number (00-23).
  : '%I' Hours as decimal number (01-12).
  : '%M' Minute as decimal number (00-59).
  : '%p' AM/PM indicator in the locale. Used in conjunction with '%I' and *not* with '%H'.
- : '%S' Second as decimal number (00-61), allowing for up to two leap-seconds.<br/>
+ : '%S' Second as decimal number (00-61), allowing for up to two leap-seconds.
  : '%X' Time, locale-specific.
  : '%z' Offset from Greenwich, so '-0900' is 9 hours west of Greenwich.
  : '%Z' Time zone as a character string.
@@ -173,6 +172,7 @@
  : '%T' Equivalent to '%H:%M:%S'.
  :</pre>
  :
+ : @error normalization:NOTSUPPORTED if the date type is not known to the service. 
  : @return The time value resulting from the conversion.
  : @example test/Queries/data-cleaning/normalization/to-time.xq
  :)
@@ -524,8 +524,8 @@
 };
 
 (:~
- : Converts a given string representation of a dateTime value into a dateTime representation 
- : valid according to the corresponding XML Schema type.
+ : <p>Converts a given string representation of a dateTime value into a dateTime representation 
+ : valid according to the corresponding XML Schema type.</p>
  :
  :
  : @param $sd The string representation for the dateTime.
@@ -533,7 +533,7 @@
  : of conversion specifications. In the format string, a conversion specification is introduced by '%', usually followed by a single 
  : letter or 'O' or 'E' and then a single letter. Any character in the format string that is not part of a conversion specification 
  : is interpreted literally, and the string '%%' gives '%'. The supported conversion specifications are as follows:
- :
+ : <p/>
  : <pre class="ace-static">
  : '%b' Abbreviated month name in the current locale.
  : '%B' Full month name in the current locale.
@@ -566,6 +566,7 @@
  : '%T' Equivalent to '%H:%M:%S'.
  :</pre>
  :
+ : @error normalization:NOTSUPPORTED if the dateTime type is not known to the service. 
  : @return The dateTime value resulting from the conversion.
  : @example test/Queries/data-cleaning/normalization/to-dateTime.xq
  :)
@@ -1183,8 +1184,8 @@
 };
 
 (:~
- : Uses an address normalization Web service to convert a postal address given as input into a 
- : cannonical representation format.
+ : <p>Uses an address normalization Web service to convert a postal address given as input into a 
+ : cannonical representation format.</p>
  :
  : 
  : @param $addr A sequence of strings encoding an address, where each string in the sequence corresponds to a different component (e.g., street, city, country, etc.) of the address.
@@ -1208,13 +1209,13 @@
 };
 
 (:~
- : Uses an phone number normalization Web service to convert a phone number given as input into a 
- : cannonical representation.
+ : <p>Uses an phone number normalization Web service to convert a phone number given as input into a 
+ : cannonical representation.</p>
  : 
  : @param $phone A strings encoding a phone number.
  : @return A strings with the phone number encoded in a cannonical format.
- :
- : <br/><br/><b> Attention : This function is still not implemented. </b> <br/>
+ : <p/>
+ : <p><b> Attention : This function is still not implemented. </b></p> 
  :
  :)
 declare function normalization:normalize-phone ( $addr as xs:string* ) as xs:string* {
@@ -1222,8 +1223,8 @@
 };
 
 (:~
- : Internal auxiliary function that returns an XML representation for a dictionary that contains the 
- : time-shift value associated to different time-zone abbreviations.
+ : <p>Internal auxiliary function that returns an XML representation for a dictionary that contains the 
+ : time-shift value associated to different time-zone abbreviations.</p>
  :)
 declare %private function normalization:timeZone-dictionary() as element(){
 	let $result :=
@@ -1453,8 +1454,8 @@
 };
 
 (:~
- : Internal auxiliary function that returns an XML representation for a dictionary that contains a 
- : numeric value associated to different month name abbreviations.
+ : <p>Internal auxiliary function that returns an XML representation for a dictionary that contains a 
+ : numeric value associated to different month name abbreviations.</p>
  :)
 declare %private function normalization:month-dictionary() as element(){
 let $dictionary :=
@@ -1523,7 +1524,7 @@
 };
 
 (:~
- : Internal auxiliary function that checks if a string is in xs:dateTime format
+ : <p>Internal auxiliary function that checks if a string is in xs:dateTime format</p>
  :
  :
  : @param $dateTime The string representation for the dateTime.
@@ -1534,7 +1535,7 @@
 };
 
 (:~
- : Internal auxiliary function that checks if a string is in xs:date format
+ : <p>Internal auxiliary function that checks if a string is in xs:date format</p>
  :
  :
  : @param $dateTime The string representation for the date.
@@ -1545,7 +1546,7 @@
 };
 
 (:~
- : Internal auxiliary function that checks if a string is in xs:time format
+ : <p>Internal auxiliary function that checks if a string is in xs:time format</p>
  :
  :
  : @param $dateTime The string representation for the time.

=== renamed file 'src/com/zorba-xquery/www/modules/data-cleaning/phonetic-string-similarity.xq' => 'src/phonetic-string-similarity.xq'
--- src/com/zorba-xquery/www/modules/data-cleaning/phonetic-string-similarity.xq	2013-05-18 00:36:01 +0000
+++ src/phonetic-string-similarity.xq	2013-07-10 00:51:26 +0000
@@ -17,29 +17,29 @@
  :)
 
 (:~
- : This library module provides phonetic string similarity functions, comparing strings with basis on how they sound.
- : 
- : These metrics are particularly effective in matching names, since names are often spelled in different 
- : ways that sound the same.
- : 
- : The logic contained in this module is not specific to any particular XQuery implementation.
+ : <p>This library module provides phonetic string similarity functions, comparing strings with basis on how they sound.</p>
+ : <p/>
+ : <p>These metrics are particularly effective in matching names, since names are often spelled in different 
+ : ways that sound the same.</p>
+ : <p/>
+ : <p>The logic contained in this module is not specific to any particular XQuery implementation.</p>
  :
  : @author Bruno Martins
  : @project Zorba/Data Cleaning/Phonectic String Similarity
  :)
 
-module namespace simp = "http://www.zorba-xquery.com/modules/data-cleaning/phonetic-string-similarity";
+module namespace simp = "http://zorba.io/modules/data-cleaning/phonetic-string-similarity";
 
 declare namespace ver = "http://www.zorba-xquery.com/options/versioning";
 declare option ver:module-version "2.0";
 
 (:~
- : Returns the Soundex key for a given string.
- :
- : <br/>
- : Example usage : <code>soundex-key("Robert")</code>
- : <br/>
- : The function invocation in the example above returns : <code>"R163"</code>
+ : <p>Returns the Soundex key for a given string.</p>
+ : <p/>
+ : 
+ : <p>Example usage : <code>soundex-key("Robert")</code></p>
+ : <p/>
+ : <p>The function invocation in the example above returns : <code>"R163"</code></p>
  :
  : @param $s1 The string.
  : @return The Soundex key for the given input string.
@@ -55,12 +55,12 @@
 };
 
 (:~
- : Checks if two strings have the same Soundex key.
- :
- : <br/>
- : Example usage : <code>soundex( "Robert" , "Rupert" )</code>
- : <br/>
- : The function invocation in the example above returns : <code>true</code>
+ : <p>Checks if two strings have the same Soundex key.</p>
+ : <p/>
+ : 
+ : <p>Example usage : <code>soundex( "Robert" , "Rupert" )</code></p>
+ : <p/>
+ : <p>The function invocation in the example above returns : <code>true</code></p>
  :
  : @param $s1 The first string.
  : @param $s2 The second string.
@@ -72,13 +72,13 @@
 };
 
 (:~
- : Returns the Metaphone key for a given string.
- : The Metaphone algorithm produces variable length keys as its output, as opposed to Soundex's fixed-length keys.
- :
- : <br/>
- : Example usage : <code>metaphone-key("ALEKSANDER")</code>
- : <br/>
- : The function invocation in the example above returns : <code>"ALKSNTR"</code>
+ : <p>Returns the Metaphone key for a given string.</p>
+ : <p>The Metaphone algorithm produces variable length keys as its output, as opposed to Soundex's fixed-length keys.</p>
+ : <p/>
+ : 
+ : <p>Example usage : <code>metaphone-key("ALEKSANDER")</code></p>
+ : <p/>
+ : <p>The function invocation in the example above returns : <code>"ALKSNTR"</code></p>
  :
  : @param $s1 The string.
  : @return The Metaphone key for the given input string.
@@ -99,12 +99,12 @@
 };
 
 (:~
- : Checks if two strings have the same Metaphone key.
- :
- : <br/>
- : Example usage : <code>metaphone("ALEKSANDER", "ALEXANDRE")</code>
- : <br/>
- : The function invocation in the example above returns : <code>true</code>
+ : <p>Checks if two strings have the same Metaphone key.</p>
+ : <p/>
+ : 
+ : <p>Example usage : <code>metaphone("ALEKSANDER", "ALEXANDRE")</code></p>
+ : <p/>
+ : <p>The function invocation in the example above returns : <code>true</code></p>
  :
  : @param $s1 The first string.
  : @param $s2 The second string.

=== renamed file 'src/com/zorba-xquery/www/modules/data-cleaning/set-similarity.xq' => 'src/set-similarity.xq'
--- src/com/zorba-xquery/www/modules/data-cleaning/set-similarity.xq	2012-09-28 13:34:20 +0000
+++ src/set-similarity.xq	2013-07-10 00:51:26 +0000
@@ -17,29 +17,29 @@
  :)
 
 (:~
- : This library module provides similarity functions for comparing sets of XML 
- : nodes (e.g., sets of XML elements, attributes or atomic values).
- :
- : These functions are particularly useful for matching near duplicate sets of XML nodes.
- :
- : The logic contained in this module is not specific to any particular XQuery implementation.
+ : <p>This library module provides similarity functions for comparing sets of XML 
+ : nodes (e.g., sets of XML elements, attributes or atomic values).</p>
+ : <p/>
+ : <p>These functions are particularly useful for matching near duplicate sets of XML nodes.</p>
+ : <p/>
+ : <p>The logic contained in this module is not specific to any particular XQuery implementation.</p>
  :
  : @author Bruno Martins
  : @project Zorba/Data Cleaning/Set Similarity
  :)
 
-module namespace set = "http://www.zorba-xquery.com/modules/data-cleaning/set-similarity";
+module namespace set = "http://zorba.io/modules/data-cleaning/set-similarity";
 
 declare namespace ver = "http://www.zorba-xquery.com/options/versioning";
 declare option ver:module-version "2.0";
 
 (:~
- : Returns the union between two sets, using the deep-equal() function to compare the XML nodes from the sets.
- :
- : <br/>
- : Example usage : <code> deep-union ( ( "a", "b", "c") , ( "a", "a", <d/> ) ) </code>
- : <br/>
- : The function invocation in the example above returns : <code> ("a", "b", "c", <d/> ) </code>
+ : <p>Returns the union between two sets, using the deep-equal() function to compare the XML nodes from the sets.</p>
+ : <p/>
+ : 
+ : <p>Example usage : <code> deep-union ( ( "a", "b", "c") , ( "a", "a", <d/> ) ) </code></p>
+ : <p/>
+ : <p>The function invocation in the example above returns : <code> ("a", "b", "c", <d/> ) </code></p>
  :
  : @param $s1 The first set.
  : @param $s2 The second set.
@@ -54,12 +54,12 @@
 };
 
 (:~
- : Returns the intersection between two sets, using the deep-equal() function to compare the XML nodes from the sets.
- :
- : <br/>
- : Example usage : <code> deep-intersect ( ( "a", "b", "c") , ( "a", "a", <d/> ) ) </code>
- : <br/>
- : The function invocation in the example above returns : <code> ("a") </code>
+ : <p>Returns the intersection between two sets, using the deep-equal() function to compare the XML nodes from the sets.</p>
+ : <p/>
+ : 
+ : <p>Example usage : <code> deep-intersect ( ( "a", "b", "c") , ( "a", "a", <d/> ) ) </code></p>
+ : <p/>
+ : <p>The function invocation in the example above returns : <code> ("a") </code></p>
  :
  : @param $s1 The first set.
  : @param $s2 The second set.
@@ -75,12 +75,12 @@
 };
 
 (:~
- : Removes exact duplicates from a set, using the deep-equal() function to compare the XML nodes from the sets.
- :
- : <br/>
- : Example usage : <code> distinct ( ( "a", "a", <b/> ) ) </code>
- : <br/>
- : The function invocation in the example above returns : <code> ("a", <b/> ) </code>
+ : <p>Removes exact duplicates from a set, using the deep-equal() function to compare the XML nodes from the sets.</p>
+ : <p/>
+ : 
+ : <p>Example usage : <code> distinct ( ( "a", "a", <b/> ) ) </code></p>
+ : <p/>
+ : <p>The function invocation in the example above returns : <code> ("a", <b/> ) </code></p>
  :
  : @param $s A set.
  : @return The set provided as input without the exact duplicates (i.e., returns the distinct nodes from the set provided as input).
@@ -93,14 +93,14 @@
 };
 
 (:~
- : Returns the overlap coefficient between two sets of XML nodes.
- : The overlap coefficient is defined as the shared information between the input sets 
- : (i.e., the size of the intersection) over the size of the smallest input set.
- :
- : <br/>
- : Example usage : <code> overlap ( ( "a", "b", <c/> ) , ( "a", "a", "b" ) ) </code>
- : <br/>
- : The function invocation in the example above returns : <code> 1.0 </code>
+ : <p>Returns the overlap coefficient between two sets of XML nodes.</p>
+ : <p>The overlap coefficient is defined as the shared information between the input sets 
+ : (i.e., the size of the intersection) over the size of the smallest input set.</p>
+ : <p/>
+ : 
+ : <p>Example usage : <code> overlap ( ( "a", "b", <c/> ) , ( "a", "a", "b" ) ) </code></p>
+ : <p/>
+ : <p>The function invocation in the example above returns : <code> 1.0 </code></p>
  :
  : @param $s1 The first set.
  : @param $s2 The second set.
@@ -112,14 +112,14 @@
 };
 
 (:~
- : Returns the Dice similarity coefficient between two sets of XML nodes.
- : The Dice coefficient is defined as defined as twice the shared information between the input sets 
- : (i.e., the size of the intersection) over the sum of the cardinalities for the input sets.
- :
- : <br/>
- : Example usage : <code> dice ( ( "a", "b", <c/> ) , ( "a", "a", "d") ) </code>
- : <br/>
- : The function invocation in the example above returns : <code> 0.4 </code>
+ : <p>Returns the Dice similarity coefficient between two sets of XML nodes.</p>
+ : <p>The Dice coefficient is defined as defined as twice the shared information between the input sets 
+ : (i.e., the size of the intersection) over the sum of the cardinalities for the input sets.</p>
+ : <p/>
+ : 
+ : <p>Example usage : <code> dice ( ( "a", "b", <c/> ) , ( "a", "a", "d") ) </code></p>
+ : <p/>
+ : <p>The function invocation in the example above returns : <code> 0.4 </code></p>
  :
  : @param $s1 The first set.
  : @param $s2 The second set.
@@ -131,14 +131,14 @@
 };
 
 (:~
- : Returns the Jaccard similarity coefficient between two sets of XML nodes.
- : The Jaccard coefficient is defined as the size of the intersection divided by the size of the 
- : union of the input sets.
- :
- : <br/>
- : Example usage : <code> jaccard ( ( "a", "b", <c/> ) , ( "a", "a", "d") ) </code>
- : <br/>
- : The function invocation in the example above returns : <code> 0.25 </code>
+ : <p>Returns the Jaccard similarity coefficient between two sets of XML nodes.</p>
+ : <p>The Jaccard coefficient is defined as the size of the intersection divided by the size of the 
+ : union of the input sets.</p>
+ : <p/>
+ : 
+ : <p>Example usage : <code> jaccard ( ( "a", "b", <c/> ) , ( "a", "a", "d") ) </code></p>
+ : <p/>
+ : <p>The function invocation in the example above returns : <code> 0.25 </code></p>
  :
  : @param $s1 The first set.
  : @param $s2 The second set.

=== renamed file 'src/com/zorba-xquery/www/modules/data-cleaning/token-based-string-similarity.xq' => 'src/token-based-string-similarity.xq'
--- src/com/zorba-xquery/www/modules/data-cleaning/token-based-string-similarity.xq	2012-09-28 13:34:20 +0000
+++ src/token-based-string-similarity.xq	2013-07-10 00:51:26 +0000
@@ -17,40 +17,40 @@
  :)
 
 (:~
- : This library module provides token-based string similarity functions that view strings 
- : as sets or multi-sets of tokens and use set-related properties to compute similarity scores. 
- : The tokens correspond to groups of characters extracted from the strings being compared, such as 
- : individual words or character n-grams.
- :
- : These functions are particularly useful for matching near duplicate strings in cases where
- : typographical conventions often lead to rearrangement of words (e.g., "John Smith" versus "Smith, John").
- :
- : The logic contained in this module is not specific to any particular XQuery implementation,
+ : <p>This library module provides token-based string similarity functions that view strings 
+ : as sets or multi-sets of tokens and use set-related properties to compute similarity scores.</p> 
+ : <p>The tokens correspond to groups of characters extracted from the strings being compared, such as 
+ : individual words or character n-grams.</p>
+ : <p/>
+ : <p>These functions are particularly useful for matching near duplicate strings in cases where
+ : typographical conventions often lead to rearrangement of words (e.g., "John Smith" versus "Smith, John").</p>
+ : <p/>
+ : <p>The logic contained in this module is not specific to any particular XQuery implementation,
  : although the module requires the trigonometic functions of XQuery 3.0 or a math extension 
- : function such as sqrt($x as numeric) for computing the square root.
+ : function such as sqrt($x as numeric) for computing the square root.</p>
  :
  : @author Bruno Martins
  : @project Zorba/Data Cleaning/Token Based String Similarity
  :)
 
-module namespace simt = "http://www.zorba-xquery.com/modules/data-cleaning/token-based-string-similarity";
+module namespace simt = "http://zorba.io/modules/data-cleaning/token-based-string-similarity";
 
-(: In the QizX or Saxon XQuery engines, it is possible to call external functions from the Java math library :)
-(: declare namespace math = "java:java.lang.Math"; :)
+(: <p>In the QizX or Saxon XQuery engines, it is possible to call external functions from the Java math library :)
+(: declare namespace math = "java:java.lang.Math";</p> :)
 declare namespace math = "http://www.w3.org/2005/xpath-functions/math";
 
-import module namespace set  = "http://www.zorba-xquery.com/modules/data-cleaning/set-similarity";
+import module namespace set  = "http://zorba.io/modules/data-cleaning/set-similarity";
 
 declare namespace ver = "http://www.zorba-xquery.com/options/versioning";
 declare option ver:module-version "2.0";
 
 (:~
- : Returns the individual character n-grams forming a string.
- :
- : <br/>
- : Example usage : <code> ngrams("FLWOR", 2 ) </code>
- : <br/>
- : The function invocation in the example above returns : <code> ("_F" , "FL" , "LW" , "WO" , "LW" , "WO" , "OR" , "R_") </code>
+ : <p>Returns the individual character n-grams forming a string.</p>
+ : <p/>
+ : 
+ : <p>Example usage : <code> ngrams("FLWOR", 2 ) </code></p>
+ : <p/>
+ : <p>The function invocation in the example above returns : <code> ("_F" , "FL" , "LW" , "WO" , "LW" , "WO" , "OR" , "R_") </code></p>
  :
  : @param $s The input string.
  : @param $n The number of characters to consider when extracting n-grams.
@@ -73,13 +73,13 @@
 };
 
 (:~
- : Auxiliary function for computing the cosine similarity coefficient between strings, 
- : using stringdescriptors based on sets of character n-grams or sets of tokens extracted from two strings.
- :
- : <br/>
- : Example usage : <code> cosine( ("aa","bb") , ("bb","aa")) </code>
- : <br/>
- : The function invocation in the example above returns : <code> 1.0 </code>
+ : <p>Auxiliary function for computing the cosine similarity coefficient between strings, 
+ : using stringdescriptors based on sets of character n-grams or sets of tokens extracted from two strings.</p>
+ : <p/>
+ : 
+ : <p>Example usage : <code> cosine( ("aa","bb") , ("bb","aa")) </code></p>
+ : <p/>
+ : <p>The function invocation in the example above returns : <code> 1.0 </code></p>
  :
  : @param $desc1 The descriptor for the first string.
  : @param $desc2 The descriptor for the second string.
@@ -97,12 +97,12 @@
 };
 
 (:~
- : Returns the Dice similarity coefficient between sets of character n-grams extracted from two strings.
- :
- : <br/>
- : Example usage : <code> dice-ngrams("DWAYNE", "DUANE", 2 ) </code>
- : <br/>
- : The function invocation in the example above returns : <code> 0.4615384615384616 </code>
+ : <p>Returns the Dice similarity coefficient between sets of character n-grams extracted from two strings.</p>
+ : <p/>
+ : 
+ : <p>Example usage : <code> dice-ngrams("DWAYNE", "DUANE", 2 ) </code></p>
+ : <p/>
+ : <p>The function invocation in the example above returns : <code> 0.4615384615384616 </code></p>
  :
  : @param $s1 The first string.
  : @param $s2 The second string.
@@ -115,12 +115,12 @@
 };
 
 (:~
- : Returns the overlap similarity coefficient between sets of character n-grams extracted from two strings.
- :
- : <br/>
- : Example usage : <code> overlap-ngrams("DWAYNE", "DUANE", 2 ) </code>
- : <br/>
- : The function invocation in the example above returns : <code> 0.5 </code>
+ : <p>Returns the overlap similarity coefficient between sets of character n-grams extracted from two strings.</p>
+ : <p/>
+ : 
+ : <p>Example usage : <code> overlap-ngrams("DWAYNE", "DUANE", 2 ) </code></p>
+ : <p/>
+ : <p>The function invocation in the example above returns : <code> 0.5 </code></p>
  :
  : @param $s1 The first string.
  : @param $s2 The second string.
@@ -133,12 +133,12 @@
 };
 
 (:~
- : Returns the Jaccard similarity coefficient between sets of character n-grams extracted from two strings.
- :
- : <br/>
- : Example usage : <code> jaccard-ngrams("DWAYNE", "DUANE", 2 ) </code>
- : <br/>
- : The function invocation in the example above returns : <code> 0.3 </code>
+ : <p>Returns the Jaccard similarity coefficient between sets of character n-grams extracted from two strings.</p>
+ : <p/>
+ : 
+ : <p>Example usage : <code> jaccard-ngrams("DWAYNE", "DUANE", 2 ) </code></p>
+ : <p/>
+ : <p>The function invocation in the example above returns : <code> 0.3 </code></p>
  :
  : @param $s1 The first string.
  : @param $s2 The second string.
@@ -151,14 +151,14 @@
 };
 
 (:~
- : Returns the cosine similarity coefficient between sets of character n-grams extracted from two strings. 
- : The n-grams from each string are weighted according to their occurence frequency (i.e., weighted according to
- : the term-frequency heuristic from Information Retrieval).
- :
- : <br/>
- : Example usage : <code> cosine-ngrams("DWAYNE", "DUANE", 2 ) </code>
- : <br/>
- : The function invocation in the example above returns : <code> 0.2401922307076307 </code>
+ : <p>Returns the cosine similarity coefficient between sets of character n-grams extracted from two strings.</p> 
+ : <p>The n-grams from each string are weighted according to their occurence frequency (i.e., weighted according to
+ : the term-frequency heuristic from Information Retrieval).</p>
+ : <p/>
+ : 
+ : <p>Example usage : <code> cosine-ngrams("DWAYNE", "DUANE", 2 ) </code></p>
+ : <p/>
+ : <p>The function invocation in the example above returns : <code> 0.2401922307076307 </code></p>
  :
  : @param $s1 The first string.
  : @param $s2 The second string.
@@ -173,12 +173,12 @@
 };
 
 (:~
- : Returns the Dice similarity coefficient between sets of tokens extracted from two strings.
- :
- : <br/>
- : Example usage : <code> dice-tokens("The FLWOR Foundation", "FLWOR Found.", " +" ) </code>
- : <br/>
- : The function invocation in the example above returns : <code> 0.4 </code>
+ : <p>Returns the Dice similarity coefficient between sets of tokens extracted from two strings.</p>
+ : <p/>
+ : 
+ : <p>Example usage : <code> dice-tokens("The FLWOR Foundation", "FLWOR Found.", " +" ) </code></p>
+ : <p/>
+ : <p>The function invocation in the example above returns : <code> 0.4 </code></p>
  :
  : @param $s1 The first string.
  : @param $s2 The second string.
@@ -191,12 +191,12 @@
 };
 
 (:~
- : Returns the overlap similarity coefficient between sets of tokens extracted from two strings.
- :
- : <br/>
- : Example usage : <code> overlap-tokens("The FLWOR Foundation", "FLWOR Found.", " +" ) </code>
- : <br/>
- : The function invocation in the example above returns : <code> 0.5 </code>
+ : <p>Returns the overlap similarity coefficient between sets of tokens extracted from two strings.</p>
+ : <p/>
+ : 
+ : <p>Example usage : <code> overlap-tokens("The FLWOR Foundation", "FLWOR Found.", " +" ) </code></p>
+ : <p/>
+ : <p>The function invocation in the example above returns : <code> 0.5 </code></p>
  :
  : @param $s1 The first string.
  : @param $s2 The second string.
@@ -209,12 +209,12 @@
 };
 
 (:~
- : Returns the Jaccard similarity coefficient between sets of tokens extracted from two strings.
- :
- : <br/>
- : Example usage : <code> jaccard-tokens("The FLWOR Foundation", "FLWOR Found.", " +" ) </code>
- : <br/>
- : The function invocation in the example above returns : <code> 0.25 </code>
+ : <p>Returns the Jaccard similarity coefficient between sets of tokens extracted from two strings.</p>
+ : <p/>
+ : 
+ : <p>Example usage : <code> jaccard-tokens("The FLWOR Foundation", "FLWOR Found.", " +" ) </code></p>
+ : <p/>
+ : <p>The function invocation in the example above returns : <code> 0.25 </code></p>
  :
  : @param $s1 The first string.
  : @param $s2 The second string.
@@ -227,14 +227,14 @@
 };
 
 (:~
- : Returns the cosine similarity coefficient between sets of tokens extracted from two strings. The tokens 
+ : <p>Returns the cosine similarity coefficient between sets of tokens extracted from two strings. The tokens 
  : from each string are weighted according to their occurence frequency (i.e., weighted according to the 
- : term-frequency heuristic from Information Retrieval).
- :
- : <br/>
- : Example usage : <code> cosine-tokens("The FLWOR Foundation", "FLWOR Found.", " +" ) </code>
- : <br/>
- : The function invocation in the example above returns : <code> 0.408248290463863 </code>
+ : term-frequency heuristic from Information Retrieval).</p>
+ : <p/>
+ : 
+ : <p>Example usage : <code> cosine-tokens("The FLWOR Foundation", "FLWOR Found.", " +" ) </code></p>
+ : <p/>
+ : <p>The function invocation in the example above returns : <code> 0.408248290463863 </code></p>
  :
  : @param $s1 The first string.
  : @param $s2 The second string.

=== renamed file 'src/com/zorba-xquery/www/modules/data-cleaning/whitepages_schema.xsd' => 'src/whitepages_schema.xsd'
=== modified file 'test/Queries/data-cleaning/character-based-string-similarity/edit-distance.xq'
--- test/Queries/data-cleaning/character-based-string-similarity/edit-distance.xq	2011-07-26 20:10:34 +0000
+++ test/Queries/data-cleaning/character-based-string-similarity/edit-distance.xq	2013-07-10 00:51:26 +0000
@@ -1,3 +1,3 @@
-import module namespace simc = "http://www.zorba-xquery.com/modules/data-cleaning/character-based-string-similarity";
+import module namespace simc = "http://zorba.io/modules/data-cleaning/character-based-string-similarity";
 
 simc:edit-distance("FLWOR", "FLOWER")

=== modified file 'test/Queries/data-cleaning/character-based-string-similarity/jaro-winkler.xq'
--- test/Queries/data-cleaning/character-based-string-similarity/jaro-winkler.xq	2011-07-26 20:10:34 +0000
+++ test/Queries/data-cleaning/character-based-string-similarity/jaro-winkler.xq	2013-07-10 00:51:26 +0000
@@ -1,3 +1,3 @@
-import module namespace simc = "http://www.zorba-xquery.com/modules/data-cleaning/character-based-string-similarity";
+import module namespace simc = "http://zorba.io/modules/data-cleaning/character-based-string-similarity";
 
 simc:jaro-winkler("DWAYNE", "DUANE", 4, 0.1 )

=== modified file 'test/Queries/data-cleaning/character-based-string-similarity/jaro.xq'
--- test/Queries/data-cleaning/character-based-string-similarity/jaro.xq	2011-07-26 20:10:34 +0000
+++ test/Queries/data-cleaning/character-based-string-similarity/jaro.xq	2013-07-10 00:51:26 +0000
@@ -1,3 +1,3 @@
-import module namespace simc = "http://www.zorba-xquery.com/modules/data-cleaning/character-based-string-similarity";
+import module namespace simc = "http://zorba.io/modules/data-cleaning/character-based-string-similarity";
 
 simc:jaro("FLWOR Found.", "FLWOR Foundation")

=== modified file 'test/Queries/data-cleaning/character-based-string-similarity/needleman-wunsch.xq'
--- test/Queries/data-cleaning/character-based-string-similarity/needleman-wunsch.xq	2011-07-26 20:10:34 +0000
+++ test/Queries/data-cleaning/character-based-string-similarity/needleman-wunsch.xq	2013-07-10 00:51:26 +0000
@@ -1,3 +1,3 @@
-import module namespace simc = "http://www.zorba-xquery.com/modules/data-cleaning/character-based-string-similarity";
+import module namespace simc = "http://zorba.io/modules/data-cleaning/character-based-string-similarity";
 
 simc:needleman-wunsch("KAK", "KQRK", 1, 1)

=== modified file 'test/Queries/data-cleaning/consolidation/least-attributes.xq'
--- test/Queries/data-cleaning/consolidation/least-attributes.xq	2011-07-19 19:12:03 +0000
+++ test/Queries/data-cleaning/consolidation/least-attributes.xq	2013-07-10 00:51:26 +0000
@@ -1,3 +1,3 @@
-import module namespace con = "http://www.zorba-xquery.com/modules/data-cleaning/consolidation";
+import module namespace con = "http://zorba.io/modules/data-cleaning/consolidation";
 
 con:least-attributes( ( <a att1="a1" att2="a2"/>, <b att1="a1" />, <c/> ) )

=== modified file 'test/Queries/data-cleaning/consolidation/least-distinct-attributes.xq'
--- test/Queries/data-cleaning/consolidation/least-distinct-attributes.xq	2011-07-19 19:12:03 +0000
+++ test/Queries/data-cleaning/consolidation/least-distinct-attributes.xq	2013-07-10 00:51:26 +0000
@@ -1,3 +1,3 @@
-import module namespace con = "http://www.zorba-xquery.com/modules/data-cleaning/consolidation";
+import module namespace con = "http://zorba.io/modules/data-cleaning/consolidation";
 
 con:least-distinct-attributes( ( <a att1="a1" att2="a2"/>, <b att1="a1" />, <c/> ) )

=== modified file 'test/Queries/data-cleaning/consolidation/least-distinct-elements.xq'
--- test/Queries/data-cleaning/consolidation/least-distinct-elements.xq	2011-07-19 19:12:03 +0000
+++ test/Queries/data-cleaning/consolidation/least-distinct-elements.xq	2013-07-10 00:51:26 +0000
@@ -1,3 +1,3 @@
-import module namespace con = "http://www.zorba-xquery.com/modules/data-cleaning/consolidation";
+import module namespace con = "http://zorba.io/modules/data-cleaning/consolidation";
 
 con:least-distinct-elements( ( <a><b/></a>, <b><c/></b>, <d/>) )

=== modified file 'test/Queries/data-cleaning/consolidation/least-distinct-nodes.xq'
--- test/Queries/data-cleaning/consolidation/least-distinct-nodes.xq	2011-07-19 19:12:03 +0000
+++ test/Queries/data-cleaning/consolidation/least-distinct-nodes.xq	2013-07-10 00:51:26 +0000
@@ -1,3 +1,3 @@
-import module namespace con = "http://www.zorba-xquery.com/modules/data-cleaning/consolidation";
+import module namespace con = "http://zorba.io/modules/data-cleaning/consolidation";
 
 con:least-distinct-nodes( ( <a><b/></a>, <b><c/></b>, <d/>) )

=== modified file 'test/Queries/data-cleaning/consolidation/least-elements.xq'
--- test/Queries/data-cleaning/consolidation/least-elements.xq	2011-07-19 19:12:03 +0000
+++ test/Queries/data-cleaning/consolidation/least-elements.xq	2013-07-10 00:51:26 +0000
@@ -1,3 +1,3 @@
-import module namespace con = "http://www.zorba-xquery.com/modules/data-cleaning/consolidation";
+import module namespace con = "http://zorba.io/modules/data-cleaning/consolidation";
 
 con:least-elements( ( <a><b/></a>, <b><c/></b>, <d/>) )

=== modified file 'test/Queries/data-cleaning/consolidation/least-nodes.xq'
--- test/Queries/data-cleaning/consolidation/least-nodes.xq	2011-07-19 19:12:03 +0000
+++ test/Queries/data-cleaning/consolidation/least-nodes.xq	2013-07-10 00:51:26 +0000
@@ -1,3 +1,3 @@
-import module namespace con = "http://www.zorba-xquery.com/modules/data-cleaning/consolidation";
+import module namespace con = "http://zorba.io/modules/data-cleaning/consolidation";
 
 con:least-nodes( ( <a><b/></a>, <b><c/></b>, <d/>) )

=== modified file 'test/Queries/data-cleaning/consolidation/least-similar-edit-distance.xq'
--- test/Queries/data-cleaning/consolidation/least-similar-edit-distance.xq	2011-07-19 19:12:03 +0000
+++ test/Queries/data-cleaning/consolidation/least-similar-edit-distance.xq	2013-07-10 00:51:26 +0000
@@ -1,3 +1,3 @@
-import module namespace con = "http://www.zorba-xquery.com/modules/data-cleaning/consolidation";
+import module namespace con = "http://zorba.io/modules/data-cleaning/consolidation";
 
 con:least-similar-edit-distance( ( "aaabbbccc", "aaabbb", "eeefff" ), "aaab" )

=== modified file 'test/Queries/data-cleaning/consolidation/least-tokens.xq'
--- test/Queries/data-cleaning/consolidation/least-tokens.xq	2011-07-19 19:12:03 +0000
+++ test/Queries/data-cleaning/consolidation/least-tokens.xq	2013-07-10 00:51:26 +0000
@@ -1,3 +1,3 @@
-import module namespace con = "http://www.zorba-xquery.com/modules/data-cleaning/consolidation";
+import module namespace con = "http://zorba.io/modules/data-cleaning/consolidation";
 
 con:least-tokens( ( "a b c", "a b", "a"), " +" )

=== modified file 'test/Queries/data-cleaning/consolidation/leastfrequent_1.xq'
--- test/Queries/data-cleaning/consolidation/leastfrequent_1.xq	2011-07-19 19:12:03 +0000
+++ test/Queries/data-cleaning/consolidation/leastfrequent_1.xq	2013-07-10 00:51:26 +0000
@@ -1,3 +1,3 @@
-import module namespace con = "http://www.zorba-xquery.com/modules/data-cleaning/consolidation";
+import module namespace con = "http://zorba.io/modules/data-cleaning/consolidation";
 
 con:least-frequent( ( "a", "a", "b") )

=== modified file 'test/Queries/data-cleaning/consolidation/longest_1.xq'
--- test/Queries/data-cleaning/consolidation/longest_1.xq	2011-07-19 19:12:03 +0000
+++ test/Queries/data-cleaning/consolidation/longest_1.xq	2013-07-10 00:51:26 +0000
@@ -1,3 +1,3 @@
-import module namespace con = "http://www.zorba-xquery.com/modules/data-cleaning/consolidation";
+import module namespace con = "http://zorba.io/modules/data-cleaning/consolidation";
 
 con:longest( ( "a", "aa", "aaa") )

=== modified file 'test/Queries/data-cleaning/consolidation/matching_1.xq'
--- test/Queries/data-cleaning/consolidation/matching_1.xq	2011-07-19 19:12:03 +0000
+++ test/Queries/data-cleaning/consolidation/matching_1.xq	2013-07-10 00:51:26 +0000
@@ -1,3 +1,3 @@
-import module namespace con = "http://www.zorba-xquery.com/modules/data-cleaning/consolidation";
+import module namespace con = "http://zorba.io/modules/data-cleaning/consolidation";
 
 con:matching( ( "a A b", "c AAA d", "e BB f"), "A+" )

=== modified file 'test/Queries/data-cleaning/consolidation/most-attributes.xq'
--- test/Queries/data-cleaning/consolidation/most-attributes.xq	2011-07-19 19:12:03 +0000
+++ test/Queries/data-cleaning/consolidation/most-attributes.xq	2013-07-10 00:51:26 +0000
@@ -1,3 +1,3 @@
-import module namespace con = "http://www.zorba-xquery.com/modules/data-cleaning/consolidation";
+import module namespace con = "http://zorba.io/modules/data-cleaning/consolidation";
 
 con:most-attributes( ( <a att1="a1" att2="a2"/>, <b att1="a1" />, <c/> ) )

=== modified file 'test/Queries/data-cleaning/consolidation/most-distinct-attributes.xq'
--- test/Queries/data-cleaning/consolidation/most-distinct-attributes.xq	2011-07-19 19:12:03 +0000
+++ test/Queries/data-cleaning/consolidation/most-distinct-attributes.xq	2013-07-10 00:51:26 +0000
@@ -1,3 +1,3 @@
-import module namespace con = "http://www.zorba-xquery.com/modules/data-cleaning/consolidation";
+import module namespace con = "http://zorba.io/modules/data-cleaning/consolidation";
 
 con:most-distinct-attributes( ( <a att1="a1" att2="a2" att3="a3"/>, <a att1="a1" att2="a2"><b att2="a2" /></a>, <c/> ) )

=== modified file 'test/Queries/data-cleaning/consolidation/most-distinct-elements.xq'
--- test/Queries/data-cleaning/consolidation/most-distinct-elements.xq	2011-07-19 19:12:03 +0000
+++ test/Queries/data-cleaning/consolidation/most-distinct-elements.xq	2013-07-10 00:51:26 +0000
@@ -1,3 +1,3 @@
-import module namespace con = "http://www.zorba-xquery.com/modules/data-cleaning/consolidation";
+import module namespace con = "http://zorba.io/modules/data-cleaning/consolidation";
 
 con:most-distinct-elements( ( <a><b/><c/><d/></a>, <a><b/><b/><c/></a>, <a/> ) )

=== modified file 'test/Queries/data-cleaning/consolidation/most-distinct-nodes.xq'
--- test/Queries/data-cleaning/consolidation/most-distinct-nodes.xq	2011-07-19 19:12:03 +0000
+++ test/Queries/data-cleaning/consolidation/most-distinct-nodes.xq	2013-07-10 00:51:26 +0000
@@ -1,3 +1,3 @@
-import module namespace con = "http://www.zorba-xquery.com/modules/data-cleaning/consolidation";
+import module namespace con = "http://zorba.io/modules/data-cleaning/consolidation";
 
 con:most-distinct-nodes( ( <a><b/></a>, <a><a/></a>, <b/>) )

=== modified file 'test/Queries/data-cleaning/consolidation/most-elements.xq'
--- test/Queries/data-cleaning/consolidation/most-elements.xq	2011-07-19 19:12:03 +0000
+++ test/Queries/data-cleaning/consolidation/most-elements.xq	2013-07-10 00:51:26 +0000
@@ -1,3 +1,3 @@
-import module namespace con = "http://www.zorba-xquery.com/modules/data-cleaning/consolidation";
+import module namespace con = "http://zorba.io/modules/data-cleaning/consolidation";
 
 con:most-elements( ( <a><b/></a>, <a/>, <b/>) )

=== modified file 'test/Queries/data-cleaning/consolidation/most-frequent.xq'
--- test/Queries/data-cleaning/consolidation/most-frequent.xq	2011-07-19 19:12:03 +0000
+++ test/Queries/data-cleaning/consolidation/most-frequent.xq	2013-07-10 00:51:26 +0000
@@ -1,3 +1,3 @@
-import module namespace con = "http://www.zorba-xquery.com/modules/data-cleaning/consolidation";
+import module namespace con = "http://zorba.io/modules/data-cleaning/consolidation";
 
 con:most-frequent( ( "a", "a", "b") )

=== modified file 'test/Queries/data-cleaning/consolidation/most-nodes.xq'
--- test/Queries/data-cleaning/consolidation/most-nodes.xq	2011-07-19 19:12:03 +0000
+++ test/Queries/data-cleaning/consolidation/most-nodes.xq	2013-07-10 00:51:26 +0000
@@ -1,3 +1,3 @@
-import module namespace con = "http://www.zorba-xquery.com/modules/data-cleaning/consolidation";
+import module namespace con = "http://zorba.io/modules/data-cleaning/consolidation";
 
 con:most-nodes( ( <a><b/></a>, <a/>, <b/>) )

=== modified file 'test/Queries/data-cleaning/consolidation/most-similar-edit-distance.xq'
--- test/Queries/data-cleaning/consolidation/most-similar-edit-distance.xq	2011-07-19 19:12:03 +0000
+++ test/Queries/data-cleaning/consolidation/most-similar-edit-distance.xq	2013-07-10 00:51:26 +0000
@@ -1,3 +1,3 @@
-import module namespace con = "http://www.zorba-xquery.com/modules/data-cleaning/consolidation";
+import module namespace con = "http://zorba.io/modules/data-cleaning/consolidation";
 
 con:most-similar-edit-distance( ( "aaabbbccc", "aaabbb", "eeefff" ), "aaab" )

=== modified file 'test/Queries/data-cleaning/consolidation/most-tokens.xq'
--- test/Queries/data-cleaning/consolidation/most-tokens.xq	2011-07-19 19:12:03 +0000
+++ test/Queries/data-cleaning/consolidation/most-tokens.xq	2013-07-10 00:51:26 +0000
@@ -1,3 +1,3 @@
-import module namespace con = "http://www.zorba-xquery.com/modules/data-cleaning/consolidation";
+import module namespace con = "http://zorba.io/modules/data-cleaning/consolidation";
 
 con:most-tokens( ( "a b c", "a b", "a"), " +" )

=== modified file 'test/Queries/data-cleaning/consolidation/shortest_1.xq'
--- test/Queries/data-cleaning/consolidation/shortest_1.xq	2011-07-19 19:12:03 +0000
+++ test/Queries/data-cleaning/consolidation/shortest_1.xq	2013-07-10 00:51:26 +0000
@@ -1,3 +1,3 @@
-import module namespace con = "http://www.zorba-xquery.com/modules/data-cleaning/consolidation";
+import module namespace con = "http://zorba.io/modules/data-cleaning/consolidation";
 
 con:shortest( ( "a", "aa", "aaa") )

=== modified file 'test/Queries/data-cleaning/consolidation/superstring_1.xq'
--- test/Queries/data-cleaning/consolidation/superstring_1.xq	2011-07-19 19:12:03 +0000
+++ test/Queries/data-cleaning/consolidation/superstring_1.xq	2013-07-10 00:51:26 +0000
@@ -1,3 +1,3 @@
-import module namespace con = "http://www.zorba-xquery.com/modules/data-cleaning/consolidation";
+import module namespace con = "http://zorba.io/modules/data-cleaning/consolidation";
 
 con:superstring( ( "aaa bbb ccc", "aaa bbb", "aaa ddd", "eee fff" ) )

=== modified file 'test/Queries/data-cleaning/conversion/address-from-geocode.xq'
--- test/Queries/data-cleaning/conversion/address-from-geocode.xq	2012-10-03 13:53:12 +0000
+++ test/Queries/data-cleaning/conversion/address-from-geocode.xq	2013-07-10 00:51:26 +0000
@@ -1,4 +1,4 @@
-import module namespace conversion = "http://www.zorba-xquery.com/modules/data-cleaning/conversion";
+import module namespace conversion = "http://zorba.io/modules/data-cleaning/conversion";
 
 for $s in conversion:address-from-geocode ( 38.725735 , -9.15021 )
 return fn:lower-case($s)

=== modified file 'test/Queries/data-cleaning/conversion/address-from-phone.xq'
--- test/Queries/data-cleaning/conversion/address-from-phone.xq	2012-02-05 22:52:01 +0000
+++ test/Queries/data-cleaning/conversion/address-from-phone.xq	2013-07-10 00:51:26 +0000
@@ -1,4 +1,4 @@
-import module namespace conversion = "http://www.zorba-xquery.com/modules/data-cleaning/conversion";
+import module namespace conversion = "http://zorba.io/modules/data-cleaning/conversion";
 
 let $arg := conversion:address-from-phone('8654582358')[1]
 let $result :=

=== modified file 'test/Queries/data-cleaning/conversion/address-from-user.xq'
--- test/Queries/data-cleaning/conversion/address-from-user.xq	2012-02-05 22:52:01 +0000
+++ test/Queries/data-cleaning/conversion/address-from-user.xq	2013-07-10 00:51:26 +0000
@@ -1,4 +1,4 @@
-import module namespace conversion = "http://www.zorba-xquery.com/modules/data-cleaning/conversion";
+import module namespace conversion = "http://zorba.io/modules/data-cleaning/conversion";
 
 let $arg := conversion:address-from-user('Maria Lurdes')[1]
 let $result :=

=== modified file 'test/Queries/data-cleaning/conversion/currency-convert.xq'
--- test/Queries/data-cleaning/conversion/currency-convert.xq	2011-07-19 19:12:03 +0000
+++ test/Queries/data-cleaning/conversion/currency-convert.xq	2013-07-10 00:51:26 +0000
@@ -1,3 +1,3 @@
-import module namespace conversion = "http://www.zorba-xquery.com/modules/data-cleaning/conversion";
+import module namespace conversion = "http://zorba.io/modules/data-cleaning/conversion";
 
 conversion:currency-convert ( 1, "USD", "EUR", "2011-01-18" )

=== modified file 'test/Queries/data-cleaning/conversion/geocode-from-address.xq'
--- test/Queries/data-cleaning/conversion/geocode-from-address.xq	2011-11-08 21:16:29 +0000
+++ test/Queries/data-cleaning/conversion/geocode-from-address.xq	2013-07-10 00:51:26 +0000
@@ -1,4 +1,4 @@
-import module namespace conversion = "http://www.zorba-xquery.com/modules/data-cleaning/conversion";
+import module namespace conversion = "http://zorba.io/modules/data-cleaning/conversion";
 
 let $geocode := conversion:geocode-from-address ( ("Lisboa", "Portugal") )
 for $result in $geocode

=== modified file 'test/Queries/data-cleaning/conversion/phone-from-address.xq'
--- test/Queries/data-cleaning/conversion/phone-from-address.xq	2012-02-05 22:52:01 +0000
+++ test/Queries/data-cleaning/conversion/phone-from-address.xq	2013-07-10 00:51:26 +0000
@@ -1,4 +1,4 @@
-import module namespace conversion = "http://www.zorba-xquery.com/modules/data-cleaning/conversion";
+import module namespace conversion = "http://zorba.io/modules/data-cleaning/conversion";
 
 let $arg := conversion:phone-from-address('5655 E Gaskill Rd, Willcox, AZ, US')[1]
 let $result :=

=== modified file 'test/Queries/data-cleaning/conversion/phone-from-user.xq'
--- test/Queries/data-cleaning/conversion/phone-from-user.xq	2012-02-05 22:52:01 +0000
+++ test/Queries/data-cleaning/conversion/phone-from-user.xq	2013-07-10 00:51:26 +0000
@@ -1,4 +1,4 @@
-import module namespace conversion = "http://www.zorba-xquery.com/modules/data-cleaning/conversion";
+import module namespace conversion = "http://zorba.io/modules/data-cleaning/conversion";
 
 let $arg := conversion:phone-from-user ('Maria Lurdes')[1]
 let $result :=

=== modified file 'test/Queries/data-cleaning/conversion/unit-convert.xq'
--- test/Queries/data-cleaning/conversion/unit-convert.xq	2011-07-19 19:12:03 +0000
+++ test/Queries/data-cleaning/conversion/unit-convert.xq	2013-07-10 00:51:26 +0000
@@ -1,3 +1,3 @@
-import module namespace conversion = "http://www.zorba-xquery.com/modules/data-cleaning/conversion";
+import module namespace conversion = "http://zorba.io/modules/data-cleaning/conversion";
 
 conversion:unit-convert ( 1 , "Distance", "mile", "kilometer" )

=== modified file 'test/Queries/data-cleaning/conversion/user-from-address.xq'
--- test/Queries/data-cleaning/conversion/user-from-address.xq	2012-02-05 22:52:01 +0000
+++ test/Queries/data-cleaning/conversion/user-from-address.xq	2013-07-10 00:51:26 +0000
@@ -1,4 +1,4 @@
-import module namespace conversion = "http://www.zorba-xquery.com/modules/data-cleaning/conversion";
+import module namespace conversion = "http://zorba.io/modules/data-cleaning/conversion";
 
 let $arg := conversion:user-from-address('5655 E Gaskill Rd, Willcox, AZ, US')[1]
 let $result :=

=== modified file 'test/Queries/data-cleaning/conversion/user-from-phone.xq'
--- test/Queries/data-cleaning/conversion/user-from-phone.xq	2012-02-05 22:52:01 +0000
+++ test/Queries/data-cleaning/conversion/user-from-phone.xq	2013-07-10 00:51:26 +0000
@@ -1,4 +1,4 @@
-import module namespace conversion = "http://www.zorba-xquery.com/modules/data-cleaning/conversion";
+import module namespace conversion = "http://zorba.io/modules/data-cleaning/conversion";
 
 let $arg := conversion:user-from-phone ('8654582358')[1]
 let $result :=

=== modified file 'test/Queries/data-cleaning/hybrid-string-similarity/monge-elkan-jaro-winkler.xq'
--- test/Queries/data-cleaning/hybrid-string-similarity/monge-elkan-jaro-winkler.xq	2011-07-19 19:12:03 +0000
+++ test/Queries/data-cleaning/hybrid-string-similarity/monge-elkan-jaro-winkler.xq	2013-07-10 00:51:26 +0000
@@ -1,3 +1,3 @@
-import module namespace simh = "http://www.zorba-xquery.com/modules/data-cleaning/hybrid-string-similarity";
+import module namespace simh = "http://zorba.io/modules/data-cleaning/hybrid-string-similarity";
 
 simh:monge-elkan-jaro-winkler("Comput. Sci. and Eng. Dept., University of California, San Diego", "Department of Computer Scinece, Univ. Calif., San Diego", 4, 0.1)

=== modified file 'test/Queries/data-cleaning/hybrid-string-similarity/soft-cosine-tokens-edit-distance.xq'
--- test/Queries/data-cleaning/hybrid-string-similarity/soft-cosine-tokens-edit-distance.xq	2011-07-19 19:12:03 +0000
+++ test/Queries/data-cleaning/hybrid-string-similarity/soft-cosine-tokens-edit-distance.xq	2013-07-10 00:51:26 +0000
@@ -1,3 +1,3 @@
-import module namespace simh = "http://www.zorba-xquery.com/modules/data-cleaning/hybrid-string-similarity";
+import module namespace simh = "http://zorba.io/modules/data-cleaning/hybrid-string-similarity";
 
 simh:soft-cosine-tokens-edit-distance("The FLWOR Foundation", "FLWOR Found.", " +", 0 )

=== modified file 'test/Queries/data-cleaning/hybrid-string-similarity/soft-cosine-tokens-jaro-winkler.xq'
--- test/Queries/data-cleaning/hybrid-string-similarity/soft-cosine-tokens-jaro-winkler.xq	2011-07-19 19:12:03 +0000
+++ test/Queries/data-cleaning/hybrid-string-similarity/soft-cosine-tokens-jaro-winkler.xq	2013-07-10 00:51:26 +0000
@@ -1,3 +1,3 @@
-import module namespace simh = "http://www.zorba-xquery.com/modules/data-cleaning/hybrid-string-similarity";
+import module namespace simh = "http://zorba.io/modules/data-cleaning/hybrid-string-similarity";
 
 simh:soft-cosine-tokens-jaro-winkler("The FLWOR Foundation", "FLWOR Found.", " +", 1, 4, 0.1 )

=== modified file 'test/Queries/data-cleaning/hybrid-string-similarity/soft-cosine-tokens-jaro.xq'
--- test/Queries/data-cleaning/hybrid-string-similarity/soft-cosine-tokens-jaro.xq	2011-07-19 19:12:03 +0000
+++ test/Queries/data-cleaning/hybrid-string-similarity/soft-cosine-tokens-jaro.xq	2013-07-10 00:51:26 +0000
@@ -1,3 +1,3 @@
-import module namespace simh = "http://www.zorba-xquery.com/modules/data-cleaning/hybrid-string-similarity";
+import module namespace simh = "http://zorba.io/modules/data-cleaning/hybrid-string-similarity";
 
 simh:soft-cosine-tokens-jaro("The FLWOR Foundation", "FLWOR Found.", " +", 1 )

=== modified file 'test/Queries/data-cleaning/hybrid-string-similarity/soft-cosine-tokens-metaphone.xq'
--- test/Queries/data-cleaning/hybrid-string-similarity/soft-cosine-tokens-metaphone.xq	2011-07-19 19:12:03 +0000
+++ test/Queries/data-cleaning/hybrid-string-similarity/soft-cosine-tokens-metaphone.xq	2013-07-10 00:51:26 +0000
@@ -1,3 +1,3 @@
-import module namespace simh = "http://www.zorba-xquery.com/modules/data-cleaning/hybrid-string-similarity";
+import module namespace simh = "http://zorba.io/modules/data-cleaning/hybrid-string-similarity";
 
 simh:soft-cosine-tokens-metaphone("ALEKSANDER SMITH", "ALEXANDER SMYTH", " +" )

=== modified file 'test/Queries/data-cleaning/hybrid-string-similarity/soft-cosine-tokens-soundex.xq'
--- test/Queries/data-cleaning/hybrid-string-similarity/soft-cosine-tokens-soundex.xq	2011-07-19 19:12:03 +0000
+++ test/Queries/data-cleaning/hybrid-string-similarity/soft-cosine-tokens-soundex.xq	2013-07-10 00:51:26 +0000
@@ -1,3 +1,3 @@
-import module namespace simh = "http://www.zorba-xquery.com/modules/data-cleaning/hybrid-string-similarity";
+import module namespace simh = "http://zorba.io/modules/data-cleaning/hybrid-string-similarity";
 
 simh:soft-cosine-tokens-soundex("ALEKSANDER SMITH", "ALEXANDER SMYTH", " +")

=== modified file 'test/Queries/data-cleaning/normalization/normalize-address.xq'
--- test/Queries/data-cleaning/normalization/normalize-address.xq	2011-07-19 19:12:03 +0000
+++ test/Queries/data-cleaning/normalization/normalize-address.xq	2013-07-10 00:51:26 +0000
@@ -1,3 +1,3 @@
-import module namespace normalization = "http://www.zorba-xquery.com/modules/data-cleaning/normalization";
+import module namespace normalization = "http://zorba.io/modules/data-cleaning/normalization";
 
 normalization:normalize-address ( ( 'Marques de Pombal' , 'Lisboa' ) )

=== modified file 'test/Queries/data-cleaning/normalization/to-date.xq'
--- test/Queries/data-cleaning/normalization/to-date.xq	2011-07-19 19:12:03 +0000
+++ test/Queries/data-cleaning/normalization/to-date.xq	2013-07-10 00:51:26 +0000
@@ -1,3 +1,3 @@
-import module namespace normalization = "http://www.zorba-xquery.com/modules/data-cleaning/normalization";
+import module namespace normalization = "http://zorba.io/modules/data-cleaning/normalization";
 
 normalization:to-date ( "24OCT2002" , "%d%b%Y" )

=== modified file 'test/Queries/data-cleaning/normalization/to-dateTime.spec'
--- test/Queries/data-cleaning/normalization/to-dateTime.spec	2011-07-26 20:10:34 +0000
+++ test/Queries/data-cleaning/normalization/to-dateTime.spec	2013-07-10 00:51:26 +0000
@@ -1,1 +1,1 @@
-Error: http://www.zorba-xquery.com/modules/data-cleaning/normalization:notsupported
+Error: http://zorba.io/modules/data-cleaning/normalization:NOTSUPPORTED

=== modified file 'test/Queries/data-cleaning/normalization/to-dateTime.xq'
--- test/Queries/data-cleaning/normalization/to-dateTime.xq	2011-07-26 20:10:34 +0000
+++ test/Queries/data-cleaning/normalization/to-dateTime.xq	2013-07-10 00:51:26 +0000
@@ -1,3 +1,3 @@
-import module namespace normalization = "http://www.zorba-xquery.com/modules/data-cleaning/normalization";
+import module namespace normalization = "http://zorba.io/modules/data-cleaning/normalization";
 
 normalization:to-dateTime( "24OCT2002 21:22" , "%d%b%Y %H%M" )

=== modified file 'test/Queries/data-cleaning/normalization/to-time.spec'
--- test/Queries/data-cleaning/normalization/to-time.spec	2011-07-19 19:12:03 +0000
+++ test/Queries/data-cleaning/normalization/to-time.spec	2013-07-10 00:51:26 +0000
@@ -1,1 +1,1 @@
-Error: http://www.zorba-xquery.com/modules/data-cleaning/normalization:notsupported
+Error: http://zorba.io/modules/data-cleaning/normalization:NOTSUPPORTED

=== modified file 'test/Queries/data-cleaning/normalization/to-time.xq'
--- test/Queries/data-cleaning/normalization/to-time.xq	2011-07-19 19:12:03 +0000
+++ test/Queries/data-cleaning/normalization/to-time.xq	2013-07-10 00:51:26 +0000
@@ -1,3 +1,3 @@
-import module namespace normalization = "http://www.zorba-xquery.com/modules/data-cleaning/normalization";
+import module namespace normalization = "http://zorba.io/modules/data-cleaning/normalization";
 
 normalization:to-time ( "09 hours 10 minutes" , "%H hours %M minutes" )

=== modified file 'test/Queries/data-cleaning/phonetic-string-similarity/metaphone-key.xq'
--- test/Queries/data-cleaning/phonetic-string-similarity/metaphone-key.xq	2011-07-19 19:12:03 +0000
+++ test/Queries/data-cleaning/phonetic-string-similarity/metaphone-key.xq	2013-07-10 00:51:26 +0000
@@ -1,3 +1,3 @@
-import module namespace simp = "http://www.zorba-xquery.com/modules/data-cleaning/phonetic-string-similarity";
+import module namespace simp = "http://zorba.io/modules/data-cleaning/phonetic-string-similarity";
 
 simp:metaphone-key("ALEKSANDER")

=== modified file 'test/Queries/data-cleaning/phonetic-string-similarity/metaphone.xq'
--- test/Queries/data-cleaning/phonetic-string-similarity/metaphone.xq	2011-07-19 19:12:03 +0000
+++ test/Queries/data-cleaning/phonetic-string-similarity/metaphone.xq	2013-07-10 00:51:26 +0000
@@ -1,3 +1,3 @@
-import module namespace simp = "http://www.zorba-xquery.com/modules/data-cleaning/phonetic-string-similarity";
+import module namespace simp = "http://zorba.io/modules/data-cleaning/phonetic-string-similarity";
 
 simp:metaphone-key("ALEKSANDER")

=== modified file 'test/Queries/data-cleaning/phonetic-string-similarity/soundex-key.xq'
--- test/Queries/data-cleaning/phonetic-string-similarity/soundex-key.xq	2013-05-18 00:38:53 +0000
+++ test/Queries/data-cleaning/phonetic-string-similarity/soundex-key.xq	2013-07-10 00:51:26 +0000
@@ -1,4 +1,4 @@
-import module namespace simpl = "http://www.zorba-xquery.com/modules/data-cleaning/phonetic-string-similarity";
+import module namespace simpl = "http://zorba.io/modules/data-cleaning/phonetic-string-similarity";
 
 simpl:soundex-key("Robert"),
 simpl:soundex-key("BARHAM") eq "B650" and

=== modified file 'test/Queries/data-cleaning/phonetic-string-similarity/soundex.xq'
--- test/Queries/data-cleaning/phonetic-string-similarity/soundex.xq	2011-07-19 19:12:03 +0000
+++ test/Queries/data-cleaning/phonetic-string-similarity/soundex.xq	2013-07-10 00:51:26 +0000
@@ -1,3 +1,3 @@
-import module namespace simp = "http://www.zorba-xquery.com/modules/data-cleaning/phonetic-string-similarity";
+import module namespace simp = "http://zorba.io/modules/data-cleaning/phonetic-string-similarity";
 
 simp:soundex( "Robert" , "Rupert" )

=== modified file 'test/Queries/data-cleaning/set-similarity/deep-intersect.xq'
--- test/Queries/data-cleaning/set-similarity/deep-intersect.xq	2011-07-19 19:12:03 +0000
+++ test/Queries/data-cleaning/set-similarity/deep-intersect.xq	2013-07-10 00:51:26 +0000
@@ -1,3 +1,3 @@
-import module namespace set = "http://www.zorba-xquery.com/modules/data-cleaning/set-similarity";
+import module namespace set = "http://zorba.io/modules/data-cleaning/set-similarity";
 
 set:deep-intersect ( ( "a", "b", "c") , ( "a", "a", <d/> ) )

=== modified file 'test/Queries/data-cleaning/set-similarity/deep-union.xq'
--- test/Queries/data-cleaning/set-similarity/deep-union.xq	2011-07-19 19:12:03 +0000
+++ test/Queries/data-cleaning/set-similarity/deep-union.xq	2013-07-10 00:51:26 +0000
@@ -1,3 +1,3 @@
-import module namespace set = "http://www.zorba-xquery.com/modules/data-cleaning/set-similarity";
+import module namespace set = "http://zorba.io/modules/data-cleaning/set-similarity";
 
 set:deep-union ( ( "a", "b", "c") , ( "a", "a", <d/> ) )

=== modified file 'test/Queries/data-cleaning/set-similarity/dice.xq'
--- test/Queries/data-cleaning/set-similarity/dice.xq	2011-07-19 19:12:03 +0000
+++ test/Queries/data-cleaning/set-similarity/dice.xq	2013-07-10 00:51:26 +0000
@@ -1,3 +1,3 @@
-import module namespace set = "http://www.zorba-xquery.com/modules/data-cleaning/set-similarity";
+import module namespace set = "http://zorba.io/modules/data-cleaning/set-similarity";
 
 set:dice ( ( "a", "b", <c/> ) , ( "a", "a", "d") )

=== modified file 'test/Queries/data-cleaning/set-similarity/distinct.xq'
--- test/Queries/data-cleaning/set-similarity/distinct.xq	2011-07-19 19:12:03 +0000
+++ test/Queries/data-cleaning/set-similarity/distinct.xq	2013-07-10 00:51:26 +0000
@@ -1,3 +1,3 @@
-import module namespace set = "http://www.zorba-xquery.com/modules/data-cleaning/set-similarity";
+import module namespace set = "http://zorba.io/modules/data-cleaning/set-similarity";
 
 set:distinct (( "a", "a", <b/> ))

=== modified file 'test/Queries/data-cleaning/set-similarity/jaccard.xq'
--- test/Queries/data-cleaning/set-similarity/jaccard.xq	2011-07-19 19:12:03 +0000
+++ test/Queries/data-cleaning/set-similarity/jaccard.xq	2013-07-10 00:51:26 +0000
@@ -1,3 +1,3 @@
-import module namespace set = "http://www.zorba-xquery.com/modules/data-cleaning/set-similarity";
+import module namespace set = "http://zorba.io/modules/data-cleaning/set-similarity";
 
 set:jaccard ( ( "a", "b", <c/> ) , ( "a", "a", "d") )

=== modified file 'test/Queries/data-cleaning/set-similarity/overlap.xq'
--- test/Queries/data-cleaning/set-similarity/overlap.xq	2011-07-19 19:12:03 +0000
+++ test/Queries/data-cleaning/set-similarity/overlap.xq	2013-07-10 00:51:26 +0000
@@ -1,3 +1,3 @@
-import module namespace set = "http://www.zorba-xquery.com/modules/data-cleaning/set-similarity";
+import module namespace set = "http://zorba.io/modules/data-cleaning/set-similarity";
 
 set:overlap ( ( "a", "b", <c/> ) , ( "a", "a", "b" ) )

=== modified file 'test/Queries/data-cleaning/token-based-string-similarity/cosine-ngrams.xq'
--- test/Queries/data-cleaning/token-based-string-similarity/cosine-ngrams.xq	2011-07-19 19:12:03 +0000
+++ test/Queries/data-cleaning/token-based-string-similarity/cosine-ngrams.xq	2013-07-10 00:51:26 +0000
@@ -1,3 +1,3 @@
-import module namespace simt = "http://www.zorba-xquery.com/modules/data-cleaning/token-based-string-similarity";
+import module namespace simt = "http://zorba.io/modules/data-cleaning/token-based-string-similarity";
 
 simt:cosine-ngrams("DWAYNE", "DUANE", 2 )

=== modified file 'test/Queries/data-cleaning/token-based-string-similarity/cosine-tokens.xq'
--- test/Queries/data-cleaning/token-based-string-similarity/cosine-tokens.xq	2011-07-19 19:12:03 +0000
+++ test/Queries/data-cleaning/token-based-string-similarity/cosine-tokens.xq	2013-07-10 00:51:26 +0000
@@ -1,3 +1,3 @@
-import module namespace simt = "http://www.zorba-xquery.com/modules/data-cleaning/token-based-string-similarity";
+import module namespace simt = "http://zorba.io/modules/data-cleaning/token-based-string-similarity";
 
 simt:cosine-tokens("The FLWOR Foundation", "FLWOR Found.", " +" )

=== modified file 'test/Queries/data-cleaning/token-based-string-similarity/cosine.xq'
--- test/Queries/data-cleaning/token-based-string-similarity/cosine.xq	2011-07-19 19:12:03 +0000
+++ test/Queries/data-cleaning/token-based-string-similarity/cosine.xq	2013-07-10 00:51:26 +0000
@@ -1,3 +1,3 @@
-import module namespace simt = "http://www.zorba-xquery.com/modules/data-cleaning/token-based-string-similarity";
+import module namespace simt = "http://zorba.io/modules/data-cleaning/token-based-string-similarity";
 
 simt:cosine( ("aa","bb") , ("bb","aa"))

=== modified file 'test/Queries/data-cleaning/token-based-string-similarity/dice-ngrams.xq'
--- test/Queries/data-cleaning/token-based-string-similarity/dice-ngrams.xq	2011-07-19 19:12:03 +0000
+++ test/Queries/data-cleaning/token-based-string-similarity/dice-ngrams.xq	2013-07-10 00:51:26 +0000
@@ -1,3 +1,3 @@
-import module namespace simt = "http://www.zorba-xquery.com/modules/data-cleaning/token-based-string-similarity";
+import module namespace simt = "http://zorba.io/modules/data-cleaning/token-based-string-similarity";
 
 simt:dice-ngrams("DWAYNE", "DUANE", 2 )

=== modified file 'test/Queries/data-cleaning/token-based-string-similarity/dice-tokens.xq'
--- test/Queries/data-cleaning/token-based-string-similarity/dice-tokens.xq	2011-07-19 19:12:03 +0000
+++ test/Queries/data-cleaning/token-based-string-similarity/dice-tokens.xq	2013-07-10 00:51:26 +0000
@@ -1,3 +1,3 @@
-import module namespace simt = "http://www.zorba-xquery.com/modules/data-cleaning/token-based-string-similarity";
+import module namespace simt = "http://zorba.io/modules/data-cleaning/token-based-string-similarity";
 
 simt:dice-tokens("The FLWOR Foundation", "FLWOR Found.", " +" )

=== modified file 'test/Queries/data-cleaning/token-based-string-similarity/jaccard-ngrams.xq'
--- test/Queries/data-cleaning/token-based-string-similarity/jaccard-ngrams.xq	2011-07-19 19:12:03 +0000
+++ test/Queries/data-cleaning/token-based-string-similarity/jaccard-ngrams.xq	2013-07-10 00:51:26 +0000
@@ -1,3 +1,3 @@
-import module namespace simt = "http://www.zorba-xquery.com/modules/data-cleaning/token-based-string-similarity";
+import module namespace simt = "http://zorba.io/modules/data-cleaning/token-based-string-similarity";
 
 simt:jaccard-ngrams("DWAYNE", "DUANE", 2 )

=== modified file 'test/Queries/data-cleaning/token-based-string-similarity/jaccard-tokens.xq'
--- test/Queries/data-cleaning/token-based-string-similarity/jaccard-tokens.xq	2011-07-19 19:12:03 +0000
+++ test/Queries/data-cleaning/token-based-string-similarity/jaccard-tokens.xq	2013-07-10 00:51:26 +0000
@@ -1,3 +1,3 @@
-import module namespace simt = "http://www.zorba-xquery.com/modules/data-cleaning/token-based-string-similarity";
+import module namespace simt = "http://zorba.io/modules/data-cleaning/token-based-string-similarity";
 
 simt:jaccard-tokens("The FLWOR Foundation", "FLWOR Found.", " +" )

=== modified file 'test/Queries/data-cleaning/token-based-string-similarity/ngrams.xq'
--- test/Queries/data-cleaning/token-based-string-similarity/ngrams.xq	2011-07-19 19:12:03 +0000
+++ test/Queries/data-cleaning/token-based-string-similarity/ngrams.xq	2013-07-10 00:51:26 +0000
@@ -1,3 +1,3 @@
-import module namespace simt = "http://www.zorba-xquery.com/modules/data-cleaning/token-based-string-similarity";
+import module namespace simt = "http://zorba.io/modules/data-cleaning/token-based-string-similarity";
 
 simt:ngrams("FLWOR", 2 )

=== modified file 'test/Queries/data-cleaning/token-based-string-similarity/overlap-ngrams.xq'
--- test/Queries/data-cleaning/token-based-string-similarity/overlap-ngrams.xq	2011-07-19 19:12:03 +0000
+++ test/Queries/data-cleaning/token-based-string-similarity/overlap-ngrams.xq	2013-07-10 00:51:26 +0000
@@ -1,3 +1,3 @@
-import module namespace simt = "http://www.zorba-xquery.com/modules/data-cleaning/token-based-string-similarity";
+import module namespace simt = "http://zorba.io/modules/data-cleaning/token-based-string-similarity";
 
 simt:overlap-ngrams("DWAYNE", "DUANE", 2 )

=== modified file 'test/Queries/data-cleaning/token-based-string-similarity/overlap-tokens.xq'
--- test/Queries/data-cleaning/token-based-string-similarity/overlap-tokens.xq	2011-07-19 19:12:03 +0000
+++ test/Queries/data-cleaning/token-based-string-similarity/overlap-tokens.xq	2013-07-10 00:51:26 +0000
@@ -1,3 +1,3 @@
-import module namespace simt = "http://www.zorba-xquery.com/modules/data-cleaning/token-based-string-similarity";
+import module namespace simt = "http://zorba.io/modules/data-cleaning/token-based-string-similarity";
 
 simt:overlap-tokens("The FLWOR Foundation", "FLWOR Found.", " +" )