EL_TEE_practiceNoteAssemblee.htmlProofing.xsl dependency tree

<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:functx="http://www.functx.com" exclude-result-prefixes="dxmlf xs" version="3.0">  <xsl:function name="functx:add-attributes" as="element()?"> <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>  <xsl:function name="functx:add-months" as="xs:date?"> <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>  <xsl:function name="functx:add-or-update-attributes" as="element()?"> <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>  <xsl:function name="functx:all-whitespace" as="xs:boolean"> <xsl:param name="arg" as="xs:string?"/> <xsl:sequence select=" normalize-space($arg) = '' "/> </xsl:function>  <xsl:function name="functx:are-distinct-values" as="xs:boolean"> <xsl:param name="seq" as="xs:anyAtomicType*"/> <xsl:sequence select=" count(distinct-values($seq)) = count($seq) "/> </xsl:function>  <xsl:function name="functx:atomic-type" as="xs:string*"> <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>  <xsl:function name="functx:avg-empty-is-zero" as="xs:double"> <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>  <xsl:function name="functx:between-exclusive" as="xs:boolean"> <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>  <xsl:function name="functx:between-inclusive" as="xs:boolean"> <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>  <xsl:function name="functx:camel-case-to-words" as="xs:string"> <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>  <xsl:function name="functx:capitalize-first" as="xs:string?"> <xsl:param name="arg" as="xs:string?"/> <xsl:sequence select=" concat(upper-case(substring($arg,1,1)), substring($arg,2)) "/> </xsl:function>  <xsl:function name="functx:change-element-names-deep" as="node()*"> <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>  <xsl:function name="functx:change-element-ns-deep" as="node()*"> <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>  <xsl:function name="functx:change-element-ns" as="element()?"> <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>  <xsl:function name="functx:chars" as="xs:string*"> <xsl:param name="arg" as="xs:string?"/> <xsl:sequence select=" for $ch in string-to-codepoints($arg) return codepoints-to-string($ch) "/> </xsl:function>  <xsl:function name="functx:contains-any-of" as="xs:boolean"> <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>  <xsl:function name="functx:contains-case-insensitive" as="xs:boolean?"> <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>  <xsl:function name="functx:contains-word" as="xs:boolean"> <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>  <xsl:function name="functx:copy-attributes" as="element()"> <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>  <xsl:function name="functx:date" as="xs:date"> <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>  <xsl:function name="functx:dateTime" as="xs:dateTime"> <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>  <xsl:function name="functx:day-in-year" as="xs:integer?"> <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>  <xsl:function name="functx:day-of-week-abbrev-en" as="xs:string?"> <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>  <xsl:function name="functx:day-of-week-name-en" as="xs:string?"> <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>  <xsl:function name="functx:day-of-week" as="xs:integer?"> <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>  <xsl:function name="functx:dayTimeDuration" as="xs:dayTimeDuration"> <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>  <xsl:function name="functx:days-in-month" as="xs:integer?"> <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>  <xsl:function name="functx:depth-of-node" as="xs:integer"> <xsl:param name="node" as="node()?"/> <xsl:sequence select=" count($node/ancestor-or-self::node()) "/> </xsl:function>  <xsl:function name="functx:distinct-attribute-names" as="xs:string*"> <xsl:param name="nodes" as="node()*"/> <xsl:sequence select=" distinct-values($nodes//@*/name(.)) "/> </xsl:function>  <xsl:function name="functx:distinct-deep" as="node()*"> <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>  <xsl:function name="functx:distinct-element-names" as="xs:string*"> <xsl:param name="nodes" as="node()*"/> <xsl:sequence select=" distinct-values($nodes/descendant-or-self::*/name(.)) "/> </xsl:function>  <xsl:function name="functx:distinct-element-paths" as="xs:string*"> <xsl:param name="nodes" as="node()*"/> <xsl:sequence select=" distinct-values(functx:path-to-node($nodes/descendant-or-self::*)) "/> </xsl:function>  <xsl:function name="functx:distinct-nodes" as="node()*"> <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>  <xsl:function name="functx:duration-from-timezone" as="xs:dayTimeDuration"> <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>  <xsl:function name="functx:dynamic-path" as="item()*"> <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>  <xsl:function name="functx:escape-for-regex" as="xs:string"> <xsl:param name="arg" as="xs:string?"/> <xsl:sequence select=" replace($arg, '(\.|\[|\]|\\|\||\-|\^|\$|\?|\*|\+|\{|\}|$|$)','\\$1') "/> </xsl:function>  <xsl:function name="functx:exclusive-or" as="xs:boolean?"> <xsl:param name="arg1" as="xs:boolean?"/> <xsl:param name="arg2" as="xs:boolean?"/> <xsl:sequence select=" $arg1 != $arg2 "/> </xsl:function>  <xsl:function name="functx:first-day-of-month" as="xs:date?"> <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>  <xsl:function name="functx:first-day-of-year" as="xs:date?"> <xsl:param name="date" as="xs:anyAtomicType?"/> <xsl:sequence select=" functx:date(year-from-date(xs:date($date)), 1, 1) "/> </xsl:function>  <xsl:function name="functx:first-node" as="node()?"> <xsl:param name="nodes" as="node()*"/> <xsl:sequence select=" ($nodes/.)[1] "/> </xsl:function>  <xsl:function name="functx:follows-not-descendant" as="xs:boolean"> <xsl:param name="a" as="node()?"/> <xsl:param name="b" as="node()?"/> <xsl:sequence select=" $a >> $b and empty($b intersect $a/ancestor::node()) "/> </xsl:function>  <xsl:function name="functx:format-as-title-en" as="xs:string*"> <xsl:param name="titles" as="xs:string*"/> <xsl:variable name="wordsToMoveToEnd" select="('A', 'An', 'The')"/> <xsl:for-each select="$titles"> <xsl:variable name="title" select="."/> <xsl:variable name="firstWord" select="functx:substring-before-match($title,'\W')"/> <xsl:sequence select="if ($firstWord = $wordsToMoveToEnd) then replace($title,'(.*?)\W(.*)', '$2, $1') else $title"/> </xsl:for-each> </xsl:function>  <xsl:function name="functx:fragment-from-uri" as="xs:string?"> <xsl:param name="uri" as="xs:string?"/> <xsl:sequence select=" substring-after($uri,'#') "/> </xsl:function>  <xsl:function name="functx:has-element-only-content" as="xs:boolean"> <xsl:param name="element" as="element()"/> <xsl:sequence select=" not($element/text()[normalize-space(.) != '']) and $element/* "/> </xsl:function>  <xsl:function name="functx:has-empty-content" as="xs:boolean"> <xsl:param name="element" as="element()"/> <xsl:sequence select=" not($element/node()) "/> </xsl:function>  <xsl:function name="functx:has-mixed-content" as="xs:boolean"> <xsl:param name="element" as="element()"/> <xsl:sequence select=" $element/text()[normalize-space(.) != ''] and $element/* "/> </xsl:function>  <xsl:function name="functx:has-simple-content" as="xs:boolean"> <xsl:param name="element" as="element()"/> <xsl:sequence select=" $element/text() and not($element/*) "/> </xsl:function>  <xsl:function name="functx:id-from-element" as="xs:string?"> <xsl:param name="element" as="element()?"/> <xsl:sequence select=" data(($element/@*[id(.) is ..])[1]) "/> </xsl:function>  <xsl:function name="functx:id-untyped" as="element()*"> <xsl:param name="node" as="node()*"/> <xsl:param name="id" as="xs:anyAtomicType"/> <xsl:sequence select=" $node//*[@* = $id] "/> </xsl:function>  <xsl:function name="functx:if-absent" as="item()*"> <xsl:param name="arg" as="item()*"/> <xsl:param name="value" as="item()*"/> <xsl:sequence select=" if (exists($arg)) then $arg else $value "/> </xsl:function>  <xsl:function name="functx:if-empty" as="item()*"> <xsl:param name="arg" as="item()?"/> <xsl:param name="value" as="item()*"/> <xsl:sequence select=" if (string($arg) != '') then data($arg) else $value "/> </xsl:function>  <xsl:function name="functx:index-of-deep-equal-node" as="xs:integer*"> <xsl:param name="nodes" as="node()*"/> <xsl:param name="nodeToFind" as="node()"/> <xsl:sequence select=" for $seq in (1 to count($nodes)) return $seq[deep-equal($nodes[$seq],$nodeToFind)] "/> </xsl:function>  <xsl:function name="functx:index-of-match-first" as="xs:integer?"> <xsl:param name="arg" as="xs:string?"/> <xsl:param name="pattern" as="xs:string"/> <xsl:sequence select=" if (matches($arg,$pattern)) then string-length(tokenize($arg, $pattern)[1]) + 1 else () "/> </xsl:function>  <xsl:function name="functx:index-of-node" as="xs:integer*"> <xsl:param name="nodes" as="node()*"/> <xsl:param name="nodeToFind" as="node()"/> <xsl:sequence select=" for $seq in (1 to count($nodes)) return $seq[$nodes[$seq] is $nodeToFind] "/> </xsl:function>  <xsl:function name="functx:index-of-string-first" as="xs:integer?"> <xsl:param name="arg" as="xs:string?"/> <xsl:param name="substring" as="xs:string"/> <xsl:sequence select=" if (contains($arg, $substring)) then string-length(substring-before($arg, $substring))+1 else () "/> </xsl:function>  <xsl:function name="functx:index-of-string-last" as="xs:integer?"> <xsl:param name="arg" as="xs:string?"/> <xsl:param name="substring" as="xs:string"/> <xsl:sequence select=" functx:index-of-string($arg, $substring)[last()] "/> </xsl:function>  <xsl:function name="functx:index-of-string" as="xs:integer*"> <xsl:param name="arg" as="xs:string?"/> <xsl:param name="substring" as="xs:string"/> <xsl:sequence select=" if (contains($arg, $substring)) then (string-length(substring-before($arg, $substring))+1, for $other in functx:index-of-string(substring-after($arg, $substring), $substring) return $other + string-length(substring-before($arg, $substring)) + string-length($substring)) else () "/> </xsl:function>  <xsl:function name="functx:insert-string" as="xs:string"> <xsl:param name="originalString" as="xs:string?"/> <xsl:param name="stringToInsert" as="xs:string?"/> <xsl:param name="pos" as="xs:integer"/> <xsl:sequence select=" concat(substring($originalString,1,$pos - 1), $stringToInsert, substring($originalString,$pos)) "/> </xsl:function>  <xsl:function name="functx:is-a-number" as="xs:boolean"> <xsl:param name="value" as="xs:anyAtomicType?"/> <xsl:sequence select=" string(number($value)) != 'NaN' "/> </xsl:function>  <xsl:function name="functx:is-absolute-uri" as="xs:boolean"> <xsl:param name="uri" as="xs:string?"/> <xsl:sequence select=" matches($uri,'^[a-z]+:') "/> </xsl:function>  <xsl:function name="functx:is-ancestor" as="xs:boolean"> <xsl:param name="node1" as="node()"/> <xsl:param name="node2" as="node()"/> <xsl:sequence select=" exists($node1 intersect $node2/ancestor::node()) "/> </xsl:function>  <xsl:function name="functx:is-descendant" as="xs:boolean"> <xsl:param name="node1" as="node()"/> <xsl:param name="node2" as="node()"/> <xsl:sequence select=" boolean($node2 intersect $node1/ancestor::node()) "/> </xsl:function>  <xsl:function name="functx:is-leap-year" as="xs:boolean"> <xsl:param name="date" as="xs:anyAtomicType?"/> <xsl:sequence select=" for $year in xs:integer(substring(string($date),1,4)) return ($year mod 4 = 0 and $year mod 100 != 0) or $year mod 400 = 0 "/> </xsl:function>  <xsl:function name="functx:is-node-among-descendants-deep-equal" as="xs:boolean"> <xsl:param name="node" as="node()?"/> <xsl:param name="seq" as="node()*"/> <xsl:sequence select=" some $nodeInSeq in $seq/descendant-or-self::*/(.|@*) satisfies deep-equal($nodeInSeq,$node) "/> </xsl:function>  <xsl:function name="functx:is-node-among-descendants" as="xs:boolean"> <xsl:param name="node" as="node()?"/> <xsl:param name="seq" as="node()*"/> <xsl:sequence select=" some $nodeInSeq in $seq/descendant-or-self::*/(.|@*) satisfies $nodeInSeq is $node "/> </xsl:function>  <xsl:function name="functx:is-node-in-sequence-deep-equal" as="xs:boolean"> <xsl:param name="node" as="node()?"/> <xsl:param name="seq" as="node()*"/> <xsl:sequence select=" some $nodeInSeq in $seq satisfies deep-equal($nodeInSeq,$node) "/> </xsl:function>  <xsl:function name="functx:is-node-in-sequence" as="xs:boolean"> <xsl:param name="node" as="node()?"/> <xsl:param name="seq" as="node()*"/> <xsl:sequence select=" some $nodeInSeq in $seq satisfies $nodeInSeq is $node "/> </xsl:function>  <xsl:function name="functx:is-value-in-sequence" as="xs:boolean"> <xsl:param name="value" as="xs:anyAtomicType?"/> <xsl:param name="seq" as="xs:anyAtomicType*"/> <xsl:sequence select=" $value = $seq "/> </xsl:function>  <xsl:function name="functx:last-day-of-month" as="xs:date?"> <xsl:param name="date" as="xs:anyAtomicType?"/> <xsl:sequence select=" functx:date(year-from-date(xs:date($date)), month-from-date(xs:date($date)), functx:days-in-month($date)) "/> </xsl:function>  <xsl:function name="functx:last-day-of-year" as="xs:date?"> <xsl:param name="date" as="xs:anyAtomicType?"/> <xsl:sequence select=" functx:date(year-from-date(xs:date($date)), 12, 31) "/> </xsl:function>  <xsl:function name="functx:last-node" as="node()?"> <xsl:param name="nodes" as="node()*"/> <xsl:sequence select=" ($nodes/.)[last()] "/> </xsl:function>  <xsl:function name="functx:leaf-elements" as="element()*"> <xsl:param name="root" as="node()?"/> <xsl:sequence select=" $root/descendant-or-self::*[not(*)] "/> </xsl:function>  <xsl:function name="functx:left-trim" as="xs:string"> <xsl:param name="arg" as="xs:string?"/> <xsl:sequence select=" replace($arg,'^\s+','') "/> </xsl:function>  <xsl:function name="functx:line-count" as="xs:integer"> <xsl:param name="arg" as="xs:string?"/> <xsl:sequence select=" count(functx:lines($arg)) "/> </xsl:function>  <xsl:function name="functx:lines" as="xs:string*"> <xsl:param name="arg" as="xs:string?"/> <xsl:sequence select=" tokenize($arg, '(\r\n?|\n\r?)') "/> </xsl:function>  <xsl:function name="functx:max-depth" as="xs:integer?"> <xsl:param name="root" as="node()?"/> <xsl:sequence select=" if ($root/*) then max($root/*/functx:max-depth(.)) + 1 else 1 "/> </xsl:function>  <xsl:function name="functx:max-determine-type" as="xs:anyAtomicType?"> <xsl:param name="seq" as="xs:anyAtomicType*"/> <xsl:sequence select=" if (every $value in $seq satisfies ($value castable as xs:double)) then max(for $value in $seq return xs:double($value)) else max(for $value in $seq return xs:string($value)) "/> </xsl:function>  <xsl:function name="functx:max-line-length" as="xs:integer"> <xsl:param name="arg" as="xs:string?"/> <xsl:sequence select=" max( for $line in functx:lines($arg) return string-length($line)) "/> </xsl:function>  <xsl:function name="functx:max-node" as="node()*"> <xsl:param name="nodes" as="node()*"/> <xsl:sequence select=" $nodes[. = max($nodes)] "/> </xsl:function>  <xsl:function name="functx:max-string" as="xs:string?"> <xsl:param name="strings" as="xs:anyAtomicType*"/> <xsl:sequence select=" max(for $string in $strings return string($string)) "/> </xsl:function>  <xsl:function name="functx:min-determine-type" as="xs:anyAtomicType?"> <xsl:param name="seq" as="xs:anyAtomicType*"/> <xsl:sequence select=" if (every $value in $seq satisfies ($value castable as xs:double)) then min(for $value in $seq return xs:double($value)) else min(for $value in $seq return xs:string($value)) "/> </xsl:function>  <xsl:function name="functx:min-node" as="node()*"> <xsl:param name="nodes" as="node()*"/> <xsl:sequence select=" $nodes[. = min($nodes)] "/> </xsl:function>  <xsl:function name="functx:min-non-empty-string" as="xs:string?"> <xsl:param name="strings" as="xs:string*"/> <xsl:sequence select=" min($strings[. != '']) "/> </xsl:function>  <xsl:function name="functx:min-string" as="xs:string?"> <xsl:param name="strings" as="xs:anyAtomicType*"/> <xsl:sequence select=" min(for $string in $strings return string($string)) "/> </xsl:function>  <xsl:function name="functx:mmddyyyy-to-date" as="xs:date?"> <xsl:param name="dateString" as="xs:string?"/> <xsl:sequence select=" if (empty($dateString)) then () else if (not(matches($dateString, '^\D*(\d{2})\D*(\d{2})\D*(\d{4})\D*$'))) then error(xs:QName('functx:Invalid_Date_Format')) else xs:date(replace($dateString, '^\D*(\d{2})\D*(\d{2})\D*(\d{4})\D*$', '$3-$1-$2')) "/> </xsl:function>  <xsl:function name="functx:month-abbrev-en" as="xs:string?"> <xsl:param name="date" as="xs:anyAtomicType?"/> <xsl:sequence select=" ('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec') [month-from-date(xs:date($date))] "/> </xsl:function>  <xsl:function name="functx:month-name-en" as="xs:string?"> <xsl:param name="date" as="xs:anyAtomicType?"/> <xsl:sequence select=" ('January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December') [month-from-date(xs:date($date))] "/> </xsl:function>  <xsl:function name="functx:name-test" as="xs:boolean"> <xsl:param name="testname" as="xs:string?"/> <xsl:param name="names" as="xs:string*"/> <xsl:sequence select=" $testname = $names or $names = '*' or functx:substring-after-if-contains($testname,':') = (for $name in $names return substring-after($name,'*:')) or substring-before($testname,':') = (for $name in $names[contains(.,':*')] return substring-before($name,':*')) "/> </xsl:function>  <xsl:function name="functx:namespaces-in-use" as="xs:anyURI*"> <xsl:param name="root" as="node()?"/> <xsl:sequence select=" distinct-values( $root/descendant-or-self::*/(.|@*)/namespace-uri(.)) "/> </xsl:function>  <xsl:function name="functx:next-day" as="xs:date?"> <xsl:param name="date" as="xs:anyAtomicType?"/> <xsl:sequence select=" xs:date($date) + xs:dayTimeDuration('P1D') "/> </xsl:function>  <xsl:function name="functx:node-kind" as="xs:string*"> <xsl:param name="nodes" as="node()*"/> <xsl:sequence select=" for $node in $nodes return if ($node instance of element()) then 'element' else if ($node instance of attribute()) then 'attribute' else if ($node instance of text()) then 'text' else if ($node instance of document-node()) then 'document-node' else if ($node instance of comment()) then 'comment' else if ($node instance of processing-instruction()) then 'processing-instruction' else 'unknown' "/> </xsl:function>  <xsl:function name="functx:non-distinct-values" as="xs:anyAtomicType*"> <xsl:param name="seq" as="xs:anyAtomicType*"/> <xsl:sequence select=" for $val in distinct-values($seq) return $val[count($seq[. = $val]) > 1] "/> </xsl:function>  <xsl:function name="functx:number-of-matches" as="xs:integer"> <xsl:param name="arg" as="xs:string?"/> <xsl:param name="pattern" as="xs:string"/> <xsl:sequence select=" count(tokenize($arg,$pattern)) - 1 "/> </xsl:function>  <xsl:function name="functx:open-ref-document" as="document-node()"> <xsl:param name="refNode" as="node()"/> <xsl:sequence select=" if (base-uri($refNode)) then doc(resolve-uri($refNode, base-uri($refNode))) else doc(resolve-uri($refNode)) "/> </xsl:function>  <xsl:function name="functx:ordinal-number-en" as="xs:string"> <xsl:param name="num" as="xs:integer?"/> <xsl:sequence select=" concat(xs:string($num), if (matches(xs:string($num),'[04-9]$|1[1-3]$')) then 'th' else if (ends-with(xs:string($num),'1')) then 'st' else if (ends-with(xs:string($num),'2')) then 'nd' else if (ends-with(xs:string($num),'3')) then 'rd' else '') "/> </xsl:function>  <xsl:function name="functx:pad-integer-to-length" as="xs:string"> <xsl:param name="integerToPad" as="xs:anyAtomicType?"/> <xsl:param name="length" as="xs:integer"/> <xsl:sequence select=" if ($length < string-length(string($integerToPad))) then error(xs:QName('functx:Integer_Longer_Than_Length')) else concat (functx:repeat-string( '0',$length - string-length(string($integerToPad))), string($integerToPad)) "/> </xsl:function>  <xsl:function name="functx:pad-string-to-length" as="xs:string"> <xsl:param name="stringToPad" as="xs:string?"/> <xsl:param name="padChar" as="xs:string"/> <xsl:param name="length" as="xs:integer"/> <xsl:sequence select=" substring( string-join ( ($stringToPad, for $i in (1 to $length) return $padChar) ,'') ,1,$length) "/> </xsl:function>  <xsl:function name="functx:path-to-node-with-pos" as="xs:string"> <xsl:param name="node" as="node()?"/> <xsl:variable name="names" as="xs:string*"> <xsl:for-each select="$node/ancestor-or-self::*"> <xsl:variable name="ancestor" select="."/> <xsl:variable name="sibsOfSameName" select="$ancestor/../*[name() = name($ancestor)]"/> <xsl:sequence select="concat(name($ancestor), if (count($sibsOfSameName) <= 1) then '' else concat( '[',functx:index-of-node($sibsOfSameName,$ancestor),']'))"/> </xsl:for-each> </xsl:variable> <xsl:sequence select="string-join($names,'/')"/> </xsl:function>  <xsl:function name="functx:path-to-node" as="xs:string*"> <xsl:param name="nodes" as="node()*"/> <xsl:sequence select=" $nodes/string-join(ancestor-or-self::*/name(.), '/') "/> </xsl:function>  <xsl:function name="functx:precedes-not-ancestor" as="xs:boolean"> <xsl:param name="a" as="node()?"/> <xsl:param name="b" as="node()?"/> <xsl:sequence select=" $a << $b and empty($a intersect $b/ancestor::node()) "/> </xsl:function>  <xsl:function name="functx:previous-day" as="xs:date?"> <xsl:param name="date" as="xs:anyAtomicType?"/> <xsl:sequence select=" xs:date($date) - xs:dayTimeDuration('P1D') "/> </xsl:function>  <xsl:function name="functx:remove-attributes-deep" as="node()*"> <xsl:param name="nodes" as="node()*"/> <xsl:param name="names" as="xs:string*"/> <xsl:for-each select="$nodes"> <xsl:choose> <xsl:when test=". instance of element()"> <xsl:element name="{node-name(.)}"> <xsl:sequence select=" (@*[not(functx:name-test(name(),$names))], functx:remove-attributes-deep(node(), $names))"/> </xsl:element> </xsl:when> <xsl:when test=". instance of document-node()"> <xsl:document> <xsl:sequence select=" functx:remove-attributes-deep(node(), $names)"/> </xsl:document> </xsl:when> <xsl:otherwise> <xsl:sequence select="."/> </xsl:otherwise> </xsl:choose> </xsl:for-each> </xsl:function>  <xsl:function name="functx:remove-attributes" as="element()"> <xsl:param name="elements" as="element()*"/> <xsl:param name="names" as="xs:string*"/> <xsl:for-each select="$elements"> <xsl:element name="{node-name(.)}"> <xsl:sequence select="(@*[not(functx:name-test(name(),$names))], node())"/> </xsl:element> </xsl:for-each> </xsl:function>  <xsl:function name="functx:remove-elements-deep" as="node()*"> <xsl:param name="nodes" as="node()*"/> <xsl:param name="names" as="xs:string*"/> <xsl:for-each select="$nodes"> <xsl:choose> <xsl:when test=". instance of element()"> <xsl:if test="not(functx:name-test(name(),$names))"> <xsl:element name="{node-name(.)}"> <xsl:sequence select="@*, functx:remove-elements-deep(node(), $names)"/> </xsl:element> </xsl:if> </xsl:when> <xsl:when test=". instance of document-node()"> <xsl:document> <xsl:sequence select=" functx:remove-elements-deep(node(), $names)"/> </xsl:document> </xsl:when> <xsl:otherwise> <xsl:sequence select="."/> </xsl:otherwise> </xsl:choose> </xsl:for-each> </xsl:function>  <xsl:function name="functx:remove-elements-not-contents" as="node()*"> <xsl:param name="nodes" as="node()*"/> <xsl:param name="names" as="xs:string*"/> <xsl:for-each select="$nodes"> <xsl:choose> <xsl:when test=". instance of element()"> <xsl:choose> <xsl:when test="functx:name-test(name(),$names)"> <xsl:sequence select=" functx:remove-elements-not-contents(node(), $names)"/> </xsl:when> <xsl:otherwise> <xsl:element name="{node-name(.)}"> <xsl:sequence select="@*, functx:remove-elements-not-contents(node(),$names)"/> </xsl:element> </xsl:otherwise> </xsl:choose> </xsl:when> <xsl:when test=". instance of document-node()"> <xsl:document> <xsl:sequence select=" functx:remove-elements-not-contents(node(), $names)"/> </xsl:document> </xsl:when> <xsl:otherwise> <xsl:sequence select="."/> </xsl:otherwise> </xsl:choose> </xsl:for-each> </xsl:function>  <xsl:function name="functx:remove-elements" as="element()*"> <xsl:param name="elements" as="element()*"/> <xsl:param name="names" as="xs:string*"/> <xsl:for-each select="$elements"> <xsl:element name="{node-name(.)}"> <xsl:sequence select="(@*, node()[not(functx:name-test(name(),$names))])"/> </xsl:element> </xsl:for-each> </xsl:function>  <xsl:function name="functx:repeat-string" as="xs:string"> <xsl:param name="stringToRepeat" as="xs:string?"/> <xsl:param name="count" as="xs:integer"/> <xsl:sequence select=" string-join((for $i in 1 to $count return $stringToRepeat), '') "/> </xsl:function>  <xsl:function name="functx:replace-beginning" as="xs:string"> <xsl:param name="arg" as="xs:string?"/> <xsl:param name="pattern" as="xs:string"/> <xsl:param name="replacement" as="xs:string"/> <xsl:sequence select=" replace($arg, concat('^.*?', $pattern), $replacement) "/> </xsl:function>  <xsl:function name="functx:replace-element-values" as="element()*"> <xsl:param name="elements" as="element()*"/> <xsl:param name="values" as="xs:anyAtomicType*"/> <xsl:for-each select="$elements"> <xsl:variable name="seq" select="position()"/> <xsl:element name="{node-name(.)}"> <xsl:sequence select="@*, $values[$seq]"/> </xsl:element> </xsl:for-each> </xsl:function>  <xsl:function name="functx:replace-first" as="xs:string"> <xsl:param name="arg" as="xs:string?"/> <xsl:param name="pattern" as="xs:string"/> <xsl:param name="replacement" as="xs:string"/> <xsl:sequence select=" replace($arg, concat('(^.*?)', $pattern), concat('$1',$replacement)) "/> </xsl:function>  <xsl:function name="functx:replace-multi" as="xs:string?"> <xsl:param name="arg" as="xs:string?"/> <xsl:param name="changeFrom" as="xs:string*"/> <xsl:param name="changeTo" as="xs:string*"/> <xsl:sequence select=" if (count($changeFrom) > 0) then functx:replace-multi( replace($arg, $changeFrom[1], functx:if-absent($changeTo[1],'')), $changeFrom[position() > 1], $changeTo[position() > 1]) else $arg "/> </xsl:function>  <xsl:function name="functx:reverse-string" as="xs:string"> <xsl:param name="arg" as="xs:string?"/> <xsl:sequence select=" codepoints-to-string(reverse(string-to-codepoints($arg))) "/> </xsl:function>  <xsl:function name="functx:right-trim" as="xs:string"> <xsl:param name="arg" as="xs:string?"/> <xsl:sequence select=" replace($arg,'\s+$','') "/> </xsl:function>  <xsl:function name="functx:scheme-from-uri" as="xs:string?"> <xsl:param name="uri" as="xs:string?"/> <xsl:sequence select=" substring-before($uri,':') "/> </xsl:function>  <xsl:function name="functx:sequence-deep-equal" as="xs:boolean"> <xsl:param name="seq1" as="item()*"/> <xsl:param name="seq2" as="item()*"/> <xsl:sequence select=" every $i in 1 to max((count($seq1),count($seq2))) satisfies deep-equal($seq1[$i],$seq2[$i]) "/> </xsl:function>  <xsl:function name="functx:sequence-node-equal-any-order" as="xs:boolean"> <xsl:param name="seq1" as="node()*"/> <xsl:param name="seq2" as="node()*"/> <xsl:sequence select=" not( ($seq1 except $seq2, $seq2 except $seq1)) "/> </xsl:function>  <xsl:function name="functx:sequence-node-equal" as="xs:boolean"> <xsl:param name="seq1" as="node()*"/> <xsl:param name="seq2" as="node()*"/> <xsl:sequence select=" every $i in 1 to max((count($seq1),count($seq2))) satisfies $seq1[$i] is $seq2[$i] "/> </xsl:function>  <xsl:function name="functx:sequence-type" as="xs:string"> <xsl:param name="items" as="item()*"/> <xsl:sequence select=" concat( if (empty($items)) then 'empty-sequence()' else if (every $val in $items satisfies $val instance of xs:anyAtomicType) then if (count(distinct-values(functx:atomic-type($items))) > 1) then 'xs:anyAtomicType' else functx:atomic-type($items[1]) else if (some $val in $items satisfies $val instance of xs:anyAtomicType) then 'item()' else if (count(distinct-values(functx:node-kind($items))) > 1) then 'node()' else concat(functx:node-kind($items[1]),'()') , if (count($items) > 1) then '+' else '') "/> </xsl:function>  <xsl:function name="functx:siblings-same-name" as="element()*"> <xsl:param name="element" as="element()?"/> <xsl:sequence select=" $element/../*[node-name(.) = node-name($element)] except $element "/> </xsl:function>  <xsl:function name="functx:siblings" as="node()*"> <xsl:param name="node" as="node()?"/> <xsl:sequence select=" $node/../node() except $node "/> </xsl:function>  <xsl:function name="functx:sort-as-numeric" as="item()*"> <xsl:param name="seq" as="item()*"/> <xsl:for-each select="$seq"> <xsl:sort select="number(.)"/> <xsl:copy-of select="."/> </xsl:for-each> </xsl:function>  <xsl:function name="functx:sort-case-insensitive" as="item()*"> <xsl:param name="seq" as="item()*"/> <xsl:for-each select="$seq"> <xsl:sort select="upper-case(string(.))"/> <xsl:copy-of select="."/> </xsl:for-each> </xsl:function>  <xsl:function name="functx:sort-document-order" as="node()*"> <xsl:param name="seq" as="node()*"/> <xsl:sequence select=" $seq/. "/> </xsl:function>  <xsl:function name="functx:sort" as="item()*"> <xsl:param name="seq" as="item()*"/> <xsl:for-each select="$seq"> <xsl:sort select="."/> <xsl:copy-of select="."/> </xsl:for-each> </xsl:function>  <xsl:function name="functx:substring-after-if-contains" as="xs:string?"> <xsl:param name="arg" as="xs:string?"/> <xsl:param name="delim" as="xs:string"/> <xsl:sequence select=" if (contains($arg,$delim)) then substring-after($arg,$delim) else $arg "/> </xsl:function>  <xsl:function name="functx:substring-after-last-match" as="xs:string"> <xsl:param name="arg" as="xs:string?"/> <xsl:param name="regex" as="xs:string"/> <xsl:sequence select=" replace($arg,concat('^.*',$regex),'') "/> </xsl:function>  <xsl:function name="functx:substring-after-last" as="xs:string"> <xsl:param name="arg" as="xs:string?"/> <xsl:param name="delim" as="xs:string"/> <xsl:sequence select=" replace ($arg,concat('^.*',functx:escape-for-regex($delim)),'') "/> </xsl:function>  <xsl:function name="functx:substring-after-match" as="xs:string?"> <xsl:param name="arg" as="xs:string?"/> <xsl:param name="regex" as="xs:string"/> <xsl:sequence select=" replace($arg,concat('^.*?',$regex),'') "/> </xsl:function>  <xsl:function name="functx:substring-before-if-contains" as="xs:string?"> <xsl:param name="arg" as="xs:string?"/> <xsl:param name="delim" as="xs:string"/> <xsl:sequence select=" if (contains($arg,$delim)) then substring-before($arg,$delim) else $arg "/> </xsl:function>  <xsl:function name="functx:substring-before-last-match" as="xs:string?"> <xsl:param name="arg" as="xs:string?"/> <xsl:param name="regex" as="xs:string"/> <xsl:sequence select=" replace($arg,concat('^(.*)',$regex,'.*'),'$1') "/> </xsl:function>  <xsl:function name="functx:substring-before-last" as="xs:string"> <xsl:param name="arg" as="xs:string?"/> <xsl:param name="delim" as="xs:string"/> <xsl:sequence select=" if (matches($arg, functx:escape-for-regex($delim))) then replace($arg, concat('^(.*)', functx:escape-for-regex($delim),'.*'), '$1') else '' "/> </xsl:function>  <xsl:function name="functx:substring-before-match" as="xs:string"> <xsl:param name="arg" as="xs:string?"/> <xsl:param name="regex" as="xs:string"/> <xsl:sequence select=" tokenize($arg,$regex)[1] "/> </xsl:function>  <xsl:function name="functx:time" as="xs:time"> <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:time( concat( functx:pad-integer-to-length(xs:integer($hour),2),':', functx:pad-integer-to-length(xs:integer($minute),2),':', functx:pad-integer-to-length(xs:integer($second),2))) "/> </xsl:function>  <xsl:function name="functx:timezone-from-duration" as="xs:string"> <xsl:param name="duration" as="xs:dayTimeDuration"/> <xsl:sequence select=" if (string($duration) = ('PT0S','-PT0S')) then 'Z' else if (matches(string($duration),'-PT[1-9]H')) then replace(string($duration),'PT([1-9])H','0$1:00') else if (matches(string($duration),'PT[1-9]H')) then replace(string($duration),'PT([1-9])H','+0$1:00') else if (matches(string($duration),'-PT1[0-4]H')) then replace(string($duration),'PT(1[0-4])H','$1:00') else if (matches(string($duration),'PT1[0-4]H')) then replace(string($duration),'PT(1[0-4])H','+$1:00') else error(xs:QName('functx:Invalid_Duration_Value')) "/> </xsl:function>  <xsl:function name="functx:total-days-from-duration" as="xs:decimal?"> <xsl:param name="duration" as="xs:dayTimeDuration?"/> <xsl:sequence select=" $duration div xs:dayTimeDuration('P1D') "/> </xsl:function>  <xsl:function name="functx:total-hours-from-duration" as="xs:decimal?"> <xsl:param name="duration" as="xs:dayTimeDuration?"/> <xsl:sequence select=" $duration div xs:dayTimeDuration('PT1H') "/> </xsl:function>  <xsl:function name="functx:total-minutes-from-duration" as="xs:decimal?"> <xsl:param name="duration" as="xs:dayTimeDuration?"/> <xsl:sequence select=" $duration div xs:dayTimeDuration('PT1M') "/> </xsl:function>  <xsl:function name="functx:total-months-from-duration" as="xs:decimal?"> <xsl:param name="duration" as="xs:yearMonthDuration?"/> <xsl:sequence select=" $duration div xs:yearMonthDuration('P1M') "/> </xsl:function>  <xsl:function name="functx:total-seconds-from-duration" as="xs:decimal?"> <xsl:param name="duration" as="xs:dayTimeDuration?"/> <xsl:sequence select=" $duration div xs:dayTimeDuration('PT1S') "/> </xsl:function>  <xsl:function name="functx:total-years-from-duration" as="xs:decimal?"> <xsl:param name="duration" as="xs:yearMonthDuration?"/> <xsl:sequence select=" $duration div xs:yearMonthDuration('P1Y') "/> </xsl:function>  <xsl:function name="functx:trim" as="xs:string"> <xsl:param name="arg" as="xs:string?"/> <xsl:sequence select=" replace(replace($arg,'\s+$',''),'^\s+','') "/> </xsl:function>  <xsl:function name="functx:update-attributes" as="element()?"> <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="$element/@*[node-name(.) = current()]"> <xsl:attribute name="{.}" namespace="{namespace-uri-from-QName(.)}" select="$attrValues[$seq]"/> </xsl:if> </xsl:for-each> <xsl:copy-of select="@*[not(node-name(.) = $attrNames)]|node()"/> </xsl:copy> </xsl:for-each> </xsl:function>  <xsl:function name="functx:value-except" as="xs:anyAtomicType*"> <xsl:param name="arg1" as="xs:anyAtomicType*"/> <xsl:param name="arg2" as="xs:anyAtomicType*"/> <xsl:sequence select=" distinct-values($arg1[not(.=$arg2)]) "/> </xsl:function>  <xsl:function name="functx:value-intersect" as="xs:anyAtomicType*"> <xsl:param name="arg1" as="xs:anyAtomicType*"/> <xsl:param name="arg2" as="xs:anyAtomicType*"/> <xsl:sequence select=" distinct-values($arg1[.=$arg2]) "/> </xsl:function>  <xsl:function name="functx:value-union" as="xs:anyAtomicType*"> <xsl:param name="arg1" as="xs:anyAtomicType*"/> <xsl:param name="arg2" as="xs:anyAtomicType*"/> <xsl:sequence select=" distinct-values(($arg1, $arg2)) "/> </xsl:function>  <xsl:function name="functx:word-count" as="xs:integer"> <xsl:param name="arg" as="xs:string?"/> <xsl:sequence select=" count(tokenize($arg, '\W+')[. != '']) "/> </xsl:function>  <xsl:function name="functx:words-to-camel-case" as="xs:string"> <xsl:param name="arg" as="xs:string?"/> <xsl:sequence select=" string-join((tokenize($arg,'\s+')[1], for $word in tokenize($arg,'\s+')[position() > 1] return functx:capitalize-first($word)) ,'') "/> </xsl:function>  <xsl:function name="functx:wrap-values-in-elements" as="element()*"> <xsl:param name="values" as="xs:anyAtomicType*"/> <xsl:param name="elementName" as="xs:QName"/> <xsl:for-each select="$values"> <xsl:element name="{$elementName}" namespace="{namespace-uri-from-QName($elementName)}"> <xsl:sequence select="."/> </xsl:element> </xsl:for-each> </xsl:function>  <xsl:function name="functx:yearMonthDuration" as="xs:yearMonthDuration"> <xsl:param name="years" as="xs:decimal?"/> <xsl:param name="months" as="xs:integer?"/> <xsl:sequence select=" (xs:yearMonthDuration('P1M') * functx:if-empty($months,0)) + (xs:yearMonthDuration('P1Y') * functx:if-empty($years,0)) "/> </xsl:function> </xsl:stylesheet>

<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:xd="http://www.oxygenxml.com/ns/doc/xsl" xmlns:rng="http://relaxng.org/ns/structure/1.0" xmlns:xf="http://www.lefebvre-sarrut.eu/ns/xmlfirst" xmlns:els="http://www.lefebvre-sarrut.eu/ns/els" xmlns:xfe="http://www.lefebvre-sarrut.eu/ns/xmlfirst/xmlEditor" xmlns:html="http://www.w3.org/1999/xhtml" exclude-result-prefixes="#all" version="3.0"> <xsl:import href="xslLib:/xslLib/rng-common.xsl"/>  <xsl:import href="xslLib:/xslLib/els-log.xsl"/> <xd:doc scope="stylesheet"> <xd:desc> <xd:p>Common function and templates for XFE</xd:p> </xd:desc> </xd:doc> <xsl:key name="getRelationByXfId" match="xf:relation" use="@xf:id"/>  <xsl:param name="xfe:debug" select="true()" as="xs:boolean"/>  <xsl:param name="xfe:ecm.ee.url.path" select="'/#/editorialEntity/'" as="xs:string"/> <xsl:param name="xfe:media.url.path" select="'/api/media/original/'" as="xs:string"/>  <xsl:param name="LOG.URI" select="resolve-uri('log', base-uri(.))" as="xs:string"/> <xsl:variable name="log.uri" select="if(ends-with($LOG.URI, '/')) then ($LOG.URI) else(concat($LOG.URI, '/'))" as="xs:string"/>  <xsl:param name="xfe:css.name" as="xs:string?"/> <xsl:param name="xfe:css.path" as="xs:string?"/>  <xsl:param name="els:log.level.code" select="'xfe'" as="xs:string"/>  <xsl:param name="xfe:conf.uri" select="resolve-uri('xfe-conf.xml', base-uri(/))" as="xs:string"/> <xsl:variable name="xfe:conf.generate-missing-mapping-from-schema" select="false()" as="xs:boolean"/> <xsl:variable name="xfe:conf" as="element()"> <xsl:choose> <xsl:when test="doc-available($xfe:conf.uri)"> <xsl:sequence select="document($xfe:conf.uri)/*"/> </xsl:when> <xsl:otherwise> <xsl:call-template name="els:log"> <xsl:with-param name="xsltName" select="els:getFileName(static-base-uri())"/> <xsl:with-param name="code" select="$els:log.level.code"/> <xsl:with-param name="alert" select="true()"/> <xsl:with-param name="level" select="'fatal'"/> <xsl:with-param name="markup" select="false()"/> <xsl:with-param name="description">document <xsl:value-of select="$xfe:conf.uri"/> is not available</xsl:with-param> </xsl:call-template> <xsl:message terminate="yes"/> </xsl:otherwise> </xsl:choose> </xsl:variable> <xsl:variable name="xfe:conf.resolved.get-recursive-imports" as="document-node()"> <xsl:document> <xsl:apply-templates select="$xfe:conf" mode="xfe:conf.resolved.get-recursive-imports"/> </xsl:document> </xsl:variable> <xsl:variable name="xfe:conf.resolved" as="document-node()"> <xsl:document> <xsl:apply-templates select="$xfe:conf.resolved.get-recursive-imports" mode="xfe:resolve-conf"/> </xsl:document> </xsl:variable> <xsl:variable name="xfe:conf.hasSchema" select="exists($xfe:conf/*:srngXmlmodel/@href)" as="xs:boolean"/> <xsl:variable name="xfe:srng.href" select="$xfe:conf/*:srngXmlmodel/@href" as="xs:anyURI?"/> <xsl:variable name="xfe:srng.uri" select="resolve-uri($xfe:srng.href, $xfe:conf.uri)" as="xs:anyURI?"/> <xsl:variable name="xfe:srng" as="document-node()?"> <xsl:if test="$xfe:conf.hasSchema"> <xsl:choose> <xsl:when test="doc-available($xfe:srng.uri)"> <xsl:sequence select="document($xfe:srng.uri)"/> </xsl:when> <xsl:otherwise> <xsl:call-template name="els:log"> <xsl:with-param name="xsltName" select="els:getFileName(static-base-uri())"/> <xsl:with-param name="code" select="$els:log.level.code"/> <xsl:with-param name="alert" select="true()"/> <xsl:with-param name="level" select="'fatal'"/> <xsl:with-param name="markup" select="false()"/> <xsl:with-param name="description">document <xsl:value-of select="$xfe:srng.uri"/> is not available</xsl:with-param> </xsl:call-template> <xsl:message terminate="yes"/> </xsl:otherwise> </xsl:choose> </xsl:if> </xsl:variable> <xsl:variable name="xfe:srng.normalized" as="document-node()?"> <xsl:if test="$xfe:conf.hasSchema"> <xsl:document> <xsl:apply-templates select="$xfe:srng" mode="xfe:srng_duplicateDefineByAttributeValue"/> </xsl:document> </xsl:if> </xsl:variable> <xsl:variable name="xfe:srng.grammar.normalized" select="$xfe:srng.normalized/rng:grammar" as="element(rng:grammar)?"/> <xsl:variable name="xfe:conf.normalized" as="element()?"> <xsl:variable name="step" as="document-node()"> <xsl:document> <xsl:apply-templates select="$xfe:conf.resolved" mode="normalizeConf.step1"/> </xsl:document> </xsl:variable> <xsl:variable name="step" as="document-node()"> <xsl:document> <xsl:apply-templates select="$step" mode="normalizeConf.step2"/> </xsl:document> </xsl:variable> <xsl:choose> <xsl:when test="$xfe:conf.generate-missing-mapping-from-schema"> <xsl:apply-templates select="$step" mode="normalizeConf.step3"/> </xsl:when> <xsl:otherwise> <xsl:sequence select="$step/*"/> </xsl:otherwise> </xsl:choose> </xsl:variable> <xsl:variable name="xfe:srng.grammar.rootIsSingle" select="if($xfe:conf.hasSchema) then(rng:rootIsSingle($xfe:srng.grammar.normalized)) else(true())" as="xs:boolean"/> <xsl:variable name="xfe:srng.is-xhtml" select="($xfe:conf/*:srngXmlmodel/@is-xhtml, false())[1]" as="xs:boolean"/> <xsl:variable name="xfe:dataAttribute.prefix" select="'data-'" as="xs:string"/> <xsl:variable name="xfe:dataXmlAttribute.prefix" select="concat($xfe:dataAttribute.prefix, 'xml-')" as="xs:string"/> <xsl:variable name="xfe:dataXfeAttribute.prefix" select="concat($xfe:dataAttribute.prefix, 'xfe-')" as="xs:string"/>    <xsl:template match="/*:conf" mode="xfe:conf.resolved.get-recursive-imports"> <xsl:param name="rel-uri" as="xs:string?"/> <xsl:variable name="uri" select="document-uri(/)" as="xs:anyURI"/> <xsl:copy> <xsl:copy-of select="@*"/> <xsl:if test="not(empty($rel-uri))"> <xsl:attribute name="xml:base" select="$rel-uri"/> </xsl:if> <xsl:apply-templates mode="#current"> <xsl:with-param name="caller.uri" select="$uri" tunnel="yes"/> </xsl:apply-templates> </xsl:copy> </xsl:template> <xsl:template match="*:import" mode="xfe:conf.resolved.get-recursive-imports"> <xsl:param name="caller.uri" as="xs:anyURI" tunnel="yes"/> <xsl:variable name="this.uri" select="resolve-uri(@href,base-uri(.))" as="xs:anyURI"/> <xsl:copy> <xsl:copy-of select="@*"/> <xsl:if test="$caller.uri != $this.uri"> <xsl:choose> <xsl:when test="doc-available($this.uri)"> <xsl:apply-templates select="document($this.uri)/*" mode="#current"> <xsl:with-param name="rel-uri" select="@href"/> </xsl:apply-templates> </xsl:when> <xsl:otherwise> <xsl:call-template name="els:log"> <xsl:with-param name="xsltName" select="els:getFileName(static-base-uri())"/> <xsl:with-param name="code" select="$els:log.level.code"/> <xsl:with-param name="alert" select="true()"/> <xsl:with-param name="level" select="'fatal'"/> <xsl:with-param name="markup" select="false()"/> <xsl:with-param name="description">[FATAL] import href="<xsl:value-of select="@href"/>" is not available in <xsl:value-of select="base-uri(.)"/></xsl:with-param> </xsl:call-template> <xsl:message terminate="yes"/> </xsl:otherwise> </xsl:choose> </xsl:if> </xsl:copy> </xsl:template>  <xsl:template match="node() | @*" mode="xfe:conf.resolved.get-recursive-imports"> <xsl:copy> <xsl:apply-templates select="node() | @*" mode="#current"/> </xsl:copy> </xsl:template>     <xsl:template match="/" mode="xfe:resolve-conf"> <xsl:choose> <xsl:when test="*:conf/*:import"> <xsl:call-template name="xfe:resolve-conf"> <xsl:with-param name="conf" select="*:conf" as="element()"/> <xsl:with-param name="level" select="count(descendant::*:import)" as="xs:integer"/> </xsl:call-template> </xsl:when> <xsl:otherwise> <xsl:sequence select="."/> </xsl:otherwise> </xsl:choose> </xsl:template>  <xsl:template name="xfe:resolve-conf"> <xsl:param name="conf" required="yes" as="element()"/> <xsl:param name="level" required="yes" as="xs:integer"/> <xsl:choose> <xsl:when test="$level = 0"> <xsl:sequence select="$conf"/> </xsl:when> <xsl:otherwise> <xsl:variable name="conf.level-n" as="element()"> <xsl:apply-templates select="$conf" mode="xfe:resolve-conf"> <xsl:with-param name="level" select="$level" as="xs:integer" tunnel="yes"/> </xsl:apply-templates> </xsl:variable> <xsl:call-template name="xfe:resolve-conf"> <xsl:with-param name="conf" select="$conf.level-n" as="element()"/> <xsl:with-param name="level" select="$level - 1" as="xs:integer"/> </xsl:call-template> </xsl:otherwise> </xsl:choose> </xsl:template>  <xsl:template match="*:conf" mode="xfe:resolve-conf"> <xsl:param name="level" as="xs:integer" tunnel="yes"/> <xsl:choose> <xsl:when test="count($level) = 0"> <xsl:next-match/> </xsl:when> <xsl:when test="count(ancestor::*:import) = $level -1"> <xsl:variable name="importedConf" select="*:import/*:conf" as="element()"/> <xsl:copy> <xsl:copy-of select="@*"/> <xsl:choose> <xsl:when test="*:srngXmlmodel"> <xsl:apply-templates select="*:srngXmlmodel" mode="#current"/> </xsl:when> <xsl:otherwise> <xsl:apply-templates select="$importedConf/*:srngXmlmodel" mode="xfe:resolve-conf.copy-importedConf"/> </xsl:otherwise> </xsl:choose> <xsl:choose> <xsl:when test="*:title"> <xsl:apply-templates select="*:title" mode="#current"/> </xsl:when> <xsl:otherwise> <xsl:apply-templates select="$importedConf/*:title" mode="xfe:resolve-conf.copy-importedConf"/> </xsl:otherwise> </xsl:choose> <xsl:choose> <xsl:when test="*:css"> <xsl:apply-templates select="*:css" mode="#current"/> </xsl:when> <xsl:otherwise> <xsl:apply-templates select="$importedConf/*:css" mode="xfe:resolve-conf.copy-importedConf"/> </xsl:otherwise> </xsl:choose> <xsl:choose> <xsl:when test="*:mapping"> <xsl:apply-templates select="*:mapping" mode="#current"> <xsl:with-param name="importedConf" select="$importedConf" as="element()"/> </xsl:apply-templates> </xsl:when> <xsl:otherwise> <xsl:apply-templates select="$importedConf/*:mapping" mode="xfe:resolve-conf.copy-importedConf"/> </xsl:otherwise> </xsl:choose> </xsl:copy> </xsl:when> <xsl:otherwise> <xsl:next-match/> </xsl:otherwise> </xsl:choose> </xsl:template> <xsl:template match="*:mapping" mode="xfe:resolve-conf"> <xsl:param name="importedConf" as="element()?"/> <xsl:variable name="self" select="." as="element()"/> <xsl:copy> <xsl:copy-of select="@*"/>  <xsl:apply-templates mode="#current"/>  <xsl:for-each select="$importedConf/*:mapping/*:element"> <xsl:if test="not(concat(@xpath, '_', @xpath-filter) = $self/*:element/concat(@xpath, '_', @xpath-filter))"> <xsl:apply-templates select="." mode="xfe:resolve-conf.copy-importedConf"/> </xsl:if> </xsl:for-each> </xsl:copy> </xsl:template>  <xsl:template match="node() | @*" mode="xfe:resolve-conf xfe:resolve-conf.copy-importedConf" priority="-1"> <xsl:copy> <xsl:apply-templates select="node() | @*" mode="#current"/> </xsl:copy> </xsl:template>    <xsl:template match="*:element[@type = 'cals:table']" mode="normalizeConf.step1"> <xsl:variable name="element.name" select="tokenize(@xpath, '/')[last()]" as="xs:string"/> <xsl:variable name="nameCase" select="xfe:getTableCasePattern($element.name)" as="xs:string"/>   <xsl:copy> <xsl:copy-of select="@*"/>  <xsl:attribute name="html-name" select="'div'"/> <xsl:attribute name="html-addClass" select="'blocTableau'"/> <xsl:attribute name="label" select="(@label, xfe:getNameFromXpath(.))[1]"/> <xsl:attribute name="html-xmlNameAsClass" select="'false'"/> </xsl:copy> <element xpath="{@xpath}/{xfe:apply-case('tgroup', $nameCase)}" html-name="table" type="cals:tgroup" html-xmlNameAsClass="false"/> <element xpath="{@xpath}/tgroup/{xfe:apply-case('colspec', $nameCase)}" html-name="col" type="cals:colspec" html-xmlNameAsClass="false"/>  <element xpath="{@xpath}/{xfe:apply-case('tgroup', $nameCase)}/{xfe:apply-case('thead', $nameCase)}" html-name="thead" type="cals:thead" html-xmlNameAsClass="false"/> <element xpath="{@xpath}/{xfe:apply-case('tgroup', $nameCase)}/{xfe:apply-case('tbody', $nameCase)}" html-name="tbody" type="cals:tbody" html-xmlNameAsClass="false"/> <element xpath="{@xpath}/{xfe:apply-case('tgroup', $nameCase)}/{xfe:apply-case('tfoot', $nameCase)}" html-name="tfoot" type="cals:tfoot" html-xmlNameAsClass="false"/> <element xpath="{@xpath}/{xfe:apply-case('tgroup', $nameCase)}//{xfe:apply-case('row', $nameCase)}" html-name="tr" type="cals:row" html-xmlNameAsClass="false"/> <element xpath="{@xpath}/{xfe:apply-case('tgroup', $nameCase)}/{xfe:apply-case('tbody', $nameCase)}/{xfe:apply-case('row', $nameCase)}/{xfe:apply-case('entry', $nameCase)}" html-name="td" type="cals:entry" html-xmlNameAsClass="false"/> <element xpath="{@xpath}/{xfe:apply-case('tgroup', $nameCase)}/{xfe:apply-case('thead', $nameCase)}/{xfe:apply-case('row', $nameCase)}/{xfe:apply-case('entry', $nameCase)}" html-name="th" type="cals:entry" html-xmlNameAsClass="false"/>  </xsl:template>  <xsl:template match="*:element[@type = 'html:table']" mode="normalizeConf.step1"> <xsl:variable name="element.name" select="tokenize(@xpath, '/')[last()]" as="xs:string"/> <xsl:variable name="nameCase" select="xfe:getTableCasePattern($element.name)" as="xs:string"/>   <xsl:copy> <xsl:attribute name="html-name" select="'table'"/> <xsl:attribute name="html-xmlNameAsClass" select="'false'"/> <xsl:copy-of select="@*"/> </xsl:copy> <element xpath="{@xpath}/{xfe:apply-case('caption', $nameCase)}" html-name="caption" type="html:caption" html-xmlNameAsClass="false"/> <element xpath="{@xpath}/{xfe:apply-case('col', $nameCase)}" html-name="col" type="html:col" html-xmlNameAsClass="false"/> <element xpath="{@xpath}/{xfe:apply-case('colgroup', $nameCase)}" html-name="colgroup" type="html:colgroup" html-xmlNameAsClass="false"/> <element xpath="{@xpath}/{xfe:apply-case('thead', $nameCase)}" html-name="thead" type="html:thead" html-xmlNameAsClass="false"/> <element xpath="{@xpath}/{xfe:apply-case('tbody', $nameCase)}" html-name="tbody" type="html:tbody" html-xmlNameAsClass="false"/> <element xpath="{@xpath}/{xfe:apply-case('tfoot', $nameCase)}" html-name="tfoot" type="html:tfoot" html-xmlNameAsClass="false"/> <element xpath="{@xpath}/{xfe:apply-case('tr', $nameCase)}" html-name="tr" type="html:tr" html-xmlNameAsClass="false"/>  <element xpath="{@xpath}/{xfe:apply-case('td', $nameCase)}" html-name="td" type="html:td" html-xmlNameAsClass="false"/> <element xpath="{@xpath}/{xfe:apply-case('th', $nameCase)}" html-name="th" type="html:th" html-xmlNameAsClass="false"/> </xsl:template> <xsl:template match="*:element[starts-with(@type, 'xfe:title-')]" mode="normalizeConf.step1"> <xsl:variable name="level" select="substring-after(@type, 'xfe:title-')" as="xs:string"/> <xsl:copy> <xsl:apply-templates select="@*" mode="#current"/>   <xsl:attribute name="html-addClass" select="normalize-space(concat('xfe_title-', $level, ' ', @html-addClass))"/>  </xsl:copy> </xsl:template> <xsl:template match="*:element[starts-with(@type, 'xfe:list(')]" mode="normalizeConf.step1"> <xsl:copy> <xsl:attribute name="html-name" select="'ul'"/>  <xsl:apply-templates select="@* | node()" mode="#current"/> </xsl:copy> </xsl:template> <xsl:template match="*:element[starts-with(@type, 'xfe:externalLinkType')]" mode="normalizeConf.step1"> <xsl:copy>   <xsl:attribute name="html-name" select="'a'"/>  <xsl:apply-templates select="@*" mode="#current"/> </xsl:copy> </xsl:template> <xsl:template match="*:element[@type = 'xfe:inlineNote']" mode="normalizeConf.step1"> <xsl:copy> <xsl:apply-templates select="@*" mode="#current"/>   <xsl:attribute name="html-name" select="'a'"/> <xsl:attribute name="html-attribute-href"> <xsl:text>''</xsl:text>  </xsl:attribute> <xsl:attribute name="html-addClass" select="normalize-space(concat('xfe_noteRef', ' ', @html-addClass))"/>  </xsl:copy> </xsl:template>  <xsl:template match="*:element[starts-with(@type, 'xfe:noteRef(')]" mode="normalizeConf.step1"> <xsl:choose> <xsl:when test="matches(@type, 'xfe:noteRef$@\w+$')"> <xsl:variable name="idRefAttributeName" select="replace(@type, '^xfe:noteRef$@(\w+)$$', '$1')" as="xs:string"/> <xsl:copy> <xsl:apply-templates select="@*" mode="#current"/>   <xsl:attribute name="html-name" select="'a'"/> <xsl:attribute name="html-attribute-href">  <xsl:text>concat('#', @</xsl:text> <xsl:value-of select="$idRefAttributeName"/> <xsl:text>)</xsl:text> </xsl:attribute> <xsl:attribute name="html-addClass" select="normalize-space(concat('xfe_noteRef', ' ', @html-addClass))"/> <xsl:attribute name="html-ignoreXmlAttributes" select="normalize-space(concat(@html-ignoreXmlAttributes, ' ', $idRefAttributeName))"/>  </xsl:copy> </xsl:when> <xsl:otherwise> <xsl:call-template name="els:log"> <xsl:with-param name="xsltName" select="els:getFileName(static-base-uri())"/> <xsl:with-param name="code" select="$els:log.level.code"/> <xsl:with-param name="alert" select="true()"/> <xsl:with-param name="level" select="'error'"/> <xsl:with-param name="markup" select="false()"/> <xsl:with-param name="description">[ERROR] @type xfe:noteRef must include an attribute name used for idRef. it should look like xfe:noteRef(@idRefAttributeName)</xsl:with-param> </xsl:call-template> <xsl:message terminate="yes"/> </xsl:otherwise> </xsl:choose> </xsl:template> <xsl:template match="*:element[starts-with(@type, 'xfe:note(')]" mode="normalizeConf.step1"> <xsl:choose> <xsl:when test="matches(@type, 'xfe:note$@\w+$')"> <xsl:variable name="idAttributeName" select="replace(@type, '^xfe:note$@(\w+)$$', '$1')" as="xs:string"/> <xsl:copy> <xsl:apply-templates select="@*" mode="#current"/>   <xsl:attribute name="html-attribute-id">  <xsl:text>@</xsl:text> <xsl:value-of select="$idAttributeName"/> </xsl:attribute> <xsl:attribute name="html-addClass" select="normalize-space(concat('xfe_note', ' ', @html-addClass))"/> <xsl:attribute name="html-ignoreXmlAttributes" select="normalize-space(concat(@html-ignoreXmlAttributes, ' ', $idAttributeName))"/>  </xsl:copy> </xsl:when> <xsl:otherwise> <xsl:call-template name="els:log"> <xsl:with-param name="xsltName" select="els:getFileName(static-base-uri())"/> <xsl:with-param name="code" select="$els:log.level.code"/> <xsl:with-param name="alert" select="true()"/> <xsl:with-param name="level" select="'error'"/> <xsl:with-param name="markup" select="false()"/> <xsl:with-param name="description">[ERROR] @type xfe:note must include an attribute name used for idRef. it should look like xfe:note(@idRefAttributeName)</xsl:with-param> </xsl:call-template> <xsl:message terminate="yes"/> </xsl:otherwise> </xsl:choose> </xsl:template> <xsl:template match="*:element[starts-with(@type, 'xfe:multimediaLink(')]" mode="normalizeConf.step1"> <xsl:choose> <xsl:when test="matches(@type, 'xfe:multimediaLink$@\w+$')"> <xsl:variable name="idRefAttributeName" select="replace(@type, '^xfe:multimediaLink$@(\w+)$$', '$1')" as="xs:string"/> <xsl:copy> <xsl:apply-templates select="@*" mode="#current"/>   <xsl:attribute name="html-name" select="'a'"/> <xsl:attribute name="html-attribute-href">  <xsl:text>concat('</xsl:text> <xsl:value-of select="$xfe:media.url.path"/> <xsl:text>', @</xsl:text> <xsl:value-of select="$idRefAttributeName"/> <xsl:text>)</xsl:text> </xsl:attribute> <xsl:attribute name="html-addClass" select="normalize-space(concat('xfe_multimediaLink', ' ', @html-addClass))"/> <xsl:attribute name="html-ignoreXmlAttributes" select="normalize-space(concat(@html-ignoreXmlAttributes, ' ', $idRefAttributeName))"/>  </xsl:copy> </xsl:when> <xsl:otherwise> <xsl:call-template name="els:log"> <xsl:with-param name="xsltName" select="els:getFileName(static-base-uri())"/> <xsl:with-param name="code" select="$els:log.level.code"/> <xsl:with-param name="alert" select="true()"/> <xsl:with-param name="level" select="'error'"/> <xsl:with-param name="markup" select="false()"/> <xsl:with-param name="description">[ERROR] @type xfe:multimediaLink must include an attribute name used for idRef. it should look like xfe:multimediaLink(@idRefAttributeName)</xsl:with-param> </xsl:call-template> <xsl:message terminate="yes"/> </xsl:otherwise> </xsl:choose> </xsl:template>   <xsl:template match="*:element" mode="normalizeConf.step2"> <xsl:copy>   <xsl:apply-templates select="@*" mode="#current"/> <xsl:attribute name="label" select="(@label, tokenize(@xpath, '/')[last()])[1]"/> <xsl:if test="$xfe:conf.hasSchema"> <xsl:attribute name="srng-defines"> <xsl:variable name="xpath.token" select="tokenize(@xpath, '/')" as="xs:string*"/> <xsl:choose>  <xsl:when test="starts-with(@xpath, '/') and not(starts-with(@xpath, '//'))"> <xsl:value-of select="rng:getSRNGdataModelFromXpath(@xpath, $xfe:srng.grammar.normalized, @xpath-filter)/parent::rng:define/@name"/>  </xsl:when> <xsl:otherwise> <xsl:variable name="xpath.elementName" select="xfe:getNameFromXpath(.)" as="xs:string"/> <xsl:variable name="rngDefinesByName" select="$xfe:srng.grammar.normalized//rng:define[rng:element[1][@name = $xpath.elementName]]" as="element(rng:define)*"/> <xsl:choose>  <xsl:when test="count($rngDefinesByName) = 0"> <xsl:call-template name="els:log"> <xsl:with-param name="xsltName" select="els:getFileName(static-base-uri())"/> <xsl:with-param name="code" select="$els:log.level.code"/> <xsl:with-param name="alert" select="true()"/> <xsl:with-param name="level" select="'fatal'"/> <xsl:with-param name="markup" select="false()"/> <xsl:with-param name="description">[FATAL] 0 define pour <xsl:copy-of select="$xpath.token"/> (dans conf /element/@xpath='<xsl:value-of select="@xpath"/>')</xsl:with-param> </xsl:call-template> <xsl:message terminate="yes"/> </xsl:when>  <xsl:when test="count($rngDefinesByName) = 1"> <xsl:value-of select="$rngDefinesByName/@name"/> </xsl:when>  <xsl:when test="count($xpath.token) = 1">  <xsl:variable name="xpath-filter" select="normalize-space(@xpath-filter)" as="xs:string"/> <xsl:variable name="xpath.attributeValueTest.reg" as="xs:string"> <xsl:text>^@(.*?)\s*=\s*'(.*?)'</xsl:text> </xsl:variable> <xsl:variable name="rngDefinesByName.xpath-filtered" as="element()*"> <xsl:choose> <xsl:when test="matches($xpath-filter, $xpath.attributeValueTest.reg)"> <xsl:variable name="att.name" select="replace($xpath-filter, $xpath.attributeValueTest.reg, '$1' )" as="xs:string"/> <xsl:variable name="att.value" select="replace($xpath-filter, $xpath.attributeValueTest.reg, '$2' )" as="xs:string"/> <xsl:message use-when="false()">[DEBUG] MATCHES <xsl:value-of select="$xpath-filter"/> [name=<xsl:value-of select="$att.name"/>][value=<xsl:value-of select="$att.value"/>]</xsl:message> <xsl:sequence select="$rngDefinesByName[.//rng:attribute[@name = $att.name][count(*)=1][rng:value = $att.value]]"/> <xsl:message use-when="false()">count $rngDefinesByName = <xsl:value-of select="count($rngDefinesByName)"/></xsl:message> <xsl:message use-when="false()">count $rngDefinesByName filtered = <xsl:value-of select="count($rngDefinesByName[.//rng:attribute[@name = $att.name][count(*)=1][rng:value = $att.value]])"/></xsl:message> </xsl:when> <xsl:otherwise> <xsl:sequence select="$rngDefinesByName"/> </xsl:otherwise> </xsl:choose> </xsl:variable> <xsl:choose> <xsl:when test="count($rngDefinesByName.xpath-filtered) = 0"> <xsl:value-of select="$rngDefinesByName/@name" separator=" "/> <xsl:call-template name="els:log"> <xsl:with-param name="xsltName" select="els:getFileName(static-base-uri())"/> <xsl:with-param name="code" select="$els:log.level.code"/> <xsl:with-param name="alert" select="true()"/> <xsl:with-param name="level" select="'error'"/> <xsl:with-param name="markup" select="false()"/> <xsl:with-param name="description">[ERROR] 0 define found for <xsl:copy-of select="$xpath.token"/> (in conf : /element/@xpath='<xsl:value-of select="@xpath"/>')</xsl:with-param> </xsl:call-template> </xsl:when> <xsl:otherwise> <xsl:value-of select="$rngDefinesByName.xpath-filtered/@name" separator=" "/> </xsl:otherwise> </xsl:choose> </xsl:when> <xsl:otherwise>  <xsl:variable name="xpath.parentName" select="$xpath.token[last() - 1]" as="xs:string"/> <xsl:variable name="rngDefines.parent" select="$xfe:srng.grammar.normalized//rng:define[rng:element[1][@name = $xpath.parentName]]" as="element(rng:define)*"/> <xsl:variable name="rngDefines.filter" as="element(rng:define)*"> <xsl:for-each select="$rngDefinesByName"> <xsl:variable name="rngDefine" select="." as="element(rng:define)"/> <xsl:if test="$rngDefines.parent[rng:defineHasRefName(., $rngDefine/@name)]"> <xsl:sequence select="."/> </xsl:if> </xsl:for-each> </xsl:variable> <xsl:value-of select="$rngDefines.filter/@name" separator=" "/>  </xsl:otherwise> </xsl:choose> </xsl:otherwise> </xsl:choose> </xsl:attribute> </xsl:if> <xsl:apply-templates mode="#current"/> </xsl:copy> </xsl:template>   <xsl:template match="@xpath" mode="normalizeConf.step2"> <xsl:attribute name="{name(.)}"> <xsl:choose> <xsl:when test="starts-with(., '/')"> <xsl:value-of select="."/> </xsl:when> <xsl:otherwise> <xsl:value-of select="concat('//', .)"/> </xsl:otherwise> </xsl:choose> </xsl:attribute> </xsl:template>  <xsl:template match="/*:conf/*:mapping" mode="normalizeConf.step3"> <xsl:variable name="self" select="self::*" as="element()"/> <xsl:copy> <xsl:apply-templates select="@*" mode="#current"/> <xsl:apply-templates select="node()" mode="#current"/> <xsl:comment>==============================</xsl:comment> <xsl:comment> GENERATED FROM SCHEMA</xsl:comment> <xsl:comment>==============================</xsl:comment> <xsl:apply-templates select="$xfe:srng/rng:grammar/rng:define" mode="normalizeConf.step3.iterate-srng"> <xsl:with-param name="mapping" select="$self" as="element()"/> </xsl:apply-templates> </xsl:copy> </xsl:template>  <xsl:template match="rng:define[@name = rng:getRootDefines(/rng:grammar)/@name]" mode="normalizeConf.step3.iterate-srng"> <xsl:message use-when="false()"><xsl:value-of select="@name"/> is root define, non need to add it in the conf</xsl:message> </xsl:template> <xsl:template match="rng:define" mode="normalizeConf.step3.iterate-srng"> <xsl:param name="mapping" as="element()"/> <xsl:variable name="rng:element" select="rng:element" as="element(rng:element)"/> <xsl:variable name="rng:element.name" select="rng:element/@name" as="xs:string"/>   <xsl:variable name="parent.names" select="key('rng:getRefByName', @name)/ancestor::rng:define/rng:element[1]/@name" as="xs:string*"/> <xsl:variable name="unspecified-parent-context-in-conf" as="xs:string*"> <xsl:choose> <xsl:when test="count($mapping/*:element[@xpath = concat('//', $rng:element/@name)]) != 0">  </xsl:when> <xsl:otherwise> <xsl:variable name="conf.specified.contexts" select="$mapping/*:element[xfe:getNameFromXpath(.) = $rng:element.name]/@xpath" as="xs:string*"/> <xsl:for-each select="$parent.names"> <xsl:variable name="context" select="concat('//', ., '/', $rng:element.name)" as="xs:string"/> <xsl:if test="not($context = $conf.specified.contexts)"> <xsl:value-of select="."/> </xsl:if> </xsl:for-each> </xsl:otherwise> </xsl:choose> </xsl:variable> <xsl:if test="@name = 'infoCommentaire'"> <xsl:message><xsl:value-of select="@name"/> : <xsl:value-of select="$unspecified-parent-context-in-conf"/></xsl:message> </xsl:if> <xsl:choose> <xsl:when test="count($unspecified-parent-context-in-conf) = 0"/> <xsl:otherwise> <xsl:variable name="html.default.name" as="xs:string"> <xsl:choose> <xsl:when test="rng:isInlineOnly($rng:element, $unspecified-parent-context-in-conf)"> <xsl:text>span</xsl:text> </xsl:when> <xsl:when test="rng:isBlockOnly($rng:element, $unspecified-parent-context-in-conf)"> <xsl:text>div</xsl:text> </xsl:when> <xsl:otherwise> <xsl:text>spanOrdiv</xsl:text> <xsl:call-template name="els:log"> <xsl:with-param name="xsltName" select="els:getFileName(static-base-uri())"/> <xsl:with-param name="code" select="$els:log.level.code"/> <xsl:with-param name="alert" select="true()"/> <xsl:with-param name="level" select="'fatal'"/> <xsl:with-param name="markup" select="false()"/> <xsl:with-param name="xpathContext" select="'_null'"/> <xsl:with-param name="description">[normalizeConf.step3.iterate-srng] Unable to add missing conf element for srng define "<xsl:value-of select="@name"/>". The element might be inline or block depending on the context. Please remove this ambiguity (see the documentation at main/conf/xfe-conf.md)</xsl:with-param> </xsl:call-template> <xsl:message terminate="yes"/> </xsl:otherwise> </xsl:choose> </xsl:variable> <element xpath="{concat('//', $rng:element/@name)}" html-name="{$html.default.name}" srng-defines="{self::rng:define/@name}"/> </xsl:otherwise> </xsl:choose> </xsl:template>  <xsl:template match="node() | @*" mode="normalizeConf.step1 normalizeConf.step2 normalizeConf.step3"> <xsl:copy> <xsl:apply-templates select="node() | @*" mode="#current"/> </xsl:copy> </xsl:template>     <xsl:template match="rng:define" mode="xfe:srng_duplicateDefineByAttributeValue"> <xsl:variable name="self" select="self::*" as="element()"/> <xsl:variable name="duplicate-define" select="xfe:srng_getConfDuplicatedDefine(.)" as="element()?"/>  <xsl:choose> <xsl:when test="count($duplicate-define) != 0"> <xsl:variable name="attribute-name" select="$duplicate-define/@attribute-name" as="xs:string"/> <xsl:for-each select=".//rng:attribute[@name = $attribute-name]/rng:choice/rng:value"> <xsl:variable name="value" select="." as="xs:string"/> <xsl:apply-templates select="$self" mode="xfe:srng_duplicateDefineByAttributeValue-copy"> <xsl:with-param name="attribute-name" select="$attribute-name" tunnel="yes"/> <xsl:with-param name="value" select="$value" tunnel="yes"/> </xsl:apply-templates> </xsl:for-each> </xsl:when> <xsl:otherwise> <xsl:next-match/> </xsl:otherwise> </xsl:choose> </xsl:template> <xsl:template match="rng:define" mode="xfe:srng_duplicateDefineByAttributeValue-copy"> <xsl:param name="value" as="xs:string" tunnel="yes"/> <xsl:copy copy-namespaces="no"> <xsl:apply-templates select="@*" mode="#current"/> <xsl:attribute name="name" select="xfe:srng_duplicatedDefineRenameDef(@name, $value)"/> <xsl:apply-templates select="node()" mode="#current"/> </xsl:copy> </xsl:template>  <xsl:template match="rng:attribute/rng:choice" mode="xfe:srng_duplicateDefineByAttributeValue-copy"> <xsl:param name="attribute-name" as="xs:string" tunnel="yes"/> <xsl:param name="value" as="xs:string" tunnel="yes"/> <xsl:choose> <xsl:when test="ancestor::rng:attribute[1]/@name = $attribute-name">  <xsl:apply-templates mode="#current"/> </xsl:when> <xsl:otherwise> <xsl:next-match/> </xsl:otherwise> </xsl:choose> </xsl:template>  <xsl:template match="rng:attribute/rng:choice/rng:value" mode="xfe:srng_duplicateDefineByAttributeValue-copy"> <xsl:param name="attribute-name" as="xs:string" tunnel="yes"/> <xsl:param name="value" as="xs:string" tunnel="yes"/> <xsl:choose> <xsl:when test="ancestor::rng:attribute[1]/@name = $attribute-name and . != $value">  </xsl:when> <xsl:otherwise> <xsl:next-match/> </xsl:otherwise> </xsl:choose> </xsl:template> <xsl:template match="rng:ref" mode="xfe:srng_duplicateDefineByAttributeValue xfe:srng_duplicateDefineByAttributeValue-copy"> <xsl:variable name="self" select="self::*" as="element()"/> <xsl:variable name="define" select="rng:getDefine(.)" as="element(rng:define)"/> <xsl:variable name="duplicate-define" select="xfe:srng_getConfDuplicatedDefine($define)" as="element()?"/> <xsl:choose> <xsl:when test="count($duplicate-define) != 0"> <choice xmlns="http://relaxng.org/ns/structure/1.0"> <xsl:for-each select="$define//rng:attribute[@name = $duplicate-define/@attribute-name]/rng:choice/rng:value"> <ref name="{xfe:srng_duplicatedDefineRenameDef($self/@name, .)}"/> </xsl:for-each> </choice> </xsl:when> <xsl:otherwise> <xsl:next-match/> </xsl:otherwise> </xsl:choose> </xsl:template> <xsl:function name="xfe:srng_duplicatedDefineRenameDef" as="xs:string"> <xsl:param name="define.name" as="xs:string"/> <xsl:param name="attribute.value" as="xs:string"/> <xsl:value-of select="concat($define.name, '_', normalize-space(string-join(tokenize($attribute.value, '\s+'), '_')))"/> </xsl:function> <xsl:function name="xfe:srng_getConfDuplicatedDefine" as="element()?"> <xsl:param name="define" as="element(rng:define)"/> <xsl:sequence select="$xfe:conf.resolved/*:conf/*:srngXmlmodel/*:duplicate-define [@element-name = $define/rng:element/@name] [@attribute-name = $define//rng:attribute[count(*) = 1][rng:choice][count(rng:choice/rng:value) = count(rng:choice/*)]/@name]"/> </xsl:function>  <xsl:template match="node() | @*" mode="xfe:srng_duplicateDefineByAttributeValue xfe:srng_duplicateDefineByAttributeValue-copy"> <xsl:copy> <xsl:apply-templates select="node() | @*" mode="#current"/> </xsl:copy> </xsl:template>        <xsl:template name="xfe:log.normalizeConf"> <xsl:if test="$xfe:debug"> <xsl:variable name="step.log.uri" select="resolve-uri('conf.resolved.xml', $log.uri)" as="xs:anyURI"/> <xsl:call-template name="els:log"> <xsl:with-param name="xsltName" select="els:getFileName(static-base-uri())"/> <xsl:with-param name="code" select="$els:log.level.code"/> <xsl:with-param name="alert" select="true()"/> <xsl:with-param name="markup" select="false()"/> <xsl:with-param name="description">[INFO] writing <xsl:value-of select="$step.log.uri"/></xsl:with-param> </xsl:call-template> <xsl:result-document href="{$step.log.uri}" format="els:xml"> <xsl:sequence select="$xfe:conf.resolved"/> </xsl:result-document> <xsl:variable name="step.log.uri" select="resolve-uri('conf.normalized.xml', $log.uri)" as="xs:anyURI"/> <xsl:call-template name="els:log"> <xsl:with-param name="xsltName" select="els:getFileName(static-base-uri())"/> <xsl:with-param name="code" select="$els:log.level.code"/> <xsl:with-param name="alert" select="true()"/> <xsl:with-param name="markup" select="false()"/> <xsl:with-param name="description">[INFO] writing <xsl:value-of select="$step.log.uri"/></xsl:with-param> </xsl:call-template> <xsl:result-document href="{$step.log.uri}" format="els:xml"> <xsl:sequence select="$xfe:conf.normalized"/> </xsl:result-document> <xsl:if test="$xfe:conf.hasSchema"> <xsl:variable name="step.log.uri" select="resolve-uri('srng.grammar.normalized.srng', $log.uri)" as="xs:anyURI"/> <xsl:result-document href="{$step.log.uri}" format="els:xml"> <xsl:sequence select="$xfe:srng.grammar.normalized"/> </xsl:result-document> </xsl:if> </xsl:if> </xsl:template>   <xsl:function name="xf:getConfMappingElementsFromSrng" as="element()*"> <xsl:param name="rngElement" as="element(rng:element)"/> <xsl:variable name="define" select="$rngElement/parent::rng:define" as="element(rng:define)"/> <xsl:sequence select="$xfe:conf.normalized/*:mapping/*:element[xfe:confElementHasRngDefine(., $define/@name)]"/> </xsl:function> <xsl:function name="xfe:getTableCasePattern" as="xs:string"> <xsl:param name="elementName" as="xs:string"/> <xsl:choose> <xsl:when test="upper-case($elementName) = $elementName"> <xsl:value-of select="'uppercase'"/> </xsl:when> <xsl:when test="lower-case($elementName) = $elementName"> <xsl:value-of select="'lowercase'"/> </xsl:when> <xsl:when test="upper-case(substring($elementName, 1, 1)) = substring($elementName, 1, 1) and lower-case(substring($elementName, 2)) = substring($elementName, 2)"> <xsl:value-of select="'titlecase'"/> </xsl:when> <xsl:otherwise> <xsl:value-of select="'error'"/> <xsl:call-template name="els:log"> <xsl:with-param name="xsltName" select="els:getFileName(static-base-uri())"/> <xsl:with-param name="code" select="$els:log.level.code"/> <xsl:with-param name="alert" select="true()"/> <xsl:with-param name="level" select="'fatal'"/> <xsl:with-param name="markup" select="false()"/> <xsl:with-param name="xpathContext" select="'_null'"/> <xsl:with-param name="description">[FATAL][xfe:getTableCasePattern] Impossible de déduire le modèle de nommage des tableaux (uppercase, lowercase ot titlecase)</xsl:with-param> </xsl:call-template> <xsl:message terminate="yes"/> </xsl:otherwise> </xsl:choose> </xsl:function> <xsl:function name="xfe:apply-case" as="xs:string"> <xsl:param name="string" as="xs:string"/> <xsl:param name="nameCase" as="xs:string"/> <xsl:choose> <xsl:when test="$nameCase = 'uppercase'"> <xsl:sequence select="upper-case($string)"/> </xsl:when> <xsl:when test="$nameCase = 'lowercase'"> <xsl:sequence select="lower-case($string)"/> </xsl:when> <xsl:when test="$nameCase = 'titlecase'"> <xsl:sequence select="concat(upper-case(substring($string, 1, 1)), lower-case(substring($string, 2)))"/> </xsl:when> <xsl:otherwise> <xsl:sequence select="$string"/> </xsl:otherwise> </xsl:choose> </xsl:function>     <xsl:function name="xfe:getConfMappingElementsFromXML" as="element()*"> <xsl:param name="e" as="element()"/> <xsl:choose> <xsl:when test="$xfe:conf.hasSchema"> <xsl:variable name="e.define.name" as="xs:string"> <xsl:choose> <xsl:when test="$e/@xfe:srng-define != ''"> <xsl:value-of select="$e/@xfe:srng-define"/> </xsl:when> <xsl:otherwise> <xsl:variable name="e.dataModel" select="rng:getSRNGdataModelFromXmlElement($e, $xfe:srng.grammar.normalized)" as="element(rng:element)"/> <xsl:variable name="e.define" select="$e.dataModel/parent::rng:define" as="element(rng:define)"/> <xsl:value-of select="$e.define/@name"/> </xsl:otherwise> </xsl:choose> </xsl:variable> <xsl:sequence select="xfe:getConfMappingElementsFromXML($e, $e.define.name)"/> </xsl:when> <xsl:otherwise> <xsl:sequence select="xfe:getConfMappingElementsFromXML($e, ())"/> </xsl:otherwise> </xsl:choose> </xsl:function> <xd:doc> <xd:desc> <xd:p>Get all conf elements corresponding to the $e xml element instance : whether xpath based or sharing the same define in the schema</xd:p> <xd:p>Remember we add the schema define name to every conf elements</xd:p> <xd:p>Beware of the plural (elementS) in the name of the function, see the other function "xfe:getConfMappingElementFromXML" (which take the last element) </xd:p> </xd:desc> <xd:param name="e">xml element in xml instance</xd:param> <xd:return>Zero or more conf elements corresponding</xd:return> </xd:doc> <xsl:function name="xfe:getConfMappingElementsFromXML" as="element()*"> <xsl:param name="e" as="element()"/> <xsl:param name="e.define.name" as="xs:string?"/>   <xsl:variable name="conf.elements" as="element()*"> <xsl:choose> <xsl:when test="$xfe:conf.hasSchema and empty($e.define.name)"> <xsl:call-template name="els:log"> <xsl:with-param name="xsltName" select="els:getFileName(static-base-uri())"/> <xsl:with-param name="code" select="$els:log.level.code"/> <xsl:with-param name="alert" select="true()"/> <xsl:with-param name="level" select="'fatal'"/> <xsl:with-param name="markup" select="false()"/> <xsl:with-param name="description">[FATAL] Calling xfe:getConfMappingElementsFromXML with an empty sequence as 2nd agrument "e.define.name" is not allowed when $xfe:conf.hasSchema is true</xsl:with-param> </xsl:call-template> <xsl:message terminate="yes"/> </xsl:when> <xsl:when test="$xfe:conf.hasSchema"> <xsl:sequence select="$xfe:conf.normalized/*:mapping/*:element[xfe:confElementHasRngDefine(., $e.define.name)]"/> </xsl:when> <xsl:otherwise> <xsl:sequence select="$xfe:conf.normalized/*:mapping/*:element"/> </xsl:otherwise> </xsl:choose> </xsl:variable> <xsl:choose> <xsl:when test="count($conf.elements) = 1"> <xsl:sequence select="$conf.elements"/> </xsl:when> <xsl:otherwise> <xsl:variable name="conf.matching.elements" as="element()*"> <xsl:for-each select="$conf.elements[tokenize(@xpath, '/')[last()] = local-name($e)]"> <xsl:variable name="conf.element" select="." as="element()"/> <xsl:variable name="xpath-with-filter" select="if(@xpath-filter) then(concat(@xpath, '[', @xpath-filter,']')) else(@xpath)" as="xs:string"/> <xsl:variable name="xml.matching.elements" select="els:evaluate-xpath($xpath-with-filter, $e/root()/*)" as="element()*"/> <xsl:if test="generate-id($e) = $xml.matching.elements/generate-id(.)"> <xsl:sequence select="$conf.element"/> </xsl:if> </xsl:for-each> </xsl:variable> <xsl:variable name="conf.matching.elements.theMorePreciseXpath" as="element()*" select="$conf.matching.elements[ count(tokenize(@xpath, '/')) = max( for $e in $conf.matching.elements return count(tokenize($e/@xpath, '/')) )]"/> <xsl:choose>  <xsl:when test="count($conf.matching.elements.theMorePreciseXpath) != 0"> <xsl:sequence select="$conf.matching.elements.theMorePreciseXpath"/> </xsl:when> <xsl:when test="not($xfe:conf.hasSchema)">  </xsl:when>  <xsl:otherwise>  <xsl:variable name="e.srng-define" select="$e.define.name" as="xs:string"/> <xsl:variable name="e.define" select="$xfe:srng.grammar.normalized//rng:define[@name = $e.srng-define]" as="element(rng:define)?"/> <xsl:variable name="conf.matchingDefine.elements" as="element()*">  <xsl:if test="count($e.define) != 0"> <xsl:sequence select="$conf.elements[xfe:confElementHasRngDefine(., $e.define.name)]"/> </xsl:if> </xsl:variable> <xsl:if test="count($conf.matchingDefine.elements) != 0"> <xsl:call-template name="els:log"> <xsl:with-param name="xsltName" select="els:getFileName(static-base-uri())"/> <xsl:with-param name="code" select="$els:log.level.code"/> <xsl:with-param name="alert" select="true()"/> <xsl:with-param name="markup" select="false()"/> <xsl:with-param name="xpathContext" select="$e"/> <xsl:with-param name="description">[INFO] surcharge de conf induite sur <xsl:value-of select="els:displayNode($e)"/></xsl:with-param> </xsl:call-template>  <xsl:if test="count($conf.matchingDefine.elements) gt 1"> <xsl:call-template name="els:log"> <xsl:with-param name="xsltName" select="els:getFileName(static-base-uri())"/> <xsl:with-param name="code" select="$els:log.level.code"/> <xsl:with-param name="level" select="'warning'"/> <xsl:with-param name="alert" select="true()"/> <xsl:with-param name="markup" select="false()"/> <xsl:with-param name="xpathContext" select="$e"/> <xsl:with-param name="description"> <xsl:value-of select="concat('[WARNING] ', count($conf.matchingDefine.elements), ' elements de surcharge induite sur ', els:displayNode($e), ', on a pris le dernier ?')"/> <xsl:value-of select="concat('
 xpath : ', els:get-xpath($e))"/> <xsl:for-each select="$conf.matchingDefine.elements"> <xsl:value-of select="concat('
 ', els:displayNode($e))"/> </xsl:for-each> </xsl:with-param> </xsl:call-template> </xsl:if> <xsl:sequence select="$conf.matchingDefine.elements[last()]"/> </xsl:if> </xsl:otherwise> </xsl:choose> </xsl:otherwise> </xsl:choose> </xsl:function> <xsl:function name="xfe:confElementHasRngDefine" as="xs:boolean"> <xsl:param name="e" as="element()"/>  <xsl:param name="defineName" as="xs:string"/> <xsl:sequence select="tokenize($e/@srng-defines, ' ') = $defineName"/> </xsl:function> <xsl:function name="xfe:getConfMappingElementFromXML" as="element()*"> <xsl:param name="e" as="element()"/>  <xsl:sequence select="xfe:getConfMappingElementsFromXML($e)[last()]"/> </xsl:function>      <xsl:function name="xfe:getConfMappingFromHTML" as="element()?">  <xsl:param name="e" as="element()"/>  <xsl:variable name="class1" select="tokenize($e/@class, '\s+')[1]" as="xs:string?"/> <xsl:variable name="name" select="local-name($e)" as="xs:string?"/> <xsl:choose>      <xsl:when test="$e/self::div/table">  </xsl:when> <xsl:when test="local-name($e) = ('table' , 'colgroup' , 'col' , 'thead' , 'tbody' , 'tfoot' , 'tr' , 'td' , 'th') or local-name($e) = ('tgroup', 'colspec', 'thead', 'tbody', 'tfoot', 'row', 'entry')">  </xsl:when>   <xsl:when test="some $class in tokenize($e/@class, $els:regAnySpace) satisfies (starts-with($class, 'xfe_title-'))"> <xsl:variable name="xfe_title.class" select="(tokenize($e/@class, $els:regAnySpace)[starts-with(., 'xfe_title-')])[1]" as="xs:string"/> <xsl:variable name="conf.mappingElements" select="$xfe:conf.normalized/*:mapping/*:element[@html-addClass = $xfe_title.class]" as="element()*"/> <xsl:sequence select="xfe:applyCommonfiltersOnConfMappingElements($e, $conf.mappingElements)"/> </xsl:when>   <xsl:when test="$e/@*[local-name(.) = concat($xfe:dataXfeAttribute.prefix, 'listType')]">  <xsl:variable name="conf.mappingElements" select="$xfe:conf.normalized/*:mapping/*:element[starts-with(@type, 'xfe:list(')][@html-name = $name]" as="element()*"/> <xsl:sequence select="xfe:applyCommonfiltersOnConfMappingElements($e, $conf.mappingElements)"/> </xsl:when>     <xsl:when test="els:hasClass($e, 'xfe_noteRef')"> <xsl:variable name="conf.mappingElements" as="element()*" select="$xfe:conf.normalized/*:mapping/*:element[starts-with(@type, 'xfe:noteRef') or @type = 'xfe:inlineNote']"/> <xsl:sequence select="xfe:applyCommonfiltersOnConfMappingElements($e, $conf.mappingElements)"/> </xsl:when> <xsl:when test="els:hasClass($e, 'xfe_note')"> <xsl:variable name="conf.mappingElements" as="element()*" select="$xfe:conf.normalized/*:mapping/*:element[starts-with(@type, 'xfe:note(')]"/> <xsl:sequence select="xfe:applyCommonfiltersOnConfMappingElements($e, $conf.mappingElements)"/> </xsl:when>        <xsl:otherwise>   <xsl:variable name="conf.mappingElements" select="$xfe:conf.normalized/*:mapping/*:element [not(@type = 'cals:table')] [not(@type = 'html:table')] [not(starts-with(@type, 'xfe:title-'))] [not(starts-with(@type, 'xfe:list('))] [not(starts-with(@type, 'xfe:noteRef('))] [not(starts-with(@type, 'xfe:note('))] [not(@type = 'inlineNote')] " as="element()*"/> <xsl:sequence select="xfe:applyCommonfiltersOnConfMappingElements($e, $conf.mappingElements)"/> </xsl:otherwise> </xsl:choose> </xsl:function>  <xsl:function name="xfe:applyCommonfiltersOnConfMappingElements" as="element()?"> <xsl:param name="e" as="element()"/> <xsl:param name="conf.mappingElements" as="element()*"/>  <xsl:variable name="class1" select="normalize-space(tokenize($e/@class, '\s+')[1][not(starts-with(., 'xfe_'))])" as="xs:string?"/> <xsl:variable name="name" select="local-name($e)" as="xs:string?"/> <xsl:message use-when="false()">[DEBUG][xfe:applyCommonfiltersOnConfMappingElements] e=<xsl:value-of select="els:displayNode($e)"/></xsl:message> <xsl:message use-when="false()">[DEBUG][xfe:applyCommonfiltersOnConfMappingElements] name=<xsl:value-of select="$name"/> class1=<xsl:value-of select="$class1"/></xsl:message> <xsl:message use-when="false()">[DEBUG][xfe:applyCommonfiltersOnConfMappingElements] count($conf.mappingElements) = <xsl:value-of select="count($conf.mappingElements)"/></xsl:message> <xsl:variable name="conf.mappingElements.filtered" as="element()*"> <xsl:choose> <xsl:when test="count($conf.mappingElements) = 0"> <xsl:call-template name="els:log"> <xsl:with-param name="xsltName" select="els:getFileName(static-base-uri())"/> <xsl:with-param name="code" select="$els:log.level.code"/> <xsl:with-param name="alert" select="true()"/> <xsl:with-param name="markup" select="false()"/> <xsl:with-param name="xpathContext" select="$e"/> <xsl:with-param name="description">[INFO][xfe:applyCommonfiltersOnConfMappingElements] No elements found in conf for html <xsl:value-of select="els:displayNode($e)"/>. </xsl:with-param> </xsl:call-template> </xsl:when> <xsl:when test="count($conf.mappingElements) = 1"> <xsl:sequence select="$conf.mappingElements"/> </xsl:when> <xsl:otherwise> <xsl:variable name="conf.mappingElements.filteredByHtmlName" as="element()*"> <xsl:choose>  <xsl:when test="$name = ('span', 'div')">   <xsl:sequence select="$conf.mappingElements"/> </xsl:when>  <xsl:otherwise> <xsl:sequence select="$conf.mappingElements[@html-name = $name]"/> </xsl:otherwise> </xsl:choose> </xsl:variable> <xsl:message use-when="false()">[DEBUG][xfe:applyCommonfiltersOnConfMappingElements] count($conf.mappingElements.filteredByHtmlName) = <xsl:value-of select="count($conf.mappingElements.filteredByHtmlName)"/></xsl:message> <xsl:choose> <xsl:when test="count($conf.mappingElements.filteredByHtmlName) = 1"> <xsl:sequence select="$conf.mappingElements.filteredByHtmlName"/> </xsl:when> <xsl:otherwise> <xsl:variable name="conf.mappingElements.filteredByClass" as="element()*"> <xsl:choose>  <xsl:when test="$class1 = ''"> <xsl:sequence select="$conf.mappingElements.filteredByHtmlName[@html-xmlNameAsClass = 'false']"/> </xsl:when>  <xsl:otherwise> <xsl:variable name="conf.mappingElements.filteredByXmlNameAsClass" as="element()*" select="$conf.mappingElements.filteredByHtmlName[xfe:getNameFromXpath(.) = $class1]"/>  <xsl:choose> <xsl:when test="count($conf.mappingElements.filteredByXmlNameAsClass) = (0, 1)"> <xsl:sequence select="$conf.mappingElements.filteredByXmlNameAsClass"/> </xsl:when> <xsl:otherwise>  <xsl:variable name="conf.mappingElements.filteredByHtmlAddClass" as="element()*"> <xsl:choose>  <xsl:when test="count($conf.mappingElements.filteredByXmlNameAsClass[@html-addClass]) = 0">  <xsl:sequence select="$conf.mappingElements.filteredByXmlNameAsClass"/> </xsl:when>  <xsl:when test="count($conf.mappingElements.filteredByXmlNameAsClass[tokenize(@html-addClass, '\s+') = tokenize($e/@class, '\s+')]) != 0">  <xsl:sequence select="$conf.mappingElements.filteredByXmlNameAsClass[tokenize(@html-addClass, '\s+') = tokenize($e/@class, '\s+')]"/> </xsl:when> <xsl:otherwise>   <xsl:sequence select="$conf.mappingElements.filteredByXmlNameAsClass"/> </xsl:otherwise> </xsl:choose> </xsl:variable> <xsl:sequence select="$conf.mappingElements.filteredByHtmlAddClass"/> </xsl:otherwise> </xsl:choose> </xsl:otherwise> </xsl:choose> </xsl:variable> <xsl:sequence select="$conf.mappingElements.filteredByClass"/> <xsl:message use-when="false()">[DEBUG][xfe:applyCommonfiltersOnConfMappingElements] count($conf.mappingElements.filteredByClass) = <xsl:value-of select="count($conf.mappingElements.filteredByClass)"/></xsl:message> </xsl:otherwise> </xsl:choose> </xsl:otherwise> </xsl:choose> </xsl:variable> <xsl:choose> <xsl:when test="count($conf.mappingElements.filtered) = 0">  </xsl:when> <xsl:when test="count($conf.mappingElements.filtered) = 1"> <xsl:sequence select="$conf.mappingElements.filtered"/> </xsl:when> <xsl:otherwise> <xsl:call-template name="els:log"> <xsl:with-param name="xsltName" select="els:getFileName(static-base-uri())"/> <xsl:with-param name="code" select="$els:log.level.code"/> <xsl:with-param name="alert" select="true()"/> <xsl:with-param name="level" select="'warning'"/> <xsl:with-param name="markup" select="false()"/> <xsl:with-param name="xpathContext" select="$e"/> <xsl:with-param name="description">[WARNING][xfe:applyCommonfiltersOnConfMappingElements] <xsl:value-of select="count($conf.mappingElements.filtered)"/> elements found in conf for html <xsl:value-of select="els:displayNode($e)"/>. Falling back to first occurence</xsl:with-param> </xsl:call-template> <xsl:if test="count($conf.mappingElements.filtered) != 0"> <xsl:call-template name="els:log"> <xsl:with-param name="xsltName" select="els:getFileName(static-base-uri())"/> <xsl:with-param name="code" select="$els:log.level.code"/> <xsl:with-param name="alert" select="true()"/> <xsl:with-param name="level" select="'warning'"/> <xsl:with-param name="markup" select="false()"/> <xsl:with-param name="xpathContext" select="$e"/> <xsl:with-param name="description"><xsl:text>conf elements found : </xsl:text> <xsl:for-each select="$conf.mappingElements.filtered"> <xsl:text> </xsl:text> <xsl:value-of select="els:displayNode(.)"/> <xsl:text> </xsl:text> </xsl:for-each> </xsl:with-param> </xsl:call-template> </xsl:if> <xsl:sequence select="$conf.mappingElements.filtered[1]"/> </xsl:otherwise> </xsl:choose> </xsl:function> <xsl:function name="xfe:getXmlELementName" as="xs:string"> <xsl:param name="e" as="element()"/>  <xsl:variable name="result" as="xs:string"> <xsl:choose>  <xsl:when test="$xfe:srng.grammar.rootIsSingle and $e/self::html:body"> <xsl:value-of select="rng:getRootElementsName($xfe:srng.grammar.normalized)[1]"/> </xsl:when> <xsl:when test="$xfe:srng.is-xhtml"> <xsl:value-of select="local-name($e)"/> </xsl:when> <xsl:otherwise> <xsl:variable name="conf.mappingElement" select="xfe:getConfMappingFromHTML($e)" as="element()*"/> <xsl:choose> <xsl:when test="count($conf.mappingElement) = 1"> <xsl:value-of select="xfe:getNameFromXpath($conf.mappingElement)"/> </xsl:when> <xsl:otherwise> <xsl:value-of select="tokenize($e/@class, $els:regAnySpace)[1]"/> </xsl:otherwise> </xsl:choose> </xsl:otherwise> </xsl:choose> </xsl:variable> <xsl:choose> <xsl:when test="normalize-space($result) != ''"> <xsl:value-of select="$result"/> </xsl:when> <xsl:otherwise> <xsl:message terminate="yes">[FATAL][xfe:getXmlELementName] Unable to get the xml element's name for <xsl:value-of select="els:displayNode($e)"/> at <xsl:value-of select="els:get-xpath($e)"/></xsl:message> </xsl:otherwise> </xsl:choose> </xsl:function>  <xsl:function name="xfe:getNameFromXpath" as="xs:string"> <xsl:param name="e" as="element()"/> <xsl:value-of select="tokenize($e/@xpath, '/')[last()]"/> </xsl:function> </xsl:stylesheet>