Hyperdonat

<!--

 ********************************

 The FunctX XSLT Function Library

 ********************************

 Copyright (C) 2007 Datypic

 This library is free software; you can redistribute it and/or

 modify it under the terms of the GNU Lesser General Public

 License as published by the Free Software Foundation; either

 version 2.1 of the License.

 This library is distributed in the hope that it will be useful,

 but WITHOUT ANY WARRANTY; without even the implied warranty of

 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 Lesser General Public License for more details.

 You should have received a copy of the GNU Lesser General Public

 License along with this library; if not, write to the Free Software

 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

 For more information on the FunctX XSLT library, contact contrib@functx.com.

 @version 1.0

 @see     http://www.xsltfunctions.com

-->

<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"

                xmlns:dxmlf="http://www.datypic.com/xmlf"

                xmlns:xs="http://www.w3.org/2001/XMLSchema"

                xmlns:fn="http://www.w3.org/2005/xpath-functions"

                xmlns:local="http://www.datypic.com/local"

                 xmlns:functx="http://www.functx.com"

                exclude-result-prefixes="dxmlf xs" version="2.0">

<!--

  Adds attributes to XML elements

 @author  Priscilla Walmsley, Datypic

 @version 1.0

 @see     http://www.xsltfunctions.com/xsl/functx_add-attributes.html

 @param   $elements the element(s) to which you wish to add the attribute

 @param   $attrNames the name(s) of the attribute(s) to add

 @param   $attrValues the value(s) of the attribute(s) to add

-->

<xsl:function name="functx:add-attributes" as="element()?"

              xmlns:functx="http://www.functx.com" >

  <xsl:param name="elements" as="element()*"/>

  <xsl:param name="attrNames" as="xs:QName*"/>

  <xsl:param name="attrValues" as="xs:anyAtomicType*"/>

  <xsl:for-each select="$elements">

    <xsl:variable name="element" select="."/>

    <xsl:copy>

      <xsl:for-each select="$attrNames">

        <xsl:variable name="seq" select="position()"/>

        <xsl:if test="not($element/@*[node-name(.) = current()])">

          <xsl:attribute name="{.}"

                         namespace="{namespace-uri-from-QName(.)}"

                         select="$attrValues[$seq]"/>

        </xsl:if>

      </xsl:for-each>

      <xsl:copy-of select="@*|node()"/>

    </xsl:copy>

  </xsl:for-each>

</xsl:function>

<!--

  Adds months to a date

 @author  Priscilla Walmsley, Datypic

 @version 1.0

 @see     http://www.xsltfunctions.com/xsl/functx_add-months.html

 @param   $date the date

 @param   $months the number of months to add

-->

<xsl:function name="functx:add-months" as="xs:date?"

              xmlns:functx="http://www.functx.com" >

  <xsl:param name="date" as="xs:anyAtomicType?"/>

  <xsl:param name="months" as="xs:integer"/>

  <xsl:sequence select="

   xs:date($date) + functx:yearMonthDuration(0,$months)

 "/>

</xsl:function>

<!--

  Adds attributes to XML elements

 @author  Priscilla Walmsley, Datypic

 @version 1.0

 @see     http://www.xsltfunctions.com/xsl/functx_add-or-update-attributes.html

 @param   $elements the element(s) to which you wish to add the attribute

 @param   $attrNames the name(s) of the attribute(s) to add

 @param   $attrValues the value(s) of the attribute(s) to add

-->

<xsl:function name="functx:add-or-update-attributes" as="element()?"

              xmlns:functx="http://www.functx.com" >

  <xsl:param name="elements" as="element()*"/>

  <xsl:param name="attrNames" as="xs:QName*"/>

  <xsl:param name="attrValues" as="xs:anyAtomicType*"/>

  <xsl:for-each select="$elements">

    <xsl:copy>

      <xsl:for-each select="$attrNames">

        <xsl:variable name="seq" select="position()"/>

        <xsl:attribute name="{.}"

                       namespace="{namespace-uri-from-QName(.)}"

                       select="$attrValues[$seq]"/>

      </xsl:for-each>

      <xsl:copy-of select="@*[not(node-name(.) = $attrNames)]|node()"/>

    </xsl:copy>

  </xsl:for-each>

</xsl:function>

<!--

  Whether a value is all whitespace or a zero-length string

 @author  Priscilla Walmsley, Datypic

 @version 1.0

 @see     http://www.xsltfunctions.com/xsl/functx_all-whitespace.html

 @param   $arg the string (or node) to test

-->

<xsl:function name="functx:all-whitespace" as="xs:boolean"

              xmlns:functx="http://www.functx.com" >

  <xsl:param name="arg" as="xs:string?"/>

  <xsl:sequence select="

   normalize-space($arg) = ''

 "/>

</xsl:function>

<!--

  Whether all the values in a sequence are distinct

 @author  Priscilla Walmsley, Datypic

 @version 1.0

 @see     http://www.xsltfunctions.com/xsl/functx_are-distinct-values.html

 @param   $seq the sequence of values

-->

<xsl:function name="functx:are-distinct-values" as="xs:boolean"

              xmlns:functx="http://www.functx.com" >

  <xsl:param name="seq" as="xs:anyAtomicType*"/>

  <xsl:sequence select="

   count(distinct-values($seq)) = count($seq)

 "/>

</xsl:function>

<!--

  The built-in type of an atomic value

 @author  Priscilla Walmsley, Datypic

 @version 1.0

 @see     http://www.xsltfunctions.com/xsl/functx_atomic-type.html

 @param   $values the value(s) whose type you want to determine

-->

<xsl:function name="functx:atomic-type" as="xs:string*"

              xmlns:functx="http://www.functx.com" >

  <xsl:param name="values" as="xs:anyAtomicType*"/>

  <xsl:sequence select="

 for $val in $values

 return

 (if ($val instance of xs:untypedAtomic) then 'xs:untypedAtomic'

 else if ($val instance of xs:anyURI) then 'xs:anyURI'

 else if ($val instance of xs:string) then 'xs:string'

 else if ($val instance of xs:QName) then 'xs:QName'

 else if ($val instance of xs:boolean) then 'xs:boolean'

 else if ($val instance of xs:base64Binary) then 'xs:base64Binary'

 else if ($val instance of xs:hexBinary) then 'xs:hexBinary'

 else if ($val instance of xs:integer) then 'xs:integer'

 else if ($val instance of xs:decimal) then 'xs:decimal'

 else if ($val instance of xs:float) then 'xs:float'

 else if ($val instance of xs:double) then 'xs:double'

 else if ($val instance of xs:date) then 'xs:date'

 else if ($val instance of xs:time) then 'xs:time'

 else if ($val instance of xs:dateTime) then 'xs:dateTime'

 else if ($val instance of xs:dayTimeDuration)

         then 'xs:dayTimeDuration'

 else if ($val instance of xs:yearMonthDuration)

         then 'xs:yearMonthDuration'

 else if ($val instance of xs:duration) then 'xs:duration'

 else if ($val instance of xs:gMonth) then 'xs:gMonth'

 else if ($val instance of xs:gYear) then 'xs:gYear'

 else if ($val instance of xs:gYearMonth) then 'xs:gYearMonth'

 else if ($val instance of xs:gDay) then 'xs:gDay'

 else if ($val instance of xs:gMonthDay) then 'xs:gMonthDay'

 else 'unknown')

 "/>

</xsl:function>

<!--

  The average, counting "empty" values as zero

 @author  Priscilla Walmsley, Datypic

 @version 1.0

 @see     http://www.xsltfunctions.com/xsl/functx_avg-empty-is-zero.html

 @param   $values the values to be averaged

 @param   $allNodes the sequence of all nodes to find the average over

-->

<xsl:function name="functx:avg-empty-is-zero" as="xs:double"

              xmlns:functx="http://www.functx.com" >

  <xsl:param name="values" as="xs:anyAtomicType*"/>

  <xsl:param name="allNodes" as="node()*"/>

  <xsl:sequence select="

   if (empty($allNodes))

   then 0

   else sum($values[string(.) != '']) div count($allNodes)

 "/>

</xsl:function>

<!--

  Whether a value is between two provided values

 @author  Priscilla Walmsley, Datypic

 @version 1.0

 @see     http://www.xsltfunctions.com/xsl/functx_between-exclusive.html

 @param   $value the value to be tested

 @param   $minValue the minimum value

 @param   $maxValue the maximum value

-->

<xsl:function name="functx:between-exclusive" as="xs:boolean"

              xmlns:functx="http://www.functx.com" >

  <xsl:param name="value" as="xs:anyAtomicType?"/>

  <xsl:param name="minValue" as="xs:anyAtomicType"/>

  <xsl:param name="maxValue" as="xs:anyAtomicType"/>

  <xsl:sequence select="

   $value > $minValue and $value < $maxValue

 "/>

</xsl:function>

<!--

  Whether a value is between two provided values, or equal to one of them

 @author  Priscilla Walmsley, Datypic

 @version 1.0

 @see     http://www.xsltfunctions.com/xsl/functx_between-inclusive.html

 @param   $value the value to be tested

 @param   $minValue the minimum value

 @param   $maxValue the maximum value

-->

<xsl:function name="functx:between-inclusive" as="xs:boolean"

              xmlns:functx="http://www.functx.com" >

  <xsl:param name="value" as="xs:anyAtomicType?"/>

  <xsl:param name="minValue" as="xs:anyAtomicType"/>

  <xsl:param name="maxValue" as="xs:anyAtomicType"/>

  <xsl:sequence select="

   $value >= $minValue and $value <= $maxValue

 "/>

</xsl:function>

<!--

  Turns a camelCase string into space-separated words

 @author  Priscilla Walmsley, Datypic

 @version 1.0

 @see     http://www.xsltfunctions.com/xsl/functx_camel-case-to-words.html

 @param   $arg the string to modify

 @param   $delim the delimiter for the words (e.g. a space)

-->

<xsl:function name="functx:camel-case-to-words" as="xs:string"

              xmlns:functx="http://www.functx.com" >

  <xsl:param name="arg" as="xs:string?"/>

  <xsl:param name="delim" as="xs:string"/>

  <xsl:sequence select="

   concat(substring($arg,1,1),

             replace(substring($arg,2),'(\p{Lu})',

                        concat($delim, '$1')))

 "/>

</xsl:function>

<!--

  Capitalizes the first character of a string

 @author  Priscilla Walmsley, Datypic

 @version 1.0

 @see     http://www.xsltfunctions.com/xsl/functx_capitalize-first.html

 @param   $arg the word or phrase to capitalize

-->

<xsl:function name="functx:capitalize-first" as="xs:string?"

              xmlns:functx="http://www.functx.com" >

  <xsl:param name="arg" as="xs:string?"/>

  <xsl:sequence select="

   concat(upper-case(substring($arg,1,1)),

             substring($arg,2))

 "/>

</xsl:function>

<!--

  Changes the names of elements in an XML fragment

 @author  Priscilla Walmsley, Datypic

 @version 1.0

 @see     http://www.xsltfunctions.com/xsl/functx_change-element-names-deep.html

 @param   $nodes the element(s) to change

 @param   $oldNames the sequence of names to change from

 @param   $newNames the sequence of names to change to

-->

<xsl:function name="functx:change-element-names-deep" as="node()*"

              xmlns:functx="http://www.functx.com" >

  <xsl:param name="nodes" as="node()*"/>

  <xsl:param name="oldNames" as="xs:QName*"/>

  <xsl:param name="newNames" as="xs:QName*"/>

  <xsl:if test="count($oldNames) != count($newNames)">

    <xsl:sequence select="error(

         xs:QName('functx:Different_number_of_names'))"/>

  </xsl:if>

  <xsl:for-each select="$nodes">

    <xsl:variable name="node" select="."/>

    <xsl:choose>

      <xsl:when test="$node instance of element()">

        <xsl:variable name="theName"

                      select="functx:if-empty

                    ($newNames[index-of($oldNames, node-name($node))],

                     node-name($node))"/>

        <xsl:element name="{$theName}"

                     namespace="{namespace-uri-from-QName($theName)}" >

           <xsl:sequence select="($node/@*,

                  functx:change-element-names-deep($node/node(),

                                           $oldNames, $newNames))"/>

        </xsl:element>

      </xsl:when>

      <xsl:when test="$node instance of document-node()">

        <xsl:document>

           <xsl:sequence select="functx:change-element-names-deep(

                $node/node(), $oldNames, $newNames)"/>

        </xsl:document>

      </xsl:when>

      <xsl:otherwise>

        <xsl:sequence select="$node"/>

      </xsl:otherwise>

    </xsl:choose>

  </xsl:for-each>

</xsl:function>

<!--

  Changes the namespace of XML elements and its descendants

 @author  Priscilla Walmsley, Datypic

 @version 1.0

 @see     http://www.xsltfunctions.com/xsl/functx_change-element-ns-deep.html

 @param   $nodes the nodes to change

 @param   $newns the new namespace

 @param   $prefix the prefix to use for the new namespace

-->

<xsl:function name="functx:change-element-ns-deep" as="node()*"

              xmlns:functx="http://www.functx.com" >

  <xsl:param name="nodes" as="node()*"/>

  <xsl:param name="newns" as="xs:string"/>

  <xsl:param name="prefix" as="xs:string"/>

  <xsl:for-each select="$nodes">

    <xsl:variable name="node" select="."/>

    <xsl:choose>

      <xsl:when test="$node instance of element()">

        <xsl:element name="{concat($prefix,

                                    if ($prefix = '')

                                    then ''

                                    else ':',

                                    local-name($node))}"

                     namespace="{$newns}">

          <xsl:sequence select="($node/@*,

                functx:change-element-ns-deep($node/node(),

                                           $newns, $prefix))"/>

        </xsl:element>

      </xsl:when>

      <xsl:when test="$node instance of document-node()">

        <xsl:document>

          <xsl:sequence select="functx:change-element-ns-deep(

                $node/node(), $newns, $prefix)"/>

        </xsl:document>

      </xsl:when>

      <xsl:otherwise>

        <xsl:sequence select="$node"/>

      </xsl:otherwise>

   </xsl:choose>

  </xsl:for-each>

</xsl:function>

<!--

  Changes the namespace of XML elements

 @author  Priscilla Walmsley, Datypic

 @version 1.0

 @see     http://www.xsltfunctions.com/xsl/functx_change-element-ns.html

 @param   $elements the elements to change

 @param   $newns the new namespace

 @param   $prefix the prefix to use for the new namespace

-->

<xsl:function name="functx:change-element-ns" as="element()?"

              xmlns:functx="http://www.functx.com" >

  <xsl:param name="elements" as="element()*"/>

  <xsl:param name="newns" as="xs:string"/>

  <xsl:param name="prefix" as="xs:string"/>

   <xsl:for-each select="$elements">

     <xsl:variable name="element" select="."/>

     <xsl:element name="{concat($prefix,

                                    if ($prefix = '')

                                    then ''

                                    else ':',

                                    local-name($element))}"

                     namespace="{$newns}">

       <xsl:sequence select="$element/@*, $element/node()"/>

     </xsl:element>

   </xsl:for-each>

</xsl:function>

<!--

  Converts a string to a sequence of characters

 @author  Priscilla Walmsley, Datypic

 @version 1.0

 @see     http://www.xsltfunctions.com/xsl/functx_chars.html

 @param   $arg the string to split

-->

<xsl:function name="functx:chars" as="xs:string*"

              xmlns:functx="http://www.functx.com" >

  <xsl:param name="arg" as="xs:string?"/>

  <xsl:sequence select="

   for $ch in string-to-codepoints($arg)

   return codepoints-to-string($ch)

 "/>

</xsl:function>

<!--

  Whether a string contains any of a sequence of strings

 @author  Priscilla Walmsley, Datypic

 @version 1.0

 @see     http://www.xsltfunctions.com/xsl/functx_contains-any-of.html

 @param   $arg the string to test

 @param   $searchStrings the strings to look for

-->

<xsl:function name="functx:contains-any-of" as="xs:boolean"

              xmlns:functx="http://www.functx.com" >

  <xsl:param name="arg" as="xs:string?"/>

  <xsl:param name="searchStrings" as="xs:string*"/>

  <xsl:sequence select="

   some $searchString in $searchStrings

   satisfies contains($arg,$searchString)

 "/>

</xsl:function>

<!--

  Whether one string contains another, without regard to case

 @author  Priscilla Walmsley, Datypic

 @version 1.0

 @see     http://www.xsltfunctions.com/xsl/functx_contains-case-insensitive.html

 @param   $arg the string to search

 @param   $substring the substring to find

-->

<xsl:function name="functx:contains-case-insensitive" as="xs:boolean?"

              xmlns:functx="http://www.functx.com" >

  <xsl:param name="arg" as="xs:string?"/>

  <xsl:param name="substring" as="xs:string"/>

  <xsl:sequence select="

   contains(upper-case($arg), upper-case($substring))

 "/>

</xsl:function>

<!--

  Whether one string contains another, as a separate word

 @author  Priscilla Walmsley, Datypic

 @version 1.0

 @see     http://www.xsltfunctions.com/xsl/functx_contains-word.html

 @param   $arg the string to search

 @param   $word the word to find

-->

<xsl:function name="functx:contains-word" as="xs:boolean"

              xmlns:functx="http://www.functx.com" >

  <xsl:param name="arg" as="xs:string?"/>

  <xsl:param name="word" as="xs:string"/>

  <xsl:sequence select="

   matches(upper-case($arg),

           concat('^(.*\W)?',

                     upper-case(functx:escape-for-regex($word)),

                     '(\W.*)?$'))

 "/>

</xsl:function>

<!--

  Copies attributes from one element to another

 @author  Priscilla Walmsley, Datypic

 @version 1.0

 @see     http://www.xsltfunctions.com/xsl/functx_copy-attributes.html

 @param   $copyTo the element to copy attributes to

 @param   $copyFrom the element to copy attributes from

-->

<xsl:function name="functx:copy-attributes" as="element()"

              xmlns:functx="http://www.functx.com" >

  <xsl:param name="copyTo" as="element()"/>

  <xsl:param name="copyFrom" as="element()"/>

  <xsl:element name="{node-name($copyTo)}">

    <xsl:sequence select="

       ($copyTo/@*[not(node-name(.) = $copyFrom/@*/node-name(.))],

        $copyFrom/@*,

        $copyTo/node())"/>

  </xsl:element>

</xsl:function>

<!--

  Construct a date from a year, month and day

 @author  Priscilla Walmsley, Datypic

 @version 1.0

 @see     http://www.xsltfunctions.com/xsl/functx_date.html

 @param   $year the year

 @param   $month the month

 @param   $day the day

-->

<xsl:function name="functx:date" as="xs:date"

              xmlns:functx="http://www.functx.com" >

  <xsl:param name="year" as="xs:anyAtomicType"/>

  <xsl:param name="month" as="xs:anyAtomicType"/>

  <xsl:param name="day" as="xs:anyAtomicType"/>

  <xsl:sequence select="

   xs:date(

     concat(

       functx:pad-integer-to-length(xs:integer($year),4),'-',

       functx:pad-integer-to-length(xs:integer($month),2),'-',

       functx:pad-integer-to-length(xs:integer($day),2)))

 "/>

</xsl:function>

<!--

  Construct a date/time from individual components

 @author  Priscilla Walmsley, Datypic

 @version 1.0

 @see     http://www.xsltfunctions.com/xsl/functx_datetime.html

 @param   $year the year

 @param   $month the month

 @param   $day the day

 @param   $hour the hour

 @param   $minute the minute

 @param   $second the second

-->

<xsl:function name="functx:dateTime" as="xs:dateTime"

              xmlns:functx="http://www.functx.com" >

  <xsl:param name="year" as="xs:anyAtomicType"/>

  <xsl:param name="month" as="xs:anyAtomicType"/>

  <xsl:param name="day" as="xs:anyAtomicType"/>

  <xsl:param name="hour" as="xs:anyAtomicType"/>

  <xsl:param name="minute" as="xs:anyAtomicType"/>

  <xsl:param name="second" as="xs:anyAtomicType"/>

  <xsl:sequence select="

   xs:dateTime(

     concat(functx:date($year,$month,$day),'T',

             functx:time($hour,$minute,$second)))

 "/>

</xsl:function>

<!--

  The day of the year (a number between 1 and 366)

 @author  Priscilla Walmsley, Datypic

 @version 1.0

 @see     http://www.xsltfunctions.com/xsl/functx_day-in-year.html

 @param   $date the date

-->

<xsl:function name="functx:day-in-year" as="xs:integer?"

              xmlns:functx="http://www.functx.com" >

  <xsl:param name="date" as="xs:anyAtomicType?"/>

  <xsl:sequence select="

  days-from-duration(

      xs:date($date) - functx:first-day-of-year($date)) + 1

 "/>

</xsl:function>

<!--

  The abbreviated day of the week, from a date, in English

 @author  Priscilla Walmsley, Datypic

 @version 1.0

 @see     http://www.xsltfunctions.com/xsl/functx_day-of-week-abbrev-en.html

 @param   $date the date

-->

<xsl:function name="functx:day-of-week-abbrev-en" as="xs:string?"

              xmlns:functx="http://www.functx.com" >

  <xsl:param name="date" as="xs:anyAtomicType?"/>

  <xsl:sequence select="

   ('Sun', 'Mon', 'Tues', 'Wed', 'Thurs', 'Fri', 'Sat')

   [functx:day-of-week($date) + 1]

 "/>

</xsl:function>

<!--

  The name of the day of the week, from a date, in English

 @author  Priscilla Walmsley, Datypic

 @version 1.0

 @see     http://www.xsltfunctions.com/xsl/functx_day-of-week-name-en.html

 @param   $date the date

-->

<xsl:function name="functx:day-of-week-name-en" as="xs:string?"

              xmlns:functx="http://www.functx.com" >

  <xsl:param name="date" as="xs:anyAtomicType?"/>

  <xsl:sequence select="

   ('Sunday', 'Monday', 'Tuesday', 'Wednesday',

    'Thursday', 'Friday', 'Saturday')

      [functx:day-of-week($date) + 1]

 "/>

</xsl:function>

<!--

  The day of the week, from a date

 @author  Priscilla Walmsley, Datypic

 @version 1.0

 @see     http://www.xsltfunctions.com/xsl/functx_day-of-week.html

 @param   $date the date

-->

<xsl:function name="functx:day-of-week" as="xs:integer?"

              xmlns:functx="http://www.functx.com" >

  <xsl:param name="date" as="xs:anyAtomicType?"/>

  <xsl:sequence select="

  if (empty($date))

  then ()

  else xs:integer((xs:date($date) - xs:date('1901-01-06'))

          div xs:dayTimeDuration('P1D')) mod 7

 "/>

</xsl:function>

<!--

  Construct a dayTimeDuration from a number of days, hours, etc.

 @author  Priscilla Walmsley, Datypic

 @version 1.0

 @see     http://www.xsltfunctions.com/xsl/functx_daytimeduration.html

 @param   $days the number of days

 @param   $hours the number of hours

 @param   $minutes the number of minutes

 @param   $seconds the number of seconds

-->

<xsl:function name="functx:dayTimeDuration" as="xs:dayTimeDuration"

              xmlns:functx="http://www.functx.com" >

  <xsl:param name="days" as="xs:decimal?"/>

  <xsl:param name="hours" as="xs:decimal?"/>

  <xsl:param name="minutes" as="xs:decimal?"/>

  <xsl:param name="seconds" as="xs:decimal?"/>

  <xsl:sequence select="

    (xs:dayTimeDuration('P1D') * functx:if-empty($days,0)) +

    (xs:dayTimeDuration('PT1H') * functx:if-empty($hours,0)) +

    (xs:dayTimeDuration('PT1M') * functx:if-empty($minutes,0)) +

    (xs:dayTimeDuration('PT1S') * functx:if-empty($seconds,0))

 "/>

</xsl:function>

<!--

  Number of days in the month

 @author  Priscilla Walmsley, Datypic

 @version 1.0

 @see     http://www.xsltfunctions.com/xsl/functx_days-in-month.html

 @param   $date the date

-->

<xsl:function name="functx:days-in-month" as="xs:integer?"

              xmlns:functx="http://www.functx.com" >

  <xsl:param name="date" as="xs:anyAtomicType?"/>

  <xsl:sequence select="

   if (month-from-date(xs:date($date)) = 2 and

       functx:is-leap-year($date))

   then 29

   else

   (31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31)

    [month-from-date(xs:date($date))]

 "/>

</xsl:function>

<!--

  The depth (level) of a node in an XML tree

 @author  Priscilla Walmsley, Datypic

 @version 1.0

 @see     http://www.xsltfunctions.com/xsl/functx_depth-of-node.html

 @param   $node the node to check

-->

<xsl:function name="functx:depth-of-node" as="xs:integer"

              xmlns:functx="http://www.functx.com" >

  <xsl:param name="node" as="node()?"/>

  <xsl:sequence select="

   count($node/ancestor-or-self::node())

 "/>

</xsl:function>

<!--

  The distinct names of all attributes in an XML fragment

 @author  Priscilla Walmsley, Datypic

 @version 1.0

 @see     http://www.xsltfunctions.com/xsl/functx_distinct-attribute-names.html

 @param   $nodes the root to start from

-->

<xsl:function name="functx:distinct-attribute-names" as="xs:string*"

              xmlns:functx="http://www.functx.com" >

  <xsl:param name="nodes" as="node()*"/>

  <xsl:sequence select="

   distinct-values($nodes//@*/name(.))

 "/>

</xsl:function>

<!--

  The XML nodes with distinct values, taking into account attributes and descendants

 @author  Priscilla Walmsley, Datypic

 @version 1.0

 @see     http://www.xsltfunctions.com/xsl/functx_distinct-deep.html

 @param   $nodes the sequence of nodes to test

-->

<xsl:function name="functx:distinct-deep" as="node()*"

              xmlns:functx="http://www.functx.com" >

  <xsl:param name="nodes" as="node()*"/>

  <xsl:sequence select="

    for $seq in (1 to count($nodes))

    return $nodes[$seq][not(functx:is-node-in-sequence-deep-equal(

                          .,$nodes[position() < $seq]))]

 "/>

</xsl:function>

<!--

  The distinct names of all elements in an XML fragment

 @author  Priscilla Walmsley, Datypic

 @version 1.0

 @see     http://www.xsltfunctions.com/xsl/functx_distinct-element-names.html

 @param   $nodes the root(s) to start from

-->

<xsl:function name="functx:distinct-element-names" as="xs:string*"

              xmlns:functx="http://www.functx.com" >

  <xsl:param name="nodes" as="node()*"/>

  <xsl:sequence select="

   distinct-values($nodes/descendant-or-self::*/name(.))

 "/>

</xsl:function>

<!--

  The distinct paths of all descendant elements in an XML fragment

 @author  Priscilla Walmsley, Datypic

 @version 1.0

 @see     http://www.xsltfunctions.com/xsl/functx_distinct-element-paths.html

 @param   $nodes the root(s) to start from

-->

<xsl:function name="functx:distinct-element-paths" as="xs:string*"

              xmlns:functx="http://www.functx.com" >

  <xsl:param name="nodes" as="node()*"/>

  <xsl:sequence select="

   distinct-values(functx:path-to-node($nodes/descendant-or-self::*))

 "/>

</xsl:function>

<!--

  The distinct XML nodes in a sequence (by node identity)

 @author  Priscilla Walmsley, Datypic

 @version 1.0

 @see     http://www.xsltfunctions.com/xsl/functx_distinct-nodes.html

 @param   $nodes the node sequence

-->

<xsl:function name="functx:distinct-nodes" as="node()*"

              xmlns:functx="http://www.functx.com" >

  <xsl:param name="nodes" as="node()*"/>

  <xsl:sequence select="

    for $seq in (1 to count($nodes))

    return $nodes[$seq][not(functx:is-node-in-sequence(

                                .,$nodes[position() < $seq]))]

 "/>

</xsl:function>

<!--

  Converts a timezone like "-05:00" or "Z" into xs:dayTimeDuration

 @author  Priscilla Walmsley, Datypic

 @version 1.0

 @see     http://www.xsltfunctions.com/xsl/functx_duration-from-timezone.html

 @param   $timezone the time zone, in (+|-)HH:MM format

-->

<xsl:function name="functx:duration-from-timezone" as="xs:dayTimeDuration"

              xmlns:functx="http://www.functx.com" >

  <xsl:param name="timezone" as="xs:string"/>

  <xsl:sequence select="

   xs:dayTimeDuration(

     if (not(matches($timezone,'Z|[\+\-]\d{2}:\d{2}')))

     then error(xs:QName('functx:Invalid_Timezone_Value'))

     else if ($timezone = 'Z')

     then 'PT0S'

     else replace($timezone,'\+?(\d{2}):\d{2}','PT$1H')

        )

 "/>

</xsl:function>

<!--

  Dynamically evaluates a simple XPath path

 @author  Priscilla Walmsley, Datypic

 @version 1.0

 @see     http://www.xsltfunctions.com/xsl/functx_dynamic-path.html

 @param   $parent the root to start from

 @param   $path the path expression

-->

<xsl:function name="functx:dynamic-path" as="item()*"

              xmlns:functx="http://www.functx.com" >

  <xsl:param name="parent" as="node()"/>

  <xsl:param name="path" as="xs:string"/>

  <xsl:variable name="nextStep"

        select="functx:substring-before-if-contains($path,'/')"/>

  <xsl:variable name="restOfSteps"

        select="substring-after($path,'/')"/>

  <xsl:for-each select="

    ($parent/*[functx:name-test(name(),$nextStep)],

     $parent/@*[functx:name-test(name(),

                              substring-after($nextStep,'@'))])">

    <xsl:variable name="child" select="."/>

    <xsl:sequence select="if ($restOfSteps)

         then functx:dynamic-path($child, $restOfSteps)

         else $child"/>

  </xsl:for-each>

</xsl:function>

<!--

  Escapes regex special characters

 @author  Priscilla Walmsley, Datypic

 @version 1.0

 @see     http://www.xsltfunctions.com/xsl/functx_escape-for-regex.html

 @param   $arg the string to escape

-->

<xsl:function name="functx:escape-for-regex" as="xs:string"

              xmlns:functx="http://www.functx.com" >

  <xsl:param name="arg" as="xs:string?"/>

  <xsl:sequence select="

   replace($arg,

           '(\.|\[|\]|\\|\||\-|\^|\$|\?|\*|\+|\{|\}|\(|\))','\\$1')

 "/>

</xsl:function>

<!--

  Whether one (and only one) of two boolean values is true

 @author  Priscilla Walmsley, Datypic

 @version 1.0

 @see     http://www.xsltfunctions.com/xsl/functx_exclusive-or.html

 @param   $arg1 the first boolean value

 @param   $arg2 the second boolean value

-->

<xsl:function name="functx:exclusive-or" as="xs:boolean?"

              xmlns:functx="http://www.functx.com" >

  <xsl:param name="arg1" as="xs:boolean?"/>

  <xsl:param name="arg2" as="xs:boolean?"/>

  <xsl:sequence select="

   $arg1 != $arg2

 "/>

</xsl:function>

<!--

  The first day of the month of a date

 @author  Priscilla Walmsley, Datypic

 @version 1.0

 @see     http://www.xsltfunctions.com/xsl/functx_first-day-of-month.html

 @param   $date the date

-->

<xsl:function name="functx:first-day-of-month" as="xs:date?"

              xmlns:functx="http://www.functx.com" >

  <xsl:param name="date" as="xs:anyAtomicType?"/>

  <xsl:sequence select="

   functx:date(year-from-date(xs:date($date)),

            month-from-date(xs:date($date)),

            1)

 "/>

</xsl:function>

<!--

  The first day of the year of a date

 @author  Priscilla Walmsley, Datypic

 @version 1.0

 @see     http://www.xsltfunctions.com/xsl/functx_first-day-of-year.html

 @param   $date the date