envjs 0.1.7 → 0.2.0

data/src/xslt/ajaxslt-0.8.1/xpathdebug.js

@@ -0,0 +1,234 @@
+// Copyright 2005 Google Inc.
+// All Rights Reserved
+//
+// Debug stuff for the XPath parser. Also used by XSLT.
+
+TokenExpr.prototype.toString = function() {
+  return this.value;
+}
+
+TokenExpr.prototype.parseTree = function(indent) {
+  var ret = indent + '[token] ' + this.value + '\n';
+  return ret;
+}
+
+LocationExpr.prototype.toString = function() {
+  var ret = '';
+  if (this.absolute) {
+    ret += '/';
+  }
+  for (var i = 0; i < this.steps.length; ++i) {
+    if (i > 0) {
+      ret += '/';
+    }
+    ret += this.steps[i].toString();
+  }
+  return ret;
+}
+
+LocationExpr.prototype.parseTree = function(indent) {
+  var ret = indent + '[location] ' + 
+  (this.absolute ? 'absolute' : 'relative') + '\n';
+  for (var i = 0; i < this.steps.length; ++i) {
+    ret += this.steps[i].parseTree(indent + ' ');
+  }  
+  return ret;
+}
+
+StepExpr.prototype.toString = function() {
+  var ret = this.axis + '::' + this.nodetest.toString();
+  for (var i = 0; i < this.predicate.length; ++i) {
+    ret += this.predicate[i].toString();
+  }
+  return ret;
+}
+
+StepExpr.prototype.parseTree = function(indent) {
+  var ret = indent + '[step]\n' + 
+  indent + ' [axis] ' + this.axis + '\n' + 
+  this.nodetest.parseTree(indent + ' ');
+  for (var i = 0; i < this.predicate.length; ++i) {
+    ret += this.predicate[i].parseTree(indent + ' ');
+  }  
+  return ret;
+}
+
+NodeTestAny.prototype.toString = function() {
+  return 'node()';
+}
+
+NodeTestAny.prototype.parseTree = function(indent) {
+  return indent + '[nodetest] ' + this.toString() + '\n';
+}
+
+NodeTestElementOrAttribute.prototype.toString = function() {
+  return '*';
+}
+
+NodeTestElementOrAttribute.prototype.parseTree = NodeTestAny.prototype.parseTree;
+
+NodeTestText.prototype.toString = function() {
+  return 'text()';
+}
+
+NodeTestText.prototype.parseTree = NodeTestAny.prototype.parseTree;
+
+NodeTestComment.prototype.toString = function() {
+  return 'comment()';
+}
+
+NodeTestComment.prototype.parseTree = NodeTestAny.prototype.parseTree;
+
+NodeTestPI.prototype.toString = function() {
+  return 'processing-instruction()';
+}
+
+NodeTestPI.prototype.parseTree = NodeTestAny.prototype.parseTree;
+
+NodeTestNC.prototype.toString = function() {
+  return this.nsprefix + ':*';
+}
+
+NodeTestNC.prototype.parseTree = NodeTestAny.prototype.parseTree;
+
+NodeTestName.prototype.toString = function() {
+  return this.name;
+}
+
+NodeTestName.prototype.parseTree = NodeTestAny.prototype.parseTree;
+
+PredicateExpr.prototype.toString = function() {
+  var ret = '[' + this.expr.toString() + ']';
+  return ret;
+}
+
+PredicateExpr.prototype.parseTree = function(indent) {
+  var ret = indent + '[predicate]\n' + this.expr.parseTree(indent + ' ');
+  return ret;
+}
+
+FunctionCallExpr.prototype.toString = function() {
+  var ret = this.name.value + '(';
+  for (var i = 0; i < this.args.length; ++i) {
+    if (i > 0) {
+      ret += ', ';
+    }
+    ret += this.args[i].toString();
+  }
+  ret += ')';
+  return ret;
+}
+
+FunctionCallExpr.prototype.parseTree = function(indent) {
+  var ret = indent + '[function call] ' + this.name.value + '\n';
+  for (var i = 0; i < this.args.length; ++i) {
+    ret += this.args[i].parseTree(indent + ' ');
+  }
+  return ret;
+}
+
+UnionExpr.prototype.toString = function() {
+  return this.expr1.toString() + ' | ' + this.expr2.toString();
+}
+
+UnionExpr.prototype.parseTree = function(indent) {
+  var ret = indent + '[union]\n' + 
+  this.expr1.parseTree(indent + ' ') + 
+  this.expr2.parseTree(indent + ' ');
+  return ret;
+}
+
+PathExpr.prototype.toString = function() {
+  var ret = '{path: {' + this.filter.toString() + '} {' + this.rel.toString() + 
+  '}}';
+  return ret;
+}
+
+PathExpr.prototype.parseTree = function(indent) {
+  var ret = indent + '[path]\n' + 
+  indent + '- filter:\n' +
+  this.filter.parseTree(indent + ' ') + 
+  indent + '- location path:\n' +
+  this.rel.parseTree(indent + ' ');
+  return ret;
+}
+
+FilterExpr.prototype.toString = function() {
+  var ret = this.expr.toString();
+  for (var i = 0; i < this.predicate.length; ++i) {
+    ret += this.predicate[i].toString();
+  }
+  return ret;
+}
+
+FilterExpr.prototype.parseTree = function(indent) {
+  var ret = indent + '[filter]\n' + 
+  indent + '- expr:\n' +
+  this.expr.parseTree(indent + ' ');
+  indent + '- predicates:\n';
+  for (var i = 0; i < this.predicate.length; ++i) {
+    ret += this.predicate[i].parseTree(indent + ' ');
+  }
+  return ret;
+}
+
+UnaryMinusExpr.prototype.toString = function() {
+  return '-' + this.expr.toString();
+}
+
+UnaryMinusExpr.prototype.parseTree = function(indent) {
+  return indent + '[unary] -\n' + this.expr.parseTree(indent + ' ');
+}
+
+BinaryExpr.prototype.toString = function() {
+  return this.expr1.toString() + ' ' + this.op.value + ' ' + 
+  this.expr2.toString();
+}
+
+BinaryExpr.prototype.parseTree = function(indent) {
+  return indent + '[binary] ' + this.op.value + '\n' + 
+  this.expr1.parseTree(indent + ' ') + 
+  this.expr2.parseTree(indent + ' ');
+}
+
+LiteralExpr.prototype.toString = function() {
+  return '"' + this.value + '"';
+}
+
+LiteralExpr.prototype.parseTree = function(indent) {
+  return indent + '[literal] ' + this.toString() + '\n';
+}
+
+NumberExpr.prototype.toString = function() {
+  return '' + this.value;
+}
+
+NumberExpr.prototype.parseTree = function(indent) {
+  return indent + '[number] ' + this.toString() + '\n';
+}
+
+VariableExpr.prototype.toString = function() {
+  return '$' + this.name;
+}
+
+VariableExpr.prototype.parseTree = function(indent) {
+  return indent + '[variable] ' + this.toString() + '\n';
+}
+
+XNode.prototype.toString = function() {
+  return this.nodeName;
+}
+
+ExprContext.prototype.toString = function() {
+  return '[' + this.position + '/' + this.nodelist.length + '] ' + 
+  this.node.nodeName;
+}
+
+function Value_toString() {
+  return this.type + ': ' + this.value;
+}
+
+StringValue.prototype.toString = Value_toString;
+NumberValue.prototype.toString = Value_toString;
+BooleanValue.prototype.toString = Value_toString;
+NodeSetValue.prototype.toString = Value_toString;

data/src/xslt/ajaxslt-0.8.1/xslt_unittest.html

@@ -0,0 +1,138 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+"http://www.w3.org/TR/html4/loose.dtd">
+
+<html>
+  <head>
+    <title>JsUnit test page for file xslt.js of goog-ajaxslt</title>
+    <script language="JavaScript" type="text/javascript" 
+    src="jsunit/app/jsUnitCore.js"></script>
+    <script language="JavaScript" type="text/javascript" 
+    src="xmltoken.js"></script>
+    <script language="JavaScript" type="text/javascript" 
+    src="util.js"></script>
+    <script language="JavaScript" type="text/javascript" 
+    src="dom.js"></script>
+    <script language="JavaScript" type="text/javascript" 
+    src="xpath.js"></script>
+    <script language="JavaScript" type="text/javascript" 
+    src="xslt.js"></script>
+    <script language="JavaScript" type="text/javascript" 
+    src="xslt_unittest.js"></script>
+  </head>
+  
+  <body>
+    This is a <a href="http://www.jsunit.net/">jsUnit</a> test
+    page. Run it using the <a
+    href="jsunit/testRunner.html">jsUnit runner</a>.
+
+    <!-- used in the test cases -->
+
+<textarea id="xml">
+  <all>
+    <item pos="2">A</item>
+    <item pos="3">B</item>
+    <item pos="1">C</item>
+  </all>
+</textarea>
+
+<textarea id="xslt-for-each-sort">
+  <xsl:stylesheet>
+    <xsl:template match="/">
+      <xsl:for-each select="//item">
+        <xsl:sort select="@pos"/>
+        <xsl:value-of select="."/>
+      </xsl:for-each>
+    </xsl:template>
+  </xsl:stylesheet>
+</textarea>
+
+<textarea id="xslt-for-each-sort-ascending">
+  <xsl:stylesheet>
+    <xsl:template match="/">
+      <xsl:for-each select="//item">
+        <xsl:sort select="." order="ascending"/>
+        <xsl:value-of select="."/>
+      </xsl:for-each>
+    </xsl:template>
+  </xsl:stylesheet>
+</textarea>
+
+<textarea id="xslt-for-each-sort-descending">
+  <xsl:stylesheet>
+    <xsl:template match="/">
+      <xsl:for-each select="//item">
+        <xsl:sort select="." order="descending"/>
+        <xsl:value-of select="."/>
+      </xsl:for-each>
+    </xsl:template>
+  </xsl:stylesheet>
+</textarea>
+
+<textarea id="xml-apply-templates">
+  <all>
+    <item type="X">A</item>
+    <item type="Y">B</item>
+    <item type="X">C</item>
+  </all>
+</textarea>
+
+<textarea id="xslt-apply-templates">
+  <xsl:stylesheet>
+    <xsl:template match="/">
+      <xsl:apply-templates select="//item"/>
+    </xsl:template>
+    <xsl:template match="item[@type='X']">
+      <xsl:value-of select="."/>
+    </xsl:template>
+    <xsl:template match="item[@type='Y']">
+      <xsl:value-of select="."/>
+    </xsl:template>
+  </xsl:stylesheet>
+</textarea>
+
+<textarea id="xslt-global-variables">
+  <xsl:stylesheet>
+    <xsl:variable name="x" select="'x'"/>
+    <xsl:variable name="y" select="'y'"/>
+    <xsl:variable name="z">
+      <xsl:text>z</xsl:text>
+    </xsl:variable>
+    <xsl:template match="/">
+      <xsl:value-of select="$x"/>
+      <xsl:value-of select="$z"/>
+      <xsl:for-each select="//item">
+        <xsl:value-of select="$y"/>
+      </xsl:for-each>
+    </xsl:template>
+  </xsl:stylesheet>
+</textarea>
+
+<textarea id="xslt-top-level-output">
+  <xsl:stylesheet>
+    <xsl:template match="/">
+      <xsl:element name="x">
+        <xsl:attribute name="y">
+          <xsl:text>z</xsl:text>
+        </xsl:attribute>
+        <xsl:text>k</xsl:text>
+      </xsl:element>
+    </xsl:template>
+  </xsl:stylesheet>
+</textarea>
+
+<textarea id="xslt-copy">
+  <xsl:stylesheet>
+    <xsl:template match="/">
+      <xsl:for-each select="//item">
+        <xsl:copy>
+          <xsl:for-each select="@*|node()">
+            <xsl:copy/>
+          </xsl:for-each>
+        </xsl:copy>
+      </xsl:for-each>
+    </xsl:template>
+  </xsl:stylesheet>
+</textarea>
+
+  </body>
+</html>

data/src/xslt/ajaxslt-0.8.1/xslt_unittest.js

@@ -0,0 +1,68 @@
+// Copyright 2006, Google Inc.
+// All Rights Reserved.
+//
+// Unit test for the XSLT processor.
+//
+// Author: Steffen Meschkat <mesch@google.com>
+
+//********************************************
+// DGF BEWARE!  You MUST update this function if you add tests!
+//********************************************
+function exposeTestFunctionNames() {
+    return ['testForEachSort', 'testForEachSortAscending', 'testForEachSortDescending', 'testApplyTemplates', 'testGlobalVariables', 'testTopLevelOutput', 'testCopy'];
+}
+
+function el(id) {
+  return document.getElementById(id);
+}
+
+function testForEachSort() {
+  var xml = xmlParse(el('xml').value);
+  var xslt = xmlParse(el('xslt-for-each-sort').value);
+  var html = xsltProcess(xml, xslt);
+  assertEquals("CAB", html);
+}
+
+function testForEachSortAscending() {
+  var xml = xmlParse(el('xml').value);
+  var xslt = xmlParse(el('xslt-for-each-sort-ascending').value);
+  var html = xsltProcess(xml, xslt);
+  assertEquals("ABC", html);
+}
+
+function testForEachSortDescending() {
+  var xml = xmlParse(el('xml').value);
+  var xslt = xmlParse(el('xslt-for-each-sort-descending').value);
+  var html = xsltProcess(xml, xslt);
+  assertEquals("CBA", html);
+}
+
+function testApplyTemplates() {
+  var xml = xmlParse(el('xml-apply-templates').value);
+  var xslt = xmlParse(el('xslt-apply-templates').value);
+  var html = xsltProcess(xml, xslt);
+  assertEquals("ABC", html);
+}
+
+function testGlobalVariables() {
+  var xml = xmlParse(el('xml').value);
+  var xslt = xmlParse(el('xslt-global-variables').value);
+  var html = xsltProcess(xml, xslt);
+  assertEquals("xzyyy", html);
+}
+
+function testTopLevelOutput() {
+  var xml = xmlParse(el('xml').value);
+  var xslt = xmlParse(el('xslt-top-level-output').value);
+  var html = xsltProcess(xml, xslt);
+  assertEquals('<x y="z">k</x>', html);
+}
+
+function testCopy() {
+  var xml = xmlParse(el('xml').value);
+  var xslt = xmlParse(el('xslt-copy').value);
+  var html = xsltProcess(xml, xslt);
+  assertEquals('<item pos="2">A</item>' +
+               '<item pos="3">B</item>' +
+               '<item pos="1">C</item>', html);
+}

data/src/xslt/implementation.js

@@ -0,0 +1,625 @@
+// Copyright 2005 Google Inc.
+// All Rights Reserved
+//
+//
+// An XSL-T processor written in JavaScript. The implementation is NOT
+// complete; some xsl element are left out.
+//
+// References:
+//
+// [XSLT] XSL-T Specification
+// <http://www.w3.org/TR/1999/REC-xslt-19991116>.
+//
+// [ECMA] ECMAScript Language Specification
+// <http://www.ecma-international.org/publications/standards/Ecma-262.htm>.
+//
+// The XSL processor API has one entry point, the function
+// xsltProcessContext(). It receives as arguments the starting point in the
+// input document as an XPath expression context, the DOM root node of
+// the XSL-T stylesheet, and a DOM node that receives the output.
+//
+// NOTE: Actually, XSL-T processing according to the specification is
+// defined as operation on text documents, not as operation on DOM
+// trees. So, strictly speaking, this implementation is not an XSL-T
+// processor, but the processing engine that needs to be complemented
+// by an XML parser and serializer in order to be complete. Those two
+// are found in the file xml.js.
+//
+//
+// TODO(mesch): add jsdoc comments. Use more coherent naming. Finish
+// remaining XSLT features.
+//
+//
+// Author: Steffen Meschkat <mesch@google.com>
+
+
+// The exported entry point of the XSL-T processor, as explained
+// above.
+//
+// @param xmlDoc The input document root, as DOM node.
+// @param template The stylesheet document root, as DOM node.
+// @return the processed document, as XML text in a string.
+
+function xsltProcess(xmlDoc, stylesheet) {
+  var output = domCreateDocumentFragment(new XDocument);
+  xsltProcessContext(new ExprContext(xmlDoc), stylesheet, output);
+  var ret = xmlText(output);
+  return ret;
+}
+
+// The main entry point of the XSL-T processor, as explained above.
+//
+// @param input The input document root, as XPath ExprContext.
+// @param template The stylesheet document root, as DOM node.
+// @param the root of the generated output, as DOM node.
+
+function xsltProcessContext(input, template, output) {
+  var outputDocument = xmlOwnerDocument(output);
+
+  var nodename = template.nodeName.split(/:/);
+  if (nodename.length == 1 || nodename[0] != 'xsl') {
+    xsltPassThrough(input, template, output, outputDocument);
+
+  } else {
+    switch(nodename[1]) {
+    case 'apply-imports':
+      alert('not implemented: ' + nodename[1]);
+      break;
+
+    case 'apply-templates':
+      var select = xmlGetAttribute(template, 'select');
+      var nodes;
+      if (select) {
+        nodes = xpathEval(select,input).nodeSetValue();
+      } else {
+        nodes = input.node.childNodes;
+      }
+
+      var sortContext = input.clone(nodes[0], 0, nodes);
+      xsltWithParam(sortContext, template);
+      xsltSort(sortContext, template);
+
+      var mode = xmlGetAttribute(template, 'mode');
+      var top = template.ownerDocument.documentElement;
+      var templates = [];
+      for (var i = 0; i < top.childNodes.length; ++i) {
+        var c = top.childNodes[i];
+        if (c.nodeType == DOM_ELEMENT_NODE &&
+            c.nodeName == 'xsl:template' &&
+            c.getAttribute('mode') == mode) {
+          templates.push(c);
+        }
+      }
+      for (var j = 0; j < sortContext.contextSize(); ++j) {
+        var nj = sortContext.nodelist[j];
+        for (var i = 0; i < templates.length; ++i) {
+          xsltProcessContext(sortContext.clone(nj, j), templates[i], output);
+        }
+      }
+      break;
+
+    case 'attribute':
+      var nameexpr = xmlGetAttribute(template, 'name');
+      var name = xsltAttributeValue(nameexpr, input);
+      var node = domCreateDocumentFragment(outputDocument);
+      xsltChildNodes(input, template, node);
+      var value = xmlValue(node);
+      domSetAttribute(output, name, value);
+      break;
+
+    case 'attribute-set':
+      alert('not implemented: ' + nodename[1]);
+      break;
+
+    case 'call-template':
+      var name = xmlGetAttribute(template, 'name');
+      var top = template.ownerDocument.documentElement;
+
+      var paramContext = input.clone();
+      xsltWithParam(paramContext, template);
+
+      for (var i = 0; i < top.childNodes.length; ++i) {
+        var c = top.childNodes[i];
+        if (c.nodeType == DOM_ELEMENT_NODE &&
+            c.nodeName == 'xsl:template' &&
+            domGetAttribute(c, 'name') == name) {
+          xsltChildNodes(paramContext, c, output);
+          break;
+        }
+      }
+      break;
+
+    case 'choose':
+      xsltChoose(input, template, output);
+      break;
+
+    case 'comment':
+      var node = domCreateDocumentFragment(outputDocument);
+      xsltChildNodes(input, template, node);
+      var commentData = xmlValue(node);
+      var commentNode = domCreateComment(outputDocument, commentData);
+      output.appendChild(commentNode);
+      break;
+
+    case 'copy':
+      var node = xsltCopy(output, input.node, outputDocument);
+      if (node) {
+        xsltChildNodes(input, template, node);
+      }
+      break;
+
+    case 'copy-of':
+      var select = xmlGetAttribute(template, 'select');
+      var value = xpathEval(select, input);
+      if (value.type == 'node-set') {
+        var nodes = value.nodeSetValue();
+        for (var i = 0; i < nodes.length; ++i) {
+          xsltCopyOf(output, nodes[i], outputDocument);
+        }
+
+      } else {
+        var node = domCreateTextNode(outputDocument, value.stringValue());
+        domAppendChild(output, node);
+      }
+      break;
+
+    case 'decimal-format':
+      alert('not implemented: ' + nodename[1]);
+      break;
+
+    case 'element':
+      var nameexpr = xmlGetAttribute(template, 'name');
+      var name = xsltAttributeValue(nameexpr, input);
+      var node = domCreateElement(outputDocument, name);
+      domAppendChild(output, node);
+      xsltChildNodes(input, template, node);
+      break;
+
+    case 'fallback':
+      alert('not implemented: ' + nodename[1]);
+      break;
+
+    case 'for-each':
+      xsltForEach(input, template, output);
+      break;
+
+    case 'if':
+      var test = xmlGetAttribute(template, 'test');
+      if (xpathEval(test, input).booleanValue()) {
+        xsltChildNodes(input, template, output);
+      }
+      break;
+
+    case 'import':
+      alert('not implemented: ' + nodename[1]);
+      break;
+
+    case 'include':
+      alert('not implemented: ' + nodename[1]);
+      break;
+
+    case 'key':
+      alert('not implemented: ' + nodename[1]);
+      break;
+
+    case 'message':
+      alert('not implemented: ' + nodename[1]);
+      break;
+
+    case 'namespace-alias':
+      alert('not implemented: ' + nodename[1]);
+      break;
+
+    case 'number':
+      alert('not implemented: ' + nodename[1]);
+      break;
+
+    case 'otherwise':
+      alert('error if here: ' + nodename[1]);
+      break;
+
+    case 'output':
+      // Ignored. -- Since we operate on the DOM, and all further use
+      // of the output of the XSL transformation is determined by the
+      // browser that we run in, this parameter is not applicable to
+      // this implementation.
+      break;
+
+    case 'preserve-space':
+      alert('not implemented: ' + nodename[1]);
+      break;
+
+    case 'processing-instruction':
+      alert('not implemented: ' + nodename[1]);
+      break;
+
+    case 'sort':
+      // just ignore -- was handled by xsltSort()
+      break;
+
+    case 'strip-space':
+      alert('not implemented: ' + nodename[1]);
+      break;
+
+    case 'stylesheet':
+    case 'transform':
+      xsltChildNodes(input, template, output);
+      break;
+
+    case 'template':
+      var match = xmlGetAttribute(template, 'match');
+      if (match && xsltMatch(match, input)) {
+        xsltChildNodes(input, template, output);
+      }
+      break;
+
+    case 'text':
+      var text = xmlValue(template);
+      var node = domCreateTextNode(outputDocument, text);
+      output.appendChild(node);
+      break;
+
+    case 'value-of':
+      var select = xmlGetAttribute(template, 'select');
+      var value = xpathEval(select, input).stringValue();
+      var node = domCreateTextNode(outputDocument, value);
+      output.appendChild(node);
+      break;
+
+    case 'param':
+      xsltVariable(input, template, false);
+      break;
+
+    case 'variable':
+      xsltVariable(input, template, true);
+      break;
+
+    case 'when':
+      alert('error if here: ' + nodename[1]);
+      break;
+
+    case 'with-param':
+      alert('error if here: ' + nodename[1]);
+      break;
+
+    default:
+      alert('error if here: ' + nodename[1]);
+      break;
+    }
+  }
+}
+
+
+// Sets parameters defined by xsl:with-param child nodes of the
+// current template node, in the current input context. This happens
+// before the operation specified by the current template node is
+// executed.
+
+function xsltWithParam(input, template) {
+  for (var i = 0; i < template.childNodes.length; ++i) {
+    var c = template.childNodes[i];
+    if (c.nodeType == DOM_ELEMENT_NODE && c.nodeName == 'xsl:with-param') {
+      xsltVariable(input, c, true);
+    }
+  }
+}
+
+
+// Orders the current node list in the input context according to the
+// sort order specified by xsl:sort child nodes of the current
+// template node. This happens before the operation specified by the
+// current template node is executed.
+//
+// TODO(mesch): case-order is not implemented.
+
+function xsltSort(input, template) {
+  var sort = [];
+  for (var i = 0; i < template.childNodes.length; ++i) {
+    var c = template.childNodes[i];
+    if (c.nodeType == DOM_ELEMENT_NODE && c.nodeName == 'xsl:sort') {
+      var select = xmlGetAttribute(c, 'select');
+      var expr = xpathParse(select);
+      var type = xmlGetAttribute(c, 'data-type') || 'text';
+      var order = xmlGetAttribute(c, 'order') || 'ascending';
+      sort.push({ expr: expr, type: type, order: order });
+    }
+  }
+
+  xpathSort(input, sort);
+}
+
+
+// Evaluates a variable or parameter and set it in the current input
+// context. Implements xsl:variable, xsl:param, and xsl:with-param.
+//
+// @param override flag that defines if the value computed here
+// overrides the one already in the input context if that is the
+// case. I.e. decides if this is a default value or a local
+// value. xsl:variable and xsl:with-param override; xsl:param doesn't.
+
+function xsltVariable(input, template, override) {
+  var name = xmlGetAttribute(template, 'name');
+  var select = xmlGetAttribute(template, 'select');
+
+  var value;
+
+  if (template.childNodes.length > 0) {
+    var root = domCreateDocumentFragment(template.ownerDocument);
+    xsltChildNodes(input, template, root);
+    value = new NodeSetValue([root]);
+
+  } else if (select) {
+    value = xpathEval(select, input);
+
+  } else {
+    value = new StringValue('');
+  }
+
+  if (override || !input.getVariable(name)) {
+    input.setVariable(name, value);
+  }
+}
+
+
+// Implements xsl:chose and its child nodes xsl:when and
+// xsl:otherwise.
+
+function xsltChoose(input, template, output) {
+  for (var i = 0; i < template.childNodes.length; ++i) {
+    var childNode = template.childNodes[i];
+    if (childNode.nodeType != DOM_ELEMENT_NODE) {
+      continue;
+
+    } else if (childNode.nodeName == 'xsl:when') {
+      var test = xmlGetAttribute(childNode, 'test');
+      if (xpathEval(test, input).booleanValue()) {
+        xsltChildNodes(input, childNode, output);
+        break;
+      }
+
+    } else if (childNode.nodeName == 'xsl:otherwise') {
+      xsltChildNodes(input, childNode, output);
+      break;
+    }
+  }
+}
+
+
+// Implements xsl:for-each.
+
+function xsltForEach(input, template, output) {
+  var select = xmlGetAttribute(template, 'select');
+  var nodes = xpathEval(select, input).nodeSetValue();
+  var sortContext = input.clone(nodes[0], 0, nodes);
+  xsltSort(sortContext, template);
+  for (var i = 0; i < sortContext.contextSize(); ++i) {
+    var ni = sortContext.nodelist[i];
+    xsltChildNodes(sortContext.clone(ni, i), template, output);
+  }
+}
+
+
+// Traverses the template node tree. Calls the main processing
+// function with the current input context for every child node of the
+// current template node.
+
+function xsltChildNodes(input, template, output) {
+  // Clone input context to keep variables declared here local to the
+  // siblings of the children.
+  var context = input.clone();
+  for (var i = 0; i < template.childNodes.length; ++i) {
+    xsltProcessContext(context, template.childNodes[i], output);
+  }
+}
+
+
+// Passes template text to the output. The current template node does
+// not specify an XSL-T operation and therefore is appended to the
+// output with all its attributes. Then continues traversing the
+// template node tree.
+
+function xsltPassThrough(input, template, output, outputDocument) {
+  if (template.nodeType == DOM_TEXT_NODE) {
+    if (xsltPassText(template)) {
+      var node = domCreateTextNode(outputDocument, template.nodeValue);
+      domAppendChild(output, node);
+    }
+
+  } else if (template.nodeType == DOM_ELEMENT_NODE) {
+    var node = domCreateElement(outputDocument, template.nodeName);
+    for (var i = 0; i < template.attributes.length; ++i) {
+      var a = template.attributes[i];
+      if (a) {
+        var name = a.nodeName;
+        var value = xsltAttributeValue(a.nodeValue, input);
+        domSetAttribute(node, name, value);
+      }
+    }
+    domAppendChild(output, node);
+    xsltChildNodes(input, template, node);
+
+  } else {
+    // This applies also to the DOCUMENT_NODE of the XSL stylesheet,
+    // so we don't have to treat it specially.
+    xsltChildNodes(input, template, output);
+  }
+}
+
+// Determines if a text node in the XSLT template document is to be
+// stripped according to XSLT whitespace stipping rules.
+//
+// See [XSLT], section 3.4.
+//
+// TODO(mesch): Whitespace stripping on the input document is
+// currently not implemented.
+
+function xsltPassText(template) {
+  if (!template.nodeValue.match(/^\s*$/)) {
+    return true;
+  }
+
+  var element = template.parentNode;
+  if (element.nodeName == 'xsl:text') {
+    return true;
+  }
+
+  while (element && element.nodeType == DOM_ELEMENT_NODE) {
+    var xmlspace = domGetAttribute(element, 'xml:space');
+    if (xmlspace) {
+      if (xmlspace == 'default') {
+        return false;
+      } else if (xmlspace == 'preserve') {
+        return true;
+      }
+    }
+
+    element = element.parentNode;
+  }
+
+  return false;
+}
+
+// Evaluates an XSL-T attribute value template. Attribute value
+// templates are attributes on XSL-T elements that contain XPath
+// expressions in braces {}. The XSL-T expressions are evaluated in
+// the current input context. NOTE(mesch): We are using stringSplit()
+// instead of string.split() for IE compatibility, see comment on
+// stringSplit().
+
+function xsltAttributeValue(value, context) {
+  var parts = stringSplit(value, '{');
+  if (parts.length == 1) {
+    return value;
+  }
+
+  var ret = '';
+  for (var i = 0; i < parts.length; ++i) {
+    var rp = stringSplit(parts[i], '}');
+    if (rp.length != 2) {
+      // first literal part of the value
+      ret += parts[i];
+      continue;
+    }
+
+    var val = xpathEval(rp[0], context).stringValue();
+    ret += val + rp[1];
+  }
+
+  return ret;
+}
+
+
+// Wrapper function to access attribute values of template element
+// nodes. Currently this calls xmlResolveEntities because in some DOM
+// implementations the return value of node.getAttributeValue()
+// contains unresolved XML entities, although the DOM spec requires
+// that entity references are resolved by te DOM.
+function xmlGetAttribute(node, name) {
+  // TODO(mesch): This should not be necessary if the DOM is working
+  // correctly. The DOM is responsible for resolving entities, not the
+  // application.
+  var value = domGetAttribute(node, name);
+  if (value) {
+    return xmlResolveEntities(value);
+  } else {
+    return value;
+  }
+};
+
+
+// Implements xsl:copy-of for node-set values of the select
+// expression. Recurses down the source node tree, which is part of
+// the input document.
+//
+// @param {Node} dst the node being copied to, part of output document,
+// @param {Node} src the node being copied, part in input document,
+// @param {Document} dstDocument
+
+function xsltCopyOf(dst, src, dstDocument) {
+  if (src.nodeType == DOM_DOCUMENT_FRAGMENT_NODE ||
+      src.nodeType == DOM_DOCUMENT_NODE) {
+    for (var i = 0; i < src.childNodes.length; ++i) {
+      arguments.callee(dst, src.childNodes[i], dstDocument);
+    }
+  } else {
+    var node = xsltCopy(dst, src, dstDocument);
+    if (node) {
+      // This was an element node -- recurse to attributes and
+      // children.
+      for (var i = 0; i < src.attributes.length; ++i) {
+        arguments.callee(node, src.attributes[i], dstDocument);
+      }
+
+      for (var i = 0; i < src.childNodes.length; ++i) {
+        arguments.callee(node, src.childNodes[i], dstDocument);
+      }
+    }
+  }
+}
+
+
+// Implements xsl:copy for all node types.
+//
+// @param {Node} dst the node being copied to, part of output document,
+// @param {Node} src the node being copied, part in input document,
+// @param {Document} dstDocument
+// @return {Node|Null} If an element node was created, the element
+// node. Otherwise null.
+
+function xsltCopy(dst, src, dstDocument) {
+  if (src.nodeType == DOM_ELEMENT_NODE) {
+    var node = domCreateElement(dstDocument, src.nodeName);
+    domAppendChild(dst, node);
+    return node;
+  }
+
+  if (src.nodeType == DOM_TEXT_NODE) {
+    var node = domCreateTextNode(dstDocument, src.nodeValue);
+    domAppendChild(dst, node);
+
+  } else if (src.nodeType == DOM_CDATA_SECTION_NODE) {
+    var node = domCreateCDATASection(dstDocument, src.nodeValue);
+    domAppendChild(dst, node);
+
+  } else if (src.nodeType == DOM_COMMENT_NODE) {
+    var node = domCreateComment(dstDocument, src.nodeValue);
+    domAppendChild(dst, node);
+
+  } else if (src.nodeType == DOM_ATTRIBUTE_NODE) {
+    domSetAttribute(dst, src.nodeName, src.nodeValue);
+  }
+
+  return null;
+}
+
+
+// Evaluates an XPath expression in the current input context as a
+// match (see [XSLT] section 5.2, paragraph 1).
+function xsltMatch(match, context) {
+  var expr = xpathParse(match);
+
+  var ret;
+  // Shortcut for the most common case.
+  if (expr.steps && !expr.absolute && expr.steps.length == 1 &&
+      expr.steps[0].axis == 'child' && expr.steps[0].predicate.length == 0) {
+    ret = expr.steps[0].nodetest.evaluate(context).booleanValue();
+
+  } else {
+
+    ret = false;
+    var node = context.node;
+
+    while (!ret && node) {
+      var result = expr.evaluate(context.clone(node,0,[node])).nodeSetValue();
+      for (var i = 0; i < result.length; ++i) {
+        if (result[i] == context.node) {
+          ret = true;
+          break;
+        }
+      }
+      node = node.parentNode;
+    }
+  }
+
+  return ret;
+}