geo_combine 0.0.2 → 0.0.3

data/lib/xslt/utils/printFormatted.xsl

@@ -0,0 +1,267 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
+
+
+<!--
+Print the text of an XML element as preformatted text or wrapped paragraphs,
+as appropriate. Makes the text readable on screen, and preserves the author's
+intended formatting.
+
+Created 6/20/06  Richard.Fozzard@noaa.gov
+
+ @version $Id$
+
+The stylesheet that imports this file needs to define two callback templates:
+    printFormattedLine  Output a line, preserving all formatting (whitespace)
+    printParagraphLine  Output a line as a continuous paragraph (word-wrapped)
+both with the param "line", the one line string to print. 
+
+Each callback template then outputs the "line" string as desired (e.g. HTML, 
+text, XML). These templates can have some optional params which printFormatted 
+will pass through as needed:
+    "restOfString"  Useful for doing something different at the end, e.g. no <P>
+    "optional-param-1"  Useful for passing indent values
+    "optional-param-2"  or word wrap widths...
+    "optional-param-3"  or whatever...
+
+Then, whenever a string of one or more lines needs to be output, call the
+printFormatted template with the params:
+    "elementContent"            a one or more line string to print
+    "formattedSectionElement"   Name of element to wrap a sequence of formatted lines
+                                    defaults to 'PRE', can be none, i.e. ''
+    plus any of the desired optional params for the callbacks
+-->
+
+
+<!--
+  g-fold-width
+    This parameter specifies the maximum length of a line when the
+    formattedSectionElement (<pre> by default) is used. The browser
+    may wrap PRE text at this width.
+    [only works in Firefox 1+]
+-->
+<!-- xsl:param name="g-fold-width" select="'80'"/ -->
+
+
+<!-- Whitespace characters -->
+<xsl:variable name="newline">
+    <xsl:text>&#10;</xsl:text>
+</xsl:variable>
+
+<xsl:variable name="tab">
+    <xsl:text>&#9;</xsl:text>
+</xsl:variable>
+
+
+<xsl:template name="printFormatted">
+    <!-- string to print out -->
+    <xsl:param name="elementContent"/>
+    <!-- Name of element to wrap a sequence of formatted lines. 
+            Set to empty string for no element, i.e. plain text output. -->
+    <xsl:param name="formattedSectionElement" select="'PRE'"/>
+    <!-- used internally to skip 1 or more formatted lines -->
+    <xsl:param name="skipFormattedLines" select="false()"/>
+    <!-- if needed by callback template: -->
+    <xsl:param name="optional-param-1"/>
+    <xsl:param name="optional-param-2"/>
+    <xsl:param name="optional-param-3"/>
+
+    <xsl:if test="$elementContent"><!-- if not at end of string -->
+        <xsl:variable name="containsNewline" select="contains($elementContent,$newline)"/>
+        <xsl:variable name="firstLine">
+            <xsl:call-template name="strip-trailing-whitespace">
+                <xsl:with-param name="content">
+                    <xsl:choose>
+                        <xsl:when test="$containsNewline">
+                            <xsl:value-of select="substring-before($elementContent,$newline)"/>
+                        </xsl:when>
+                        <xsl:otherwise>
+                            <xsl:value-of select="$elementContent"/>
+                        </xsl:otherwise>
+                    </xsl:choose>
+                </xsl:with-param>
+            </xsl:call-template>
+        </xsl:variable>
+            
+        <xsl:variable name="restOfString" select="substring-after($elementContent,$newline)"/>
+    
+        <!-- This line is formatted if it has 3 spaces or a tab or empty line -->
+        <xsl:variable name="thisLineFormatted" 
+            select="$firstLine = '' or contains($firstLine,'   ') or contains($firstLine,$tab)"/>
+    
+        
+        <xsl:choose>
+            <!-- if a formatted line -->
+            <xsl:when test="$thisLineFormatted = true()">
+                
+               <!-- if at start of a formatted section, and it's a non-empty line before the end of the element, print it -->
+               <xsl:if test="not($skipFormattedLines) and (normalize-space($firstLine) or normalize-space($restOfString))">
+                    <xsl:choose>
+                        <!-- if specified, wrap a formatted section (1 or more lines) in an element -->
+                        <xsl:when test="$formattedSectionElement">
+                            <xsl:element name="{$formattedSectionElement}">
+                                <xsl:attribute name="wrap"/><!-- works on Firefox 1.5+, not on IE 6/7, Safari 2 -->
+                                <!-- xsl:attribute name="width"><xsl:value-of select="$g-fold-width"/></xsl:attribute -->
+                                <xsl:call-template name="printFormattedSection">
+                                    <xsl:with-param name="elementContent" select="$elementContent"/>
+                                    <xsl:with-param name="optional-param-1" select="$optional-param-1"/>
+                                    <xsl:with-param name="optional-param-2" select="$optional-param-2"/>
+                                    <xsl:with-param name="optional-param-3" select="$optional-param-3"/>
+                                </xsl:call-template>
+                            </xsl:element>
+                        </xsl:when>
+                    
+                        <!-- else if no element specified, 
+                            output a formatted section (1 or more lines) directly -->
+                        <xsl:otherwise>
+                            <xsl:call-template name="printFormattedSection">
+                                <xsl:with-param name="elementContent" select="$elementContent"/>
+                                <xsl:with-param name="optional-param-1" select="$optional-param-1"/>
+                                <xsl:with-param name="optional-param-2" select="$optional-param-2"/>
+                                <xsl:with-param name="optional-param-3" select="$optional-param-3"/>
+                            </xsl:call-template>
+                        </xsl:otherwise>
+                    </xsl:choose>
+                </xsl:if>
+                
+                <!-- go to next line, recursively until next non-formatted line or end of string -->
+                <xsl:call-template name="printFormatted">
+                    <xsl:with-param name="elementContent" select="$restOfString"/>
+                    <xsl:with-param name="formattedSectionElement" select="$formattedSectionElement"/>
+                    <xsl:with-param name="skipFormattedLines" select="true()"/>
+                    <xsl:with-param name="optional-param-1" select="$optional-param-1"/>
+                    <xsl:with-param name="optional-param-2" select="$optional-param-2"/>
+                    <xsl:with-param name="optional-param-3" select="$optional-param-3"/>
+                </xsl:call-template>
+            
+            </xsl:when>
+            
+            <!-- else not a formatted line; treat as paragraph -->
+            <xsl:otherwise>
+            
+                <!-- make callback to importing stylesheet to print the paragraph -->
+                <xsl:call-template name="printParagraphLine">
+                    <xsl:with-param name="line" select="$firstLine"/>
+                    <xsl:with-param name="restOfString" select="$restOfString"/>
+                    <xsl:with-param name="optional-param-1" select="$optional-param-1"/>
+                    <xsl:with-param name="optional-param-2" select="$optional-param-2"/>
+                    <xsl:with-param name="optional-param-3" select="$optional-param-3"/>
+                </xsl:call-template>
+                
+                <!-- go to next line, recursively until non-formatted line or end of string -->
+                <xsl:call-template name="printFormatted">
+                    <xsl:with-param name="elementContent" select="$restOfString"/>
+                    <xsl:with-param name="formattedSectionElement" select="$formattedSectionElement"/>
+                    <xsl:with-param name="skipFormattedLines" select="false()"/>
+                    <xsl:with-param name="optional-param-1" select="$optional-param-1"/>
+                    <xsl:with-param name="optional-param-2" select="$optional-param-2"/>
+                    <xsl:with-param name="optional-param-3" select="$optional-param-3"/>
+                </xsl:call-template>
+            
+            </xsl:otherwise>
+        </xsl:choose>
+        
+    </xsl:if>
+</xsl:template>
+
+
+
+<xsl:template name="printFormattedSection">
+    <xsl:param name="elementContent"/><!-- string to print out -->
+    <!-- if needed by callback template: -->
+    <xsl:param name="optional-param-1"/>
+    <xsl:param name="optional-param-2"/>
+    <xsl:param name="optional-param-3"/>
+
+    <xsl:if test="$elementContent"><!-- if not at end of string -->
+        <xsl:variable name="firstLine">
+            <xsl:call-template name="strip-trailing-whitespace">
+                <xsl:with-param name="content" select="substring-before($elementContent,$newline)"/>
+            </xsl:call-template>
+        </xsl:variable>
+            
+        <xsl:variable name="restOfString" select="substring-after($elementContent,$newline)"/>
+    
+        <!-- This line is formatted if it has 3 spaces or a tab or empty line -->
+        <xsl:variable name="thisLineFormatted" 
+            select="$firstLine = '' or contains($firstLine,'   ') or contains($firstLine,$tab)"/>          
+    
+        
+        <xsl:if test="$thisLineFormatted = true()"><!-- if a formatted line -->
+            <!-- make callback to importing stylesheet to print the formatted line -->
+            <xsl:call-template name="printFormattedLine">
+                <xsl:with-param name="line" select="$firstLine"/>
+                <xsl:with-param name="restOfString" select="$restOfString"/>
+                <xsl:with-param name="optional-param-1" select="$optional-param-1"/>
+                <xsl:with-param name="optional-param-2" select="$optional-param-2"/>
+                <xsl:with-param name="optional-param-3" select="$optional-param-3"/>
+            </xsl:call-template>
+            
+            <!-- recursively call self until all formatted lines written -->
+            <xsl:call-template name="printFormattedSection">
+                <xsl:with-param name="elementContent" select="$restOfString"/>
+                <xsl:with-param name="optional-param-1" select="$optional-param-1"/>
+                <xsl:with-param name="optional-param-2" select="$optional-param-2"/>
+                <xsl:with-param name="optional-param-3" select="$optional-param-3"/>
+            </xsl:call-template>
+        </xsl:if>
+        <!-- do nothing and end recursion if we find a non-formatted, plain line -->
+    </xsl:if>
+
+</xsl:template>
+
+
+
+
+
+<!--
+  Strip the leading white space (including newlines or other characters
+  that get translated to white space by normalize-space) from a block
+  of text.
+  
+  [Stolen from somewhere on the web using Google.]
+-->
+
+<xsl:template name="strip-leading-whitespace">
+  <xsl:param name="content"/>
+  <xsl:variable name="normalized-text" select="normalize-space($content)"/>
+  <xsl:variable name="first-char" select="substring($normalized-text,1,1)"/>
+  <xsl:variable name="leading-spaces" select="substring-before($content,$first-char)"/>
+  <xsl:choose>
+    <xsl:when test="string-length($leading-spaces) &gt; 0">
+        <xsl:value-of select="substring-after($content,$leading-spaces)"/>
+    </xsl:when>
+    <xsl:otherwise>
+        <xsl:value-of select="$content"/>
+    </xsl:otherwise>
+  </xsl:choose>
+</xsl:template>
+
+
+<!--
+  Strip the trailing white space (including newlines or other characters
+  that get translated to white space by normalize-space) from a block
+  of text.
+  
+  [Stolen from somewhere on the web using Google.]
+-->
+
+<xsl:template name="strip-trailing-whitespace">
+    <xsl:param name="content"/>
+    <xsl:param name="i" select="string-length($content)"/>
+    <xsl:choose>
+      <xsl:when test="translate(substring($content, $i, 1), ' &#9;&#10;&#13;', '')">
+        <xsl:value-of select="substring($content,1,$i)"/>
+      </xsl:when>
+      <xsl:when test="$i &lt; 2"/><!-- done! -->
+      <xsl:otherwise>
+        <xsl:call-template name="strip-trailing-whitespace">
+          <xsl:with-param name="content" select="$content"/>
+          <xsl:with-param name="i" select="$i - 1"/>
+        </xsl:call-template>
+      </xsl:otherwise>
+    </xsl:choose>
+
+</xsl:template>
+
+</xsl:stylesheet>

data/lib/xslt/utils/printTextLines.xsl

@@ -0,0 +1,192 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
+
+
+<!--
+Print an XML element as plain formatted text or wrapped paragraphs,
+as appropriate. Makes the text readable on screen, and preserves the author's
+intended formatting.
+
+[The 'fold' and 'chop' templates come from original xml-to-text.xsl by Joe 
+Shirley.]
+
+Created 6/20/06  Richard.Fozzard@noaa.gov
+
+ @version $Id$
+
+This file defines two callback templates used by printFormatted.xsl:
+    printFormattedLine  Output a line, preserving all formatting (whitespace)
+    printParagraphLine  Output a line as a continuous paragraph (word-wrapped)
+
+-->
+
+<!--
+  g-fold-width
+    This parameter specifies the maximum length of a line when the
+    'fold' text formatting option is chosen. This parameter is ignored
+    for other text formatting options.
+-->
+<xsl:param name="g-fold-width" select="'80'"/>
+
+<!--
+  g-fold-character
+    This parameter specifies where a line may be broken when the
+    'fold' text formatting option is chosen. This parameter is ignored
+    for other text formatting options.
+-->
+<xsl:param name="g-fold-character" select="' '"/>
+
+<xsl:variable name="newline">
+    <xsl:text>&#10;</xsl:text>
+</xsl:variable>
+
+<xsl:variable name="tab">
+    <xsl:text>&#9;</xsl:text>
+</xsl:variable>
+
+<!-- Output a single line formatted with all white space preserved. Indent each line
+  to the current indent level.
+-->
+<xsl:template name="printFormattedLine">
+    <xsl:param name="line"/>
+    <xsl:param name="restOfString"/>
+    <xsl:param name="optional-param-1"/>
+
+    <xsl:variable name="indent" select="$optional-param-1"/>
+    
+    <!-- Print next line, unless it's a blank line after final text line. -->
+    <xsl:if test="(string-length($line) &gt; 0) or (string-length(normalize-space($restOfString)) &gt; 0)">
+        <xsl:value-of select="$indent"/>
+        <xsl:value-of select="$line"/>
+        <xsl:value-of select="$newline"/>
+    </xsl:if>
+
+</xsl:template>
+
+
+<!-- Output a single line formatted as a word-wrapped paragraph. Indent each line
+  to the current indent level. Use 'fold' template to do the word-wrapping.
+-->
+<xsl:template name="printParagraphLine">
+    <xsl:param name="line"/>
+    <xsl:param name="restOfString"/>
+    <xsl:param name="optional-param-1"/>
+    <xsl:param name="optional-param-2"/>
+
+    <xsl:variable name="indent" select="$optional-param-1"/>
+    <xsl:variable name="length" select="$optional-param-2"/>
+
+    <!-- Print line with 'fold', unless it's a blank line after final text line. -->
+    <xsl:if test="(string-length($line) &gt; 0) or (string-length(normalize-space($restOfString)) &gt; 0)">
+        <xsl:value-of select="$indent"/><!-- fold doesn't indent first line -->
+        <xsl:call-template name="fold">
+            <xsl:with-param name="original-string" select="normalize-space($line)"/>
+            <xsl:with-param name="length" select="$length"/>
+            <xsl:with-param name="indent" select="$indent"/>
+        </xsl:call-template>
+    </xsl:if>
+
+</xsl:template>
+
+<!--
+  Text formatting template. Create line breaks. Indent each line to
+  the current indent level. Return the next line each time the
+  template is called.
+-->
+
+<xsl:template name="fold">
+  <xsl:param name="original-string"/>
+  <xsl:param name="length"/>
+  <xsl:param name="indent"/>
+  <xsl:param name="fold-width" select="$g-fold-width"/>
+  <xsl:variable name="printstring">
+    <xsl:choose>
+      <xsl:when test="string-length($original-string) &gt; number($length)">
+        <!-- Text is longer than max, chop it down and print next line. -->
+        <xsl:call-template name="chop">
+          <xsl:with-param name="newstring" select="''"/>
+          <xsl:with-param name="original-string" select="$original-string"/>
+          <xsl:with-param name="length" select="$length"/>
+        </xsl:call-template>
+      </xsl:when>
+      <xsl:otherwise>
+        <xsl:value-of select="$original-string"/>
+      </xsl:otherwise>
+   </xsl:choose>
+  </xsl:variable>
+  <xsl:value-of select="$printstring"/>
+  <xsl:value-of select="$newline"/>
+  <xsl:variable name="str" select="substring-after($original-string, $printstring)"/>
+  <xsl:if test="string-length($str)">
+    <!-- More text, call fold recursively. -->
+    <xsl:value-of select="$indent"/>
+    <xsl:call-template name="fold">
+      <xsl:with-param name="original-string" select="$str"/>
+      <xsl:with-param name="length" select="number($fold-width) - string-length($indent)"/>
+      <xsl:with-param name="indent" select="$indent"/>
+    </xsl:call-template>
+  </xsl:if>
+</xsl:template>
+
+
+<!--
+  Create line breaks. Break only at specified line break
+  character. If possible keep lines less than a specified maximum
+  length, otherwise break at first acceptable character after
+  maximum length. Return one line each time the template is called.
+-->
+
+<xsl:template name="chop">
+  <xsl:param name="newstring"/>
+  <xsl:param name="original-string"/>
+  <xsl:param name="char" select="$g-fold-character"/>
+  <xsl:param name="length"/>
+  <xsl:variable name="str1">
+    <!-- str1 is the part before the break. -->
+    <xsl:choose>
+      <xsl:when test="contains($original-string, $char)">
+        <!-- The text contains a break character, chop it off. -->
+        <xsl:value-of select="concat($newstring, substring-before($original-string, $char), $char)"/>
+      </xsl:when>
+      <xsl:otherwise>
+        <!-- The text contains no break character, use it all. -->
+        <xsl:value-of select="concat($newstring, $original-string)"/>
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:variable>
+  <xsl:variable name="str2">
+    <!-- str2 is the part after the break. -->
+    <xsl:choose>
+      <xsl:when test="contains($original-string, $char)">
+        <!-- The text contains a break character, take what is after that. -->
+        <xsl:value-of select="substring-after($original-string, $char)"/>
+      </xsl:when>
+      <xsl:otherwise>
+        <!-- The text contains no break character, use an empty string. -->
+        <xsl:value-of select="''"/>
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:variable>
+  <xsl:choose>
+    <xsl:when test="(string-length($str1) &lt; number($length)) and $str2">
+      <xsl:variable name="return-value">
+        <xsl:call-template name="chop">
+          <xsl:with-param name="newstring" select="$str1"/>
+          <xsl:with-param name="original-string" select="$str2"/>
+          <xsl:with-param name="char" select="$char"/>
+          <xsl:with-param name="length" select="$length"/>
+        </xsl:call-template>
+      </xsl:variable>
+      <xsl:value-of select="$return-value"/>
+    </xsl:when>
+    <xsl:when test="$newstring">
+      <xsl:value-of select="$newstring"/>
+    </xsl:when>
+    <xsl:otherwise>
+      <xsl:value-of select="$str1"/>
+    </xsl:otherwise>
+  </xsl:choose>
+</xsl:template>
+
+
+</xsl:stylesheet>

data/lib/xslt/utils/replace-newlines.xsl

@@ -0,0 +1,97 @@
+<!--
+
+replace-newlines.xsl
+
+Author: John Maurer (jmaurer@hawaii.edu)
+Date: June 2007 (when I was at National Snow and Ice Data Center)
+
+This Extensible Stylesheet Language for Transformations (XSLT) document takes
+an input string and outputs it with all newline characters substituted with
+HTML <br/> elements. This helps maintain paragraph and text structures when
+using them to output to an HTML document. You can import this XSLT in other 
+XSLT files to call the "replace-newlines" template for accomplishing this. 
+Here is an example import statement:
+
+<xsl:import href="replace-newlines.xsl"/>
+
+For more information on XSLT see:
+
+http://en.wikipedia.org/wiki/XSLT
+http://www.w3.org/TR/xslt
+
+-->
+
+<xsl:stylesheet
+  xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+  version="1.0">
+
+  <xsl:output method="text"/>
+
+  <!-- Define a variable for creating a newline: -->
+
+  <xsl:variable name="newline">
+<xsl:text>
+</xsl:text>
+  </xsl:variable>
+
+  <!-- Define a variable for creating an HTML <br/> element: -->
+
+  <xsl:variable name="break">
+    <xsl:text disable-output-escaping="yes">&lt;br/&gt;</xsl:text>
+  </xsl:variable>
+
+  <!-- Template to replace newlines with <br/>'s; note the use
+       of "disable-output-escaping" to presever the <br/> in an
+       output HTML document without it being converted to
+       &lt;br/&gt;, which ends up displaying the characters "<br/>"
+       in the output rather than an actual HTML element: -->
+
+  <xsl:template name="replace-newlines">
+    <xsl:param name="element"/>
+    <xsl:variable name="first">
+      <xsl:choose>
+        <xsl:when test="contains( $element, $newline )">
+          <xsl:value-of select="substring-before( $element, $newline )"/>
+        </xsl:when>
+        <xsl:otherwise>
+          <xsl:value-of select="$element"/>
+        </xsl:otherwise>
+      </xsl:choose>
+    </xsl:variable>
+    <xsl:variable name="middle">
+      <xsl:choose>
+        <xsl:when test="contains( $element, $newline )">
+          <xsl:value-of select="$break"/>
+        </xsl:when>
+        <xsl:otherwise>
+          <xsl:text></xsl:text>
+        </xsl:otherwise>
+      </xsl:choose>
+    </xsl:variable>
+    <xsl:variable name="last">
+      <xsl:choose>
+        <xsl:when test="contains( $element, $newline )">
+          <xsl:choose>
+            <xsl:when test="contains( substring-after( $element, $newline ), $newline )">
+              <xsl:call-template name="replace-newlines">
+                <xsl:with-param name="element">
+                  <xsl:value-of select="substring-after( $element, $newline )"/>
+                </xsl:with-param>
+              </xsl:call-template>
+            </xsl:when>
+            <xsl:otherwise>
+              <xsl:value-of select="substring-after( $element, $newline )"/>
+            </xsl:otherwise>
+          </xsl:choose>
+        </xsl:when>
+        <xsl:otherwise>
+          <xsl:text></xsl:text>
+        </xsl:otherwise>
+      </xsl:choose>
+    </xsl:variable>
+    <xsl:value-of select="$first" disable-output-escaping="yes"/>
+    <xsl:value-of select="$middle" disable-output-escaping="yes"/>
+    <xsl:value-of select="$last" disable-output-escaping="yes"/>
+  </xsl:template>
+
+</xsl:stylesheet>

data/lib/xslt/utils/replace-string.xsl

@@ -0,0 +1,80 @@
+<!--
+
+replace-string.xsl
+
+Author: John Maurer (jmaurer@hawaii.edu)
+Date: July 2007 (when I was at National Snow and Ice Data Center)
+
+This Extensible Stylesheet Language for Transformations (XSLT) document takes
+an input string and outputs it with all $old-string's substituted with the 
+specified $new-string. You can import this XSLT in other XSLT files to call 
+the "replace-string" template for accomplishing this. Here is an example 
+import statement:
+
+<xsl:import href="replace-string.xsl"/>
+
+For more information on XSLT see:
+
+http://en.wikipedia.org/wiki/XSLT
+http://www.w3.org/TR/xslt
+
+-->
+
+<xsl:stylesheet
+  xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+  version="1.0">
+
+  <xsl:output method="text"/>
+
+  <xsl:template name="replace-string">
+    <xsl:param name="element"/>
+    <xsl:param name="old-string"/>
+    <xsl:param name="new-string"/>
+    <xsl:variable name="first">
+      <xsl:choose>
+        <xsl:when test="contains( $element, $old-string )">
+          <xsl:value-of select="substring-before( $element, $old-string )"/>
+        </xsl:when>
+        <xsl:otherwise>
+          <xsl:value-of select="$element"/>
+        </xsl:otherwise>
+      </xsl:choose>
+    </xsl:variable>
+    <xsl:variable name="middle">
+      <xsl:choose>
+        <xsl:when test="contains( $element, $old-string )">
+          <xsl:value-of select="$new-string"/>
+        </xsl:when>
+        <xsl:otherwise>
+          <xsl:text></xsl:text>
+        </xsl:otherwise>
+      </xsl:choose>
+    </xsl:variable>
+    <xsl:variable name="last">
+      <xsl:choose>
+        <xsl:when test="contains( $element, $old-string )">
+          <xsl:choose>
+            <xsl:when test="contains( substring-after( $element, $old-string ), $old-string )">
+              <xsl:call-template name="replace-string">
+                <xsl:with-param name="element" select="substring-after( $element, $old-string )"/>
+                <xsl:with-param name="old-string" select="$old-string"/>
+                <xsl:with-param name="new-string" select="$new-string"/>
+              </xsl:call-template>
+            </xsl:when>
+            <xsl:otherwise>
+              <xsl:value-of select="substring-after( $element, $old-string )"/>
+            </xsl:otherwise>
+          </xsl:choose>
+        </xsl:when>
+        <xsl:otherwise>
+          <xsl:text></xsl:text>
+        </xsl:otherwise>
+      </xsl:choose>
+    </xsl:variable>
+    <!-- Disable output escaping to allow HTML tags to be interpreted: -->
+    <xsl:value-of select="$first" disable-output-escaping="yes"/>
+    <xsl:value-of select="$middle" disable-output-escaping="yes"/>
+    <xsl:value-of select="$last" disable-output-escaping="yes"/>
+  </xsl:template>
+
+</xsl:stylesheet>