diff --git a/README.md b/README.md
index c4a757b..294edd5 100644
--- a/README.md
+++ b/README.md
@@ -1,2 +1,20 @@
 # xslt-extra
-Libxslt Extension Modules
+
+## Libxslt Extension Modules
+
+This collection implements various extension elements and functions for libxslt
+that have proved useful in a few projects. The functions or elements actually
+implemented follow no particular plan, rather they are somewhat randomly chosen
+based on immediate need over time.
+
+They attempt to follow the specifications from [exslt.org](http://exslt.org/)
+or XPath 2.0 functions where feasible, although some functions appear in
+neither specification. Since XPath 2.0 has a number of features not present in
+the libxml2 implementation, corresponding implementations are at most similar
+rather than identical.
+
+## Copyright & Licence
+
+The Libxslt Extension Modules are copyright © 2020 Brian Stafford.
+They are released under the [MIT Licence][1].
+
diff --git a/docs/download.md b/docs/download.md
new file mode 100644
index 0000000..f7c7247
--- /dev/null
+++ b/docs/download.md
@@ -0,0 +1,54 @@
+# Download
+
+The Libxslt Extension Modules are available from [GitHub][5].  Clone the
+repository as follows:
+
+```sh
+$ git clone https://github.com/iarthair/xslt-extra.git
+```
+
+## Dependencies
+
+### libxml2
+
+The libxml2 development package is required to build the extension modules.
+If your distribution does not provide libxml2, you can [download it here][1].
+
+### libxslt
+
+The libxslt development package is required to build the extension modules.
+If your distribution does not provide libxml2, you can [download it here][2].
+
+### regcomp()
+
+Most modern C libraries provide the POSIX.1-2001, POSIX.1-2008 regcomp() family
+of functions, required to build the regular expression functions.
+
+## Installation
+
+The libxslt extension functions use the [Meson build system][3].  Refer to the
+Meson manual for standard configuration options.
+
+Meson supports multiple build system backends.  To build with [Ninja][4] do the
+following:
+
+``` sh
+$ meson [options] --buildtype=release builddir
+$ ninja -C builddir install
+```
+
+Note that the meson/ninja installer does not require an explicit `sudo`,
+instead it will prompt for a password during install. This avoids polluting
+builddir with files owned by root.
+
+## Reporting Bugs
+
+Bug should be reported using the GitHub issue tracker.
+
+[5]: https://github.com/iarthair/xslt-extra
+[1]: http://xmlsoft.org/downloads.html
+[2]: http://xmlsoft.org/XSLT/downloads.html
+[3]: https://mesonbuild.com/Getting-meson.html
+[4]: https://ninja-build.org/
+
+
diff --git a/docs/functions.md b/docs/functions.md
new file mode 100644
index 0000000..224494e
--- /dev/null
+++ b/docs/functions.md
@@ -0,0 +1,66 @@
+# XPath String Functions
+
+## string-join()
+```xquery
+xmlns:fn="https://iarthair.github.io/xpfunctions"
+
+string fn:string-join(node-set,string?)
+```
+
+Concatenate a list of strings with an intervening separator.  The list of
+strings is specified by a node-set passed in the first argument.  Each
+element in the node-set is converted to a string as if by using the XPath
+`string()` function. If the separator is not specified an empty string is used.
+
+### Arguments
+
+* `node-set`: A node-set converted to a list of strings.
+* `string`?: An optional separator string. If omitted an empty string is used.
+
+### Returns
+
+* `string`: the concatenated string
+
+---
+
+## ends-with()
+```xquery
+xmlns:fn="https://iarthair.github.io/xpfunctions"
+
+boolean fn:ends-with(string,string)
+```
+
+Test whether a string ends with the specified suffix.  If either argument is
+not a string it is converted as if with the XPath `string()` function.
+
+### Arguments
+
+* `string`: String to test.
+* `string`: Suffix to search for.
+
+### Returns
+
+* `boolean`: true if the test string has the specified suffix.
+
+---
+
+## class-match()
+```xquery
+xmlns:fn="https://iarthair.github.io/xpfunctions"
+
+string fn:class-match(string, string?)
+```
+
+Test whether the token specified in the second argument matches any of the
+space-separated tokens in the 1st argument.  If either argument is
+not a string it is converted as if with the XPath `string()` function.
+
+### Arguments
+
+* `string`: list of space separated tokens.
+* `string`: token to test.
+
+### Returns
+
+* `boolean`: true if the token matches.
+
diff --git a/docs/index.md b/docs/index.md
new file mode 100644
index 0000000..afb3760
--- /dev/null
+++ b/docs/index.md
@@ -0,0 +1,29 @@
+# Libxslt Extension Modules
+
+Although [libxml2 and libxslt](https://www.xmlsoft.org/) are widely available,
+unfortunately they implement only XPath 1.0 and XSL-T 1.0.  Therefore a lot of
+useful features are missing, particularly XPath functions.
+
+This collection implements various extension elements and functions for libxslt
+that have proved useful in a few projects. The functions or elements actually
+implemented follow no particular plan, rather they are somewhat randomly chosen
+based on immediate need over time.
+
+In principle the XPath extension functions are independent of libxslt and could
+be implemented using only libxml2, however the extension modules rely on the
+module loading mechanism in libxslt and so they are only available when used
+through an XSL-T stylesheet.
+
+They attempt to follow the specifications from [exslt.org](http://exslt.org/)
+or XPath 2.0 functions where feasible, although some functions appear in
+neither specification. Since XPath 2.0 has a number of features not present in
+the libxml2 implementation, corresponding implementations are at most similar
+rather than identical.
+
+## Copyright & Licence
+
+The Libxslt Extension Modules are copyright [© 2020 Brian Stafford](license.md).
+They are released under the [MIT Licence][1] since this is the licence used
+by libxml2 and libxslt.
+
+[1]: https://opensource.org/licenses/mit-license.html
diff --git a/docs/lang.md b/docs/lang.md
new file mode 100644
index 0000000..59bf2fb
--- /dev/null
+++ b/docs/lang.md
@@ -0,0 +1,94 @@
+# RFC 4647 Language Tag Matching
+
+The following functions implement [RFC 4647][1] language tag matching.
+
+In each function the range argument is a string of space separated language
+tags listed in order of decreasing preference.
+
+[1]: https://tools.ietf.org/html/rfc4647
+
+## lang()
+```xquery
+xmlns:lang="https://iarthair.github.io/lang"
+
+boolean lang:lang(string)
+```
+
+Compare the context node's language against the range specified in the first
+argument. The language of a node is the value of `xml:lang` attribute or, if
+absent, the one carried by the nearest ancestor.
+
+This is similar to the XPath `lang()` function except that the comparison is
+guaranteed to be the algorithm described in RFC 4647 and consistent with the
+other functions in this namespace URI.
+
+### Arguments
+
+* `string`: the language range to accept.
+
+### Returns
+
+* `boolean`: true if the node is matched by the range.
+
+---
+
+## accept-lang()
+```xquery
+xmlns:lang="https://iarthair.github.io/lang"
+
+node-set lang:accept-lang(node-set,string)
+```
+
+Return a node-set of elements whose language is the most specific match for the
+range specified in the second argument. The language of a node is the value of
+`xml:lang` attribute or, if absent, the one carried by the nearest ancestor.
+
+### Arguments
+
+* `node-set`: the set of nodes to be matched.
+* `string`: the language range to accept.
+
+### Returns
+
+* `node-set`: set of matching nodes.
+
+---
+
+## canonic-lang()
+```xquery
+xmlns:lang="https://iarthair.github.io/lang"
+
+string lang:canonic-lang(string)
+```
+
+Return the canonic form of the language tag in the argument string or an empty
+string if it is not a valid RFC 4646 tag.
+
+### Arguments
+
+* `string`: the language tag.
+
+### Returns
+
+* `string`: the canonic tag.
+
+---
+
+## extract-lang()
+```xquery
+xmlns:lang="https://iarthair.github.io/lang"
+
+string lang:extract-lang(string)
+```
+
+Return the language tag extracted from the string or an empty string if it is
+not a valid RFC 4646 tag.
+
+### Arguments
+
+* `string`: the language tag.
+
+### Returns
+
+* `string`: the canonic tag.
+
diff --git a/docs/license.md b/docs/license.md
new file mode 100644
index 0000000..1ad1772
--- /dev/null
+++ b/docs/license.md
@@ -0,0 +1,21 @@
+# The MIT License
+
+Copyright © 2020 Brian Stafford
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/docs/lualibxslt.md b/docs/lualibxslt.md
new file mode 100644
index 0000000..e903680
--- /dev/null
+++ b/docs/lualibxslt.md
@@ -0,0 +1,37 @@
+# XML and XSL-T access from Lua
+
+When using Lua from the `<script>` element, XML and XSLT types are
+automatically available when accessed via arguments passed to Lua functions.
+
+Additional functions described here are accessed using `require "libxslt"`.
+
+```lua
+xslt = require "libxslt"
+
+nodeset = xslt.current()
+pos = xslt.position()
+pos = xslt.last()
+nodeset = xslt.nodeset()
+```
+
+## Functions
+
+### current()
+
+Return a node-set containing the current XPath context node. Equivalent to the
+XPath `current()` function.
+
+### position()
+
+Return a number equal to the context position from the current XPath expression
+evaluation context.  Equivalent to the XPath `position()` function.
+
+### last()
+
+Return a number equal to the context size from the current XPath expression
+evaluation context.  Equivalent to the XPath `last()` function.
+
+### nodeset()
+
+Return a new empty nodeset.
+
diff --git a/docs/luaxmldoc.md b/docs/luaxmldoc.md
new file mode 100644
index 0000000..2d9b4be
--- /dev/null
+++ b/docs/luaxmldoc.md
@@ -0,0 +1,54 @@
+# XML Document
+
+XML documents are available via the following properties and methods:
+
+## Properties
+
+Document properties are read only variables.
+
+### doc:name
+```lua
+string = doc:name
+```
+
+The document name.
+
+### doc:url
+```lua
+string = doc:url
+```
+
+The document's URL.
+
+### doc:root
+```lua
+node = doc:root
+```
+
+The document's root node.
+
+## Methods
+
+### doc:node()
+```lua
+local node = doc:node()
+```
+
+Create a new node belonging to the document.
+
+### doc:setroot()
+```lua
+old_root = doc:setroot(node)
+```
+
+Set the document's root node to `node`. Returns the old root node.
+
+### doc:serialize()
+```lua
+doc:serialize(func)
+doc:serialize(function (text) io.write (text) end)
+```
+
+Serialise the XML document. The argument is a function repeatedly called to
+write the resulting text.
+
diff --git a/docs/luaxmlnode.md b/docs/luaxmlnode.md
new file mode 100644
index 0000000..893b088
--- /dev/null
+++ b/docs/luaxmlnode.md
@@ -0,0 +1,193 @@
+# XML Nodes
+
+!!! attention
+    Lua XML documentation is still incomplete
+
+XML element nodes are made available with the following API.
+
+## Properties
+
+
+### node:name
+```lua
+local string = node:name
+```
+### node:root
+```lua
+local root = node:root
+```
+### node:document
+```lua
+local doc = node:document
+```
+### node:local_name
+```lua
+local string = node:local_name
+```
+### node:prefix
+```lua
+local string = node:prefix
+```
+### node:namespace_uri
+```lua
+local string = node:namespace_uri
+```
+
+### node:attr
+```lua
+node:attr[name] = text
+local attr = node:attr[name]
+```
+
+Set or retrieve an attribute value belonging to the node.  Equivalent to the
+`setattr()` and `getattr()` methods respectively.
+
+### node:parent
+```lua
+local node = node:parent
+```
+### node:next_sibling
+```lua
+local sibling = node:next_sibling
+```
+### node:previous_sibling
+```lua
+local sibling = node:previous_sibling
+```
+### node:first_child
+```lua
+local child = node:first_child
+```
+### node:last_child
+```lua
+local child = node:last_child
+```
+
+## Methods
+
+### node:append_child()
+```lua
+node:append_child(child)
+```
+* child: child to append
+
+Append `child` to the end of the node's child list.
+
+### node:children()
+```lua
+local child
+
+for child in node:children()
+do
+    -- process child
+end
+```
+
+Return an iterator function for the node's children. This is a more convenient
+alternative to explicitly looping through nodes from `node:first_child` to
+`node:last_child` via the `child:next_sibling` properties.
+
+### node:setattr()
+```lua
+node:setattr(name, value)
+```
+* name: string with name of attribute
+* value: string with text value of attribute
+
+Set the value of the node's attribute (property).
+
+### node:getattr()
+```lua
+value = node:getattr(name)
+```
+* name: string with name of attribute
+
+Return a string with the value of the node's property.
+
+### node:unsetattr()
+```lua
+node:unsetattr(name)
+```
+* name: string with name of attribute to remove.
+
+Remove attribute.
+
+### node:copy()
+```lua
+node:copy()
+```
+### node:replace()
+```lua
+node:replace()
+```
+### node:unlink()
+```lua
+node:unlink()
+```
+### node:new()
+```lua
+node:new(name)
+```
+
+* name: string with new node local-name
+
+Create a new node belonging to the same document as the reference node.
+
+### node:text()
+```lua
+node:text(content)
+```
+
+* content: string with new text content
+
+Create a new text node belonging to the same document as the reference node.
+
+### node:parse()
+```lua
+node:parse(content)
+```
+
+* content: string with content to parse
+
+Parse a string containing a well-balanced XML chunk and add the result to
+the reference node's list of children.
+
+### node:serialize()
+```lua
+node:serialize(func)
+node:serialize(function (text) io.write (text) end)
+```
+
+* func: writer function.
+
+Serialise the XML document. The argument is a function repeatedly called to
+write the resulting text.
+
+### node:nodeset()
+```lua
+local node_set = node:nodeset()
+```
+
+Create a new nodeset containing the node.
+
+### node:newattr()
+```lua
+node:attr(name,text)
+```
+
+* name: string with attribute name.
+* text: string with text content for the attribute.
+
+Create a new attribute on the node with the specified name and content.
+
+## tostring()
+
+The Lua tostring() function returns the string value of the element content.
+
+## Operators
+
+The following operators are defined
+
+* `=`:
+* `<`:
+* `<=`:
diff --git a/docs/luaxpathnodeset.md b/docs/luaxpathnodeset.md
new file mode 100644
index 0000000..04db4f2
--- /dev/null
+++ b/docs/luaxpathnodeset.md
@@ -0,0 +1,6 @@
+# XPath Nodeset
+
+!!! attention
+    Lua XML documentation is still incomplete
+
+*TODO*
diff --git a/docs/misc-functions.md b/docs/misc-functions.md
new file mode 100644
index 0000000..6b399eb
--- /dev/null
+++ b/docs/misc-functions.md
@@ -0,0 +1,34 @@
+# XPath Miscellaneous Functions
+
+## if()
+```xquery
+xmlns:fn="https://iarthair.github.io/xpfunctions"
+
+obj fn:if(obj, obj)
+obj fn:if(obj, obj, obj)
+```
+
+Implement a conditional operator.  Convert the first argument to boolean as if
+using the XPath `boolean()` function.  If called with two arguments return the
+first argument if the condition is true otherwise return the second argument.
+If called with three arguments return the second argument if the condition is
+true otherwise return the final argument.  Arguments may be of any type
+provided the first argument may be converted to boolean.
+
+### Arguments
+
+2 arguments:
+
+* `obj`: evaluate as boolean and return if true
+* `obj`: return if first argument is false
+
+3 arguments:
+
+* `obj`: evaluate as boolean
+* `obj`: return if first argument is true
+* `obj`: return if first argument is false
+
+### Returns
+
+* `obj`: matching argument
+
diff --git a/docs/regexp.md b/docs/regexp.md
new file mode 100644
index 0000000..23d57ed
--- /dev/null
+++ b/docs/regexp.md
@@ -0,0 +1,143 @@
+# Posix Regular Expressions
+
+The regular expression functions are modelled on those described at
+[exslt.org](http://exslt.org/regexp/index.html).  The exslt specification
+specifies Javascript style regular expressions, however these functions are
+implemented using Posix regular expression syntax since these functions
+are readily available on Unix like platforms.
+
+In all cases if a non-string argument is specified where a string is expected
+the argument is converted as if by using the XPath `string()` function.
+
+## replace()
+```xquery
+xmlns:re="https://iarthair.github.io/posix-regex"
+
+string re:replace(string, string, string, string)
+```
+The re:replace() function replaces the parts of a string that match a
+Posix extended regular expression with the replacement string.
+
+Within the replacement strings, the following sequences are recognised:
+
+- `\\` - stands for a `\` sign.
+- `&`  - the matched substring (write as `&amp;` in XML documents).
+- `\0` - the matched substring, synonym for `&`.
+- `\p` - the portion of the string that precedes the matched substring (prefix).
+- `\s` - the portion of the string that follows the matched substring (suffix).
+- `\nnn` - the nth matched substring.
+
+The following flag characters are recognised:
+
+- `i` - perform a case insensitive search.
+- `g` - global match; replace all occurrences of the pattern, otherwise replace
+  only the first match.
+- `m` - match-any-character operators don't match a newline.
+
+### Arguments
+
+* `string`: the string to be matched
+* `string`: a Posix extended regular expression
+* `string`: flags
+* `string`: replacement string
+
+Note that the order of arguments follows exslt.org and differs from the
+corresponding XPath 2 function.
+
+### Returns
+
+* `string`: resulting string
+
+---
+
+## match()
+```xquery
+xmlns:re="https://iarthair.github.io/posix-regex"
+
+object re:match(string, string, string?)
+```
+The re:match() function lets you get hold of the substrings of the string
+passed as the first argument that match the captured parts of the regular
+expression passed as the second argument.
+
+The following flag characters specified in the optional final argument are
+recognised:
+
+- `i` - perform a case insensitive search.
+- `g` - global match
+- `m` - match-any-character operators don't match a newline.
+
+The return value is a node set of `<match>` elements, each of whose string
+value is equal to a portion of the first argument string captured by the
+regular expression.
+
+Behaviour differs depending on whether the match is global.  If the match is
+not global, the first match element has a value equal to the portion of the
+string matched by the entire regular expression. Subsequent elements have
+values equal to the corresponding submatches from the regular expression.
+
+If the match is global, each match element contains a portion of the string
+matched by the entire regular expression.
+
+### Arguments
+
+* `string`: the string to be matched
+* `string`: a Posix extended regular expression
+* `string`?: optional flags argument. Equivalent to empty string if omitted.
+
+### Returns
+
+* `node-set`: a node set of `<match>` elements.
+
+---
+
+## test()
+```xquery
+xmlns:re="https://iarthair.github.io/posix-regex"
+
+boolean re:test(string, string, string?)
+```
+The re:test() function returns true if the string given as the first argument
+matches the regular expression given as the second argument. 
+
+The following flag characters are recognised:
+- `i` - perform a case insensitive search.
+- `m` - match-any-character operators don't match a newline.
+
+### Arguments
+
+* `string`: the string to be matched
+* `string`: a Posix extended regular expression
+* `string`?: optional flags argument. Equivalent to empty string if omitted.
+
+### Returns
+
+* `boolean`: whether the string matches.
+
+---
+
+## filter()
+```xquery
+xmlns:re="https://iarthair.github.io/posix-regex"
+
+re:filter(node-set, string, string?)
+
+```
+Filter the node-set specified by the first argument. Each node is converted
+to a string as if using the XPath string() function and if it matches the RE
+add it to the result node-set.
+
+The following flag characters are recognised:
+- `i` - perform a case insensitive search.
+- `m` - match-any-character operators don't match a newline.
+
+### Arguments
+
+* `node-set`: the nodes to be matched
+* `string`: a Posix extended regular expression
+* `string`?: optional flags argument. Equivalent to empty string if omitted.
+
+### Returns
+
+* `node-set`: the filtered, possibly empty, node set.
+
diff --git a/docs/script.md b/docs/script.md
new file mode 100644
index 0000000..74f8d5d
--- /dev/null
+++ b/docs/script.md
@@ -0,0 +1,153 @@
+# EXSLT Script Extension
+
+This module implements the `<script>` extension element decribed in
+[exslt.org](http://exslt.org/func/elements/script/index.html) with a few
+minor differences.
+
+## <script\>
+
+```xml
+xmlns:func="http://exslt.org/functions"
+
+<func:script implements-prefix=ncname
+             language=qname
+             src=uri-reference
+             archive=uri-reference/>
+```
+
+The top-level `<func:script>` element provides an implementation of extension
+functions in the specified namespace.
+
+The function implementations may be provided as a separate resource or as
+element content.
+
+### implements-prefix
+
+The `implements-prefix` attribute is an [ncname][1] expanded to a URI using the
+namespace declarations in scope for the script element.  This URI is the
+namespace URI identifying the [local name][3] of the XPath extension functions
+being implemented.
+
+### language
+
+A [qname][4] identifying programming language used for the extension.  If the
+language value is not supported, the script element is ignored.
+
+### src
+
+Optional URI for the resource containing the extension functions.  A relative
+URI is resolved relative to the [base URI][2] of the script element.
+
+If omitted the script is read from the element content instead.  Element
+content should be protected by enclosing it in a CDATA section or by using XML
+entities where these conflict with symbols used in the programming language.
+An example is given below.
+
+!!! important
+    Currently the `src` property is not fully implemented, only resources
+    that are pathnames identifying local files may be specified.
+
+### archive
+
+Not implemented, ignored.
+
+[1]: https://www.w3.org/TR/REC-xml-names/#ns-decl (Declaring Namespaces)
+[2]: https://www.w3.org/TR/1999/REC-xslt-19991116#base-uri (Base URI)
+[3]: https://www.w3.org/TR/REC-xml-names/#dt-localname (Basic Concepts)
+[4]: https://www.w3.org/TR/REC-xml-names/#ns-qualnames (Qualified Names)
+
+# Lua
+
+Currently the only supported script language is
+[Lua 5.3](https://www.lua.org/manual/5.3/). The `language` property should be
+specified as `Lua`.
+
+Lua functions are exported when the script is compiled, by returning a table of
+functions where the key is a string naming the XPath function.
+ 
+For example the following will create the XPath functions `my:func1()`,
+`my:func2()` and `my:func3()`. Func3() illustrates that it is possible to
+create XPath functions with a closure.
+
+```xml
+<xsl:stylesheet ...
+                xmlns:func="http://exslt.org/functions"
+                xmlns:my="http://example.org/lua"
+                extension-element-prefixes="func">
+
+<func:script implements-prefix="my" language="Lua" src="functions.lua"/>
+
+...
+
+</xsl:stylesheet>
+```
+
+```lua
+-- content of functions.lua
+
+exports = {}
+
+function exports.func1(...)
+    return ""
+end
+
+function exports.func2(...)
+    return ""
+end
+
+function func3_factory()
+    local closure_var = ""
+
+    return function(...)
+        -- do some work involving the closure variables
+        return closure_var
+    end
+end
+
+exports.func3 = func3_factory()
+
+return exports
+```
+
+If the above example were implemented as script element content it would read
+as follows. In this case to avoid issues with CDATA quoting, multi-line
+comments and strings should be written as `--[=[ ... ]=]` and `[=[ ... ]=]`
+respectively.
+
+```xml
+<xsl:stylesheet ...
+                xmlns:func="http://exslt.org/functions"
+                xmlns:my="http://example.org/lua"
+                extension-element-prefixes="func">
+
+<func:script implements-prefix="my" language="Lua">
+<![CDATA[
+exports = {}
+
+function exports.func1(...)
+    return ""
+end
+
+function exports.func2(...)
+    return ""
+end
+
+function func3_factory()
+    local closure_var = ""
+
+    return function(...)
+        -- do some work involving the closure variables
+        return closure_var
+    end
+end
+
+exports.func3 = func3_factory()
+
+return exports
+]]>
+</func:script>
+
+...
+
+</xsl:stylesheet>
+```
diff --git a/docs/uri-functions.md b/docs/uri-functions.md
new file mode 100644
index 0000000..53eec98
--- /dev/null
+++ b/docs/uri-functions.md
@@ -0,0 +1,42 @@
+# XPath URI Functions
+
+## base-uri()
+```xquery
+xmlns:fn="https://iarthair.github.io/xpfunctions"
+
+string fn:base-uri(node-set?)
+```
+
+Return the base URI of the specified node or the context node
+if the argument is omitted.
+
+### Arguments
+
+* `node-set`?: use first node in node-set or context node if omitted.
+
+### Returns
+
+* `string`: the base URI.
+
+---
+
+## resolve-uri()
+```xquery
+xmlns:fn="https://iarthair.github.io/xpfunctions"
+
+string fn:resolve-uri(string, string?)
+```
+
+Resolve-uri() takes a base URI and a relative URI as arguments, and
+constructs an absolute URI.  If either argument is
+not a string it is converted as if with the XPath `string()` function.
+
+### Arguments
+
+* `string`: relative URI.
+* `string`?: base URI or base URI of context node if omitted.
+
+### Returns
+
+* `string`: absolute URI
+
diff --git a/docs/usage.md b/docs/usage.md
new file mode 100644
index 0000000..c596bba
--- /dev/null
+++ b/docs/usage.md
@@ -0,0 +1,56 @@
+# Using the Libxslt Extension Modules
+
+The extension modules are installed in libxslt's plugin directory, for example
+`/usr/lib/libxslt-plugins`. Extension modules placed there will be located
+automatically by libxslt or any program that uses it such as `xsltproc`.
+
+## Usage
+
+Usage is straightforward.  The documentation for each extension element or
+function includes the namespace URI to be used. This is declared in the
+`<xsl:stylesheet>` element in the usual way and the prefix is listed in the
+`extension-element-prefixes` attribute.
+
+!!! important
+    Remember to add the prefix to `extension-element-prefixes` since this tells
+    libxslt to load the plugin referenced by the associated URI.  Forgetting to
+    do this can be a frustrating source of errors in your stylesheet.
+
+For example if the prefix is `ext` and the URI is `https://iarthair.github.io/xpfunctions`
+they are declared in the XSL-T stylesheet follows as:
+
+```xsl
+<xsl:stylesheet version="1.0"
+                xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+                xmlns:ext="https://iarthair.github.io/xpfunctions"
+                extension-element-prefixes="ext">
+
+...
+
+</xsl:stylesheet>
+```
+
+XPath functions may then be referenced via the namespace prefix in the usual
+way, for example to call the `string-join()` function:
+
+```xsl
+<xsl:template match="*">
+  <xsl:value-of select="ext:string-join(*,' + ')"/>
+</xsl:template>
+```
+
+Similar considerations apply for extension elements.
+
+# Non-standard Installation
+
+If installation is made to a non-standard plugin directory, set the environment
+variable `LIBXSLT_PLUGINS_PATH` to point to the appropriate directory.  Note
+that this is not a colon separated list of directories, only a single directory
+may be specified. For example:
+
+```sh
+$ LIBXSLT_PLUGINS_PATH=/path/to/modules xsltproc ss.xsl file.xml
+```
+
+
+
diff --git a/functions/meson.build b/functions/meson.build
new file mode 100644
index 0000000..1303596
--- /dev/null
+++ b/functions/meson.build
@@ -0,0 +1,25 @@
+# build the functions extension
+
+xpath_functions_source = [
+    'xp-functions.c',
+    'xp-functions.h',
+]
+
+shared_module('xpfunctions', xpath_functions_source,
+	      name_prefix : prefix_iarthair,
+	      dependencies : xsldep,
+	      install_dir: plugin_dir,
+	      install : true)
+
+# build the regexp extension
+
+regexp_source = [
+    'xp-regexp.c',
+    'xp-regexp.h',
+]
+
+shared_module('posix_regex', regexp_source,
+	      name_prefix : prefix_iarthair,
+	      dependencies : [xsldep],
+	      install_dir: plugin_dir,
+	      install : true)
diff --git a/functions/xp-functions.c b/functions/xp-functions.c
new file mode 100644
index 0000000..b7b729c
--- /dev/null
+++ b/functions/xp-functions.c
@@ -0,0 +1,296 @@
+#include <ctype.h>
+#include <string.h>
+
+#include <libxml/tree.h>
+#include <libxml/hash.h>
+
+#include <libxslt/xslt.h>
+#include <libxslt/xsltInternals.h>
+#include <libxslt/imports.h>
+#include <libxslt/transform.h>
+#include <libxslt/templates.h>
+#include <libxslt/extensions.h>
+#include <libxml/uri.h>
+
+#include <libxml/xpath.h>
+#include <libxml/xpathInternals.h>
+
+#include "xp-functions.h"
+
+/****************************************************************************
+ * string fn:string-join(node-set,string?)
+ *	return the concatenation the string values of each node
+ *      separated by the string specified in the 1st argument.
+ ****************************************************************************/
+
+static void
+fn_string_join (xmlXPathParserContextPtr ctxt, int nargs)
+
+{
+  xmlChar *separator, *item, *result;
+  xmlNodeSet *nodeset;
+  int i;
+
+  if (nargs == 1)
+    separator = xmlStrdup (cX"");
+  else if (nargs == 2)
+    separator = xmlXPathPopString (ctxt);
+  else
+    {
+      xmlGenericError (xmlGenericErrorContext,
+		       "fn:string-join(node-set,string?)\n");
+      ctxt->error = XPATH_INVALID_ARITY;
+      return;
+    }
+
+  nodeset = xmlXPathPopNodeSet (ctxt);
+
+  if (nodeset == NULL || nodeset->nodeNr < 1)
+    result = xmlStrdup (cX"");
+  else
+    {
+      result = xmlNodeGetContent (nodeset->nodeTab[0]);
+      for (i = 1; i < nodeset->nodeNr; i++)
+	{
+	  item = xmlNodeGetContent (nodeset->nodeTab[i]);
+	  result = xmlStrcat (result, separator);
+	  result = xmlStrcat (result, item);
+	  xmlFree (item);
+	}
+    }
+
+  valuePush (ctxt, xmlXPathNewString (result));
+
+  xmlXPathFreeNodeSet (nodeset);
+  xmlFree (separator);
+  xmlFree (result);
+}
+
+/****************************************************************************
+ * boolean fn:ends-with(string, string)
+ *   return true if the 2nd argument string is a suffix of the 1st argument.
+ ****************************************************************************/
+
+static void
+fn_ends_with (xmlXPathParserContextPtr ctxt, int nargs)
+{
+  xmlChar *string, *suffix;
+  int string_len, suffix_len;
+  int result;
+
+  if (nargs != 2)
+    {
+      xmlGenericError (xmlGenericErrorContext,
+		       "fn:ends-with($string as string,$end as string)\n");
+      ctxt->error = XPATH_INVALID_ARITY;
+      return;
+    }
+
+  suffix = xmlXPathPopString (ctxt);
+  string = xmlXPathPopString (ctxt);
+
+  string_len = xmlStrlen (string);
+  suffix_len = xmlStrlen (suffix);
+
+  result = suffix_len <= string_len
+	    && xmlStrEqual (&string[string_len - suffix_len], suffix);
+  valuePush (ctxt, xmlXPathNewBoolean (result));
+
+  xmlFree (suffix);
+  xmlFree (string);
+}
+
+/****************************************************************************
+ * string fn:base-uri(node-set?)
+ * return the base URI of the 1st node in node-set or the context node
+ * if the argument is omitted.
+ ****************************************************************************/
+
+static void
+fn_base_uri (xmlXPathParserContextPtr ctxt, int nargs)
+{
+  xmlChar *base;
+  xmlNodeSet *nodeset;
+  xmlNode *node;
+
+  if (nargs == 0)
+    node = ctxt->context->node;
+  else if (nargs == 1)
+    {
+      if ((nodeset = xmlXPathPopNodeSet (ctxt)) == NULL)
+        {
+	  xmlGenericError (xmlGenericErrorContext,
+			   "fn:base-uri(): invalid node-set\n");
+	  return;
+	}
+      if (nodeset->nodeNr < 1)
+	{
+	  xmlGenericError (xmlGenericErrorContext,
+			   "fn:base-uri(): empty node-set\n");
+	  xmlXPathFreeNodeSet (nodeset);
+	  return;
+	}
+
+      node = nodeset->nodeTab[0];
+      xmlXPathFreeNodeSet (nodeset);
+    }
+  else
+    {
+      xmlGenericError (xmlGenericErrorContext,
+		       "fn:base-uri($node as node-set?)\n");
+      ctxt->error = XPATH_INVALID_ARITY;
+      return;
+    }
+
+  if ((base = xmlNodeGetBase (node->doc, node)) == NULL)
+    base = xmlStrdup (node->doc->URL);
+
+  valuePush (ctxt, xmlXPathNewString (base));
+  xmlFree (base);
+}
+
+/****************************************************************************
+ * string fn:resolve-uri(string, string?)
+ * return the relative URI specified in the 1st argument using the 1st node in
+ * node-set or the context node if the 2nd argument is omitted.
+ ****************************************************************************/
+
+static void
+fn_resolve_uri (xmlXPathParserContextPtr ctxt, int nargs)
+{
+  xmlChar *relative, *base, *uri;
+  xmlNode *node;
+
+  if (nargs == 1)
+    {
+      node = ctxt->context->node;
+      if ((base = xmlNodeGetBase (node->doc, node)) == NULL)
+        base = xmlStrdup (node->doc->URL);
+    }
+  else if (nargs == 2)
+    base = xmlXPathPopString (ctxt);
+  else
+    {
+      xmlGenericError (xmlGenericErrorContext,
+		       "fn:resolve-uri($relative as string,$base as string?)\n");
+      ctxt->error = XPATH_INVALID_ARITY;
+      return;
+    }
+
+  relative = xmlXPathPopString (ctxt);
+  uri = xmlBuildURI (relative, base);
+  valuePush (ctxt, xmlXPathNewString (uri));
+
+  xmlFree (base);
+  xmlFree (relative);
+  xmlFree (uri);
+}
+
+/****************************************************************************/
+
+static int
+class_match (const char *class, const char *name)
+{
+  const char *p;
+  int len;
+
+  if (class != NULL && name != NULL && *name != '\0'
+      && (p = strstr (class, name)) != NULL)
+    {
+      len = strlen (name);
+      do
+	if ((p == class || isspace (p[-1]))
+	    && (p[len] == '\0' || isspace (p[len])))
+	  return 1;
+      while ((p = strstr (p + len, name)) != NULL);
+    }
+  return 0;
+}
+
+/****************************************************************************
+ * boolean str:class-match(string,string)
+ *	return true if the 2nd argument matches any of the space-separated
+ *	tokens in the 1st argument.
+ ****************************************************************************/
+
+static void
+fn_class_match (xmlXPathParserContextPtr ctxt, int nargs)
+{
+  char *name, *class;
+  int ret;
+
+  if (nargs != 2)
+    {
+      xmlGenericError (xmlGenericErrorContext,
+		       "str:class-match requires 2 arguments\n");
+      ctxt->error = XPATH_INVALID_ARITY;
+      return;
+    }
+
+  name = (char *) xmlXPathPopString (ctxt);
+  class = (char *) xmlXPathPopString (ctxt);
+  ret = class_match (class, name);
+  xmlFree (name);
+  xmlFree (class);
+  xmlXPathReturnBoolean (ctxt, ret);
+}
+
+/****************************************************************************
+ * obj if(obj,obj?,obj)
+ * Cast the first argument to type boolean.  If false return the final argument,
+ * otherwise if called with 2 arguments return the 1st argument or if called
+ * with 3 arguments return the second argument.
+ ****************************************************************************/
+static void
+fn_cond_if (xmlXPathParserContextPtr ctxt, int nargs)
+{
+  xmlXPathObjectPtr cond, if_true, if_false;
+
+  if (nargs < 2 || nargs > 3)
+    {
+      xmlGenericError (xmlGenericErrorContext,
+		       "if() requires 2 or 3 arguments\n");
+      ctxt->error = XPATH_INVALID_ARITY;
+      return;
+    }
+
+  if_false = valuePop (ctxt);
+  if_true = (nargs == 3) ? valuePop (ctxt) : NULL;
+  cond = valuePop (ctxt);
+  if (xmlXPathCastToBoolean (cond))
+    {
+      if (if_true != NULL)
+        {
+	  xmlXPathFreeObject (cond);
+	  valuePush (ctxt, if_true);
+	}
+      else
+	valuePush (ctxt, cond);
+      xmlXPathFreeObject (if_false);
+    }
+  else
+    {
+      xmlXPathFreeObject (cond);
+      if (if_true != NULL)
+	xmlXPathFreeObject (if_true);
+      valuePush (ctxt, if_false);
+    }
+}
+
+/****************************************************************************/
+
+void
+xsltFunctionsRegister (void)
+{
+  xsltRegisterExtModuleFunction (cX"base-uri", XSLT_FUNCTIONS_NAMESPACE,
+  				 fn_base_uri);
+  xsltRegisterExtModuleFunction (cX"resolve-uri", XSLT_FUNCTIONS_NAMESPACE,
+  				 fn_resolve_uri);
+  xsltRegisterExtModuleFunction (cX"string-join", XSLT_FUNCTIONS_NAMESPACE,
+  				 fn_string_join);
+  xsltRegisterExtModuleFunction (cX"ends-with", XSLT_FUNCTIONS_NAMESPACE,
+  				 fn_ends_with);
+  xsltRegisterExtModuleFunction (cX"class-match", XSLT_FUNCTIONS_NAMESPACE,
+  				 fn_class_match);
+  xsltRegisterExtModuleFunction (cX"if", XSLT_FUNCTIONS_NAMESPACE, fn_cond_if);
+}
diff --git a/functions/xp-functions.h b/functions/xp-functions.h
new file mode 100644
index 0000000..9806ff9
--- /dev/null
+++ b/functions/xp-functions.h
@@ -0,0 +1,31 @@
+#ifndef __XSLT_FUNCTIONS_H__
+#define __XSLT_FUNCTIONS_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef LIBEXSLT_PUBLIC
+#define LIBEXSLT_PUBLIC
+#endif
+
+#define cX              (const xmlChar *)
+
+/**
+ * XSLT_FUNCTIONS_NAMESPACE:
+ *
+ * Namespace for XPath functions
+ */
+#define XSLT_FUNCTIONS_NAMESPACE (cX"https://iarthair.github.io/xpfunctions")
+
+#ifdef MODULE
+#define xsltFunctionsRegister  iarthair_github_io_xpfunctions_init
+#endif
+
+LIBEXSLT_PUBLIC void xsltFunctionsRegister (void);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* __XSLT_FUNCTIONS_H__ */
+
diff --git a/functions/xp-regexp.c b/functions/xp-regexp.c
new file mode 100644
index 0000000..cb652b7
--- /dev/null
+++ b/functions/xp-regexp.c
@@ -0,0 +1,509 @@
+#include <libxml/globals.h>
+#include <libxml/tree.h>
+#include <libxml/xpath.h>
+#include <libxml/xpathInternals.h>
+#include <libxml/parser.h>
+#include <libxml/encoding.h>
+
+#include <libxslt/xsltconfig.h>
+#include <libxslt/xsltutils.h>
+#include <libxslt/xsltInternals.h>
+#include <libxslt/extensions.h>
+
+#include "xp-regexp.h"
+
+#include <sys/types.h>
+#include <regex.h>
+#include <string.h>
+#include <ctype.h>
+
+#define NMATCH		100
+
+/* Not clear if xmlFree() is safe for NULL pointers */
+static inline void
+xmlSafeFree (void *ptr)
+{
+  if (ptr != NULL)
+    xmlFree (ptr);
+}
+
+/****************************************************************************
+ * Within the replacement strings, the following are recognised:
+ * \\ - stands for a \ sign
+ * &  - the matched substring (N.B. write as &amp; in XML documents)
+ * \0 - the matched substring, synonym for &
+ * \p - the portion of the string that precedes the matched substring (prefix)
+ * \s - the portion of the string that follows the matched substring (suffix)
+ * \nnn - the nth matched substring
+ ****************************************************************************/
+static xmlChar *
+copy_match (xmlChar *result, const xmlChar *string,
+	    const xmlChar *replacement, const xmlChar *tail,
+	    regmatch_t *match, size_t nsub)
+{
+  size_t nth;
+  int sub_len;
+  const xmlChar *rep, *sub;
+  char *es;
+
+  while ((rep = cX strpbrk ((const char *) replacement, "&\\")) != NULL)
+    {
+      /* Copy the leading portion of the substitution.  */
+      if (rep > replacement)
+	result = xmlStrncat (result, replacement, rep - replacement);
+      /* Copy the replacement string */
+      sub = NULL;
+      sub_len = 0;
+      if (*rep == '&')
+	{
+	  if (match[0].rm_so != -1)
+	    {
+	      sub = tail + match[0].rm_so;
+	      sub_len = match[0].rm_eo - match[0].rm_so;
+	    }
+	  replacement = rep + 1;
+	}
+      else
+	switch (*++rep)
+	  {
+	  case '\\':
+	    sub = rep;
+	    sub_len = 1;
+	    replacement = rep + 1;
+	    break;
+	  case '0':
+	    if (match[0].rm_so != -1)
+	      {
+		sub = tail + match[0].rm_so;
+		sub_len = match[0].rm_eo - match[0].rm_so;
+	      }
+	    replacement = rep + 1;
+	    break;
+	  case 'p':
+	    if (match[0].rm_so != -1)
+	      {
+		sub = string;
+		sub_len = tail - string + match[0].rm_so;
+	      }
+	    replacement = rep + 1;
+	    break;
+	  case 's':
+	    if (match[0].rm_so != -1)
+	      {
+		sub = tail + match[0].rm_eo;
+		sub_len = xmlStrlen (sub);
+	      }
+	    replacement = rep + 1;
+	    break;
+	  default:
+	    if (isdigit (*rep)
+		&& (nth = strtoul ((const char *) rep, &es, 10)) >= 1
+		&& nth <= nsub)
+	      {
+		if (match[nth].rm_so != -1)
+		  {
+		    sub = tail + match[nth].rm_so;
+		    sub_len = match[nth].rm_eo - match[nth].rm_so;
+		  }
+		replacement = (xmlChar *) es;
+	      }
+	    else
+	      {
+		sub = cX "\\";
+		sub_len = 1;
+		replacement = rep;
+	      }
+	    break;
+	  }
+      if (sub_len > 0)
+	result = xmlStrncat (result, sub, sub_len);
+    }
+  return xmlStrcat (result, replacement);
+}
+
+
+/****************************************************************************
+ * pre_replace:
+ *
+ * Scans a string for RE matches and replaces the matched substrings.
+ * Return value is the new string so formed.
+ ****************************************************************************/
+static void
+pre_replace (xmlXPathParserContextPtr ctxt, int nargs)
+{
+  xmlChar *string, *tail, *pattern, *flags, *replacement, *ret = NULL;
+  xmlChar *p;
+  int global, re_flags;
+  regex_t re;
+  regmatch_t match[NMATCH];
+
+  if (nargs != 4)
+    {
+      xmlXPathSetArityError (ctxt);
+      return;
+    }
+
+  replacement = xmlXPathPopString (ctxt);
+  if (xmlXPathCheckError (ctxt) || replacement == NULL)
+    {
+      xmlSafeFree (replacement);
+      return;
+    }
+
+  flags = xmlXPathPopString (ctxt);
+  if (xmlXPathCheckError (ctxt) || flags == NULL)
+    {
+      xmlSafeFree (flags);
+      xmlSafeFree (replacement);
+      return;
+    }
+
+  pattern = xmlXPathPopString (ctxt);
+  if (xmlXPathCheckError (ctxt) || pattern == NULL)
+    {
+      xmlSafeFree (pattern);
+      xmlSafeFree (flags);
+      xmlSafeFree (replacement);
+      return;
+    }
+
+  string = xmlXPathPopString (ctxt);
+  if (xmlXPathCheckError (ctxt) || string == NULL)
+    {
+      xmlSafeFree (string);
+      xmlSafeFree (pattern);
+      xmlSafeFree (flags);
+      xmlSafeFree (replacement);
+      return;
+    }
+
+  /* parse substitution flags */
+  global = 0;
+  re_flags = REG_EXTENDED;
+  for (p = flags; *p != '\0'; p++)
+    switch (*p)
+      {
+      case 'g':
+        global = 1;
+	break;
+      case 'i':
+        re_flags |= REG_ICASE;
+	break;
+      case 'm':
+        re_flags |= REG_NEWLINE;
+	break;
+      }
+
+  if (regcomp (&re, (char *) pattern, re_flags) == 0)
+    {
+      tail = string;
+      if (regexec (&re, (char *) tail, NMATCH, match, 0) == 0)
+	do
+	  {
+	    if (match[0].rm_so > 0)
+	      ret = xmlStrncat (ret, tail, match[0].rm_so);
+	    if (replacement != NULL)
+	      ret = copy_match (ret, string, replacement, tail,
+				match, re.re_nsub);
+	    tail += match[0].rm_eo;
+	  }
+	while (global && regexec (&re, (char *) tail, NMATCH, match, REG_NOTBOL) == 0);
+      ret = xmlStrcat (ret, tail);
+      regfree (&re);
+    }
+
+  xmlSafeFree (string);
+  xmlSafeFree (pattern);
+  xmlSafeFree (flags);
+  xmlSafeFree (replacement);
+
+  xmlXPathReturnString (ctxt, ret);
+}
+
+/****************************************************************************
+ * pre_match:
+ *
+ * Scans a string for RE matches and returns a node set of match elements,
+ * each containing the portion of the string matched by the RE. 
+ ****************************************************************************/
+static void
+pre_match (xmlXPathParserContextPtr ctxt, int nargs)
+{
+  xmlNodePtr node, text;
+  xmlXPathObjectPtr ret;
+  xmlChar *string, *tail, *pattern, *flags;
+  xmlChar *p;
+  xmlDoc *container;
+  xsltTransformContext *tctxt;
+  int global, re_flags, matches, i;
+  regex_t re;
+  regmatch_t match[NMATCH];
+
+  if (nargs < 2 || nargs > 3)
+    {
+      xmlXPathSetArityError (ctxt);
+      return;
+    }
+
+  global = 0;
+  re_flags = REG_EXTENDED;
+  if (nargs == 3 && (flags = xmlXPathPopString (ctxt)) != NULL)
+    {
+      for (p = flags; *p != '\0'; p++)
+	switch (*p)
+	  {
+	  case 'g':
+	    global = 1;
+	    break;
+	  case 'i':
+	    re_flags |= REG_ICASE;
+	    break;
+	  case 'm':
+	    re_flags |= REG_NEWLINE;
+	    break;
+	  }
+      xmlSafeFree (flags);
+    }
+
+  pattern = xmlXPathPopString (ctxt);
+  if (xmlXPathCheckError (ctxt) || pattern == NULL)
+    {
+      xmlSafeFree (pattern);
+      return;
+    }
+
+  string = xmlXPathPopString (ctxt);
+  if (xmlXPathCheckError (ctxt) || string == NULL)
+    {
+      xmlSafeFree (string);
+      xmlSafeFree (pattern);
+      return;
+    }
+
+  tctxt = xsltXPathGetTransformContext (ctxt);
+  container = xsltCreateRVT (tctxt);
+  if (container == NULL)
+    {
+      xmlSafeFree (string);
+      xmlSafeFree (pattern);
+      return;
+    }
+  xsltRegisterTmpRVT (tctxt, container);
+
+  ret = xmlXPathNewNodeSet (NULL);
+  if (ret == NULL)
+    {
+      xmlSafeFree (string);
+      xmlSafeFree (pattern);
+      return;
+    }
+
+  ret->boolval = 0;
+  if (regcomp (&re, (char *) pattern, re_flags) == 0)
+    {
+      tail = string;
+      if (regexec (&re, (char *) tail, NMATCH, match, 0) == 0)
+	{
+	  if (global)
+	    do
+	      {
+		/* create a match element for each submatch */
+		node = xmlNewDocRawNode (container, NULL, cX "match", NULL);
+		xmlAddChild ((xmlNodePtr) container, node);
+		if (match[0].rm_so != -1)
+		  {
+		    text = xmlNewDocTextLen (container,
+					     tail + match[0].rm_so,
+					     match[0].rm_eo - match[0].rm_so);
+		    xmlAddChild (node, text);
+		  }
+		xmlXPathNodeSetAdd (ret->nodesetval, node);
+		tail += match[0].rm_eo;
+	      }
+	    while (regexec (&re, (char *) tail, NMATCH, match, REG_NOTBOL) == 0);
+	  else
+	    {
+	      /* count the matches */
+	      for (matches = NMATCH; matches > 0; matches--)
+		if (match[matches - 1].rm_so != -1)
+		  break;
+	      /* create a match element for each submatch */
+	      for (i = 0; i < matches; i++)
+		{
+		  node = xmlNewDocRawNode (container, NULL, cX "match", NULL);
+		  xmlAddChild ((xmlNodePtr) container, node);
+		  if (match[i].rm_so != -1)
+		    {
+		      text = xmlNewDocTextLen (container,
+					       tail + match[i].rm_so,
+					       match[i].rm_eo - match[i].rm_so);
+		      xmlAddChild (node, text);
+		    }
+		  xmlXPathNodeSetAdd (ret->nodesetval, node);
+		}
+	    }
+	}
+      regfree (&re);
+    }
+
+  valuePush (ctxt, ret);
+
+  xmlSafeFree (string);
+  xmlSafeFree (pattern);
+}
+
+
+/****************************************************************************
+ * pre_test:
+ *
+ * Returns TRUE if the  RE matches the string.
+ ****************************************************************************/
+static void
+pre_test (xmlXPathParserContextPtr ctxt, int nargs)
+{
+  xmlChar *string, *pattern, *flags;
+  xmlChar *p;
+  int match, re_flags;
+  regex_t re;
+
+  if (nargs < 2 || nargs > 3)
+    {
+      xmlXPathSetArityError (ctxt);
+      return;
+    }
+
+  re_flags = REG_EXTENDED;
+  if (nargs == 3 && (flags = xmlXPathPopString (ctxt)) != NULL)
+    {
+      for (p = flags; *p != '\0'; p++)
+	switch (*p)
+	  {
+	  case 'i':
+	    re_flags |= REG_ICASE;
+	    break;
+	  case 'm':
+	    re_flags |= REG_NEWLINE;
+	    break;
+	  }
+      xmlSafeFree (flags);
+    }
+
+  pattern = xmlXPathPopString (ctxt);
+  if (xmlXPathCheckError (ctxt) || pattern == NULL)
+    {
+      xmlSafeFree (pattern);
+      return;
+    }
+
+  string = xmlXPathPopString (ctxt);
+  if (xmlXPathCheckError (ctxt) || string == NULL)
+    {
+      xmlSafeFree (string);
+      xmlSafeFree (pattern);
+      return;
+    }
+
+  match = 0;
+  if (regcomp (&re, (char *) pattern, re_flags) == 0)
+    {
+      match = regexec (&re, (char *) string, 0, NULL, 0) == 0;
+      regfree (&re);
+    }
+  xmlXPathReturnBoolean (ctxt, match);
+
+  xmlSafeFree (string);
+  xmlSafeFree (pattern);
+}
+
+/****************************************************************************
+ * pre_filter:
+ *
+ * Filter the node-set specified by the first argument.  For each
+ * node cast to a string and if it matches the RE add it to the result
+ * node-set.  Remaining arguments are as per test().
+ ****************************************************************************/
+static void
+pre_filter (xmlXPathParserContextPtr ctxt, int nargs)
+{
+  xmlChar *string, *pattern, *flags;
+  xmlChar *p;
+  xmlXPathObject *set, *obj;
+  xmlNode *node;
+  int re_flags, i;
+  regex_t re;
+
+  if (nargs < 2 || nargs > 3)
+    {
+      xmlXPathSetArityError (ctxt);
+      return;
+    }
+
+  re_flags = REG_EXTENDED;
+  if (nargs == 3 && (flags = xmlXPathPopString (ctxt)) != NULL)
+    {
+      for (p = flags; *p != '\0'; p++)
+	switch (*p)
+	  {
+	  case 'g':
+	    break;
+	  case 'i':
+	    re_flags |= REG_ICASE;
+	    break;
+	  case 'm':
+	    re_flags |= REG_NEWLINE;
+	    break;
+	  }
+      xmlSafeFree (flags);
+    }
+
+  pattern = xmlXPathPopString (ctxt);
+  if (xmlXPathCheckError (ctxt) || pattern == NULL)
+    {
+      xmlSafeFree (pattern);
+      return;
+    }
+
+  obj = valuePop (ctxt);
+  if (xmlXPathCheckError (ctxt) || obj == NULL)
+    {
+      xmlSafeFree (pattern);
+      return;
+    }
+
+  set = xmlXPathNewNodeSet (NULL);
+  if (obj->type == XPATH_NODESET && obj->nodesetval != NULL)
+    {
+      if (regcomp (&re, (char *) pattern, re_flags) == 0)
+	{
+	  for (i = 0; i < obj->nodesetval->nodeNr; i++)
+	    {
+	      node = obj->nodesetval->nodeTab[i];
+	      string = xmlNodeGetContent (node);
+	      if (regexec (&re, (char *) string, 0, NULL, 0) == 0)
+		xmlXPathNodeSetAdd (set->nodesetval, node);
+	      xmlSafeFree (string);
+	    }
+	  regfree (&re);
+	}
+    }
+  valuePush (ctxt, set);
+
+  xmlXPathFreeObject (obj);
+  xmlSafeFree (pattern);
+}
+
+
+/**
+ * xsltRegexpRegister:
+ *
+ * Registers the EXSLT - Regexp module
+ */
+
+void
+xsltRegexpRegister (void)
+{
+  xsltRegisterExtModuleFunction (cX "replace", XSLT_REGEXP_NAMESPACE, pre_replace);
+  xsltRegisterExtModuleFunction (cX "match", XSLT_REGEXP_NAMESPACE, pre_match);
+  xsltRegisterExtModuleFunction (cX "test", XSLT_REGEXP_NAMESPACE, pre_test);
+  xsltRegisterExtModuleFunction (cX "filter", XSLT_REGEXP_NAMESPACE, pre_filter);
+}
diff --git a/functions/xp-regexp.h b/functions/xp-regexp.h
new file mode 100644
index 0000000..e6899c8
--- /dev/null
+++ b/functions/xp-regexp.h
@@ -0,0 +1,31 @@
+#ifndef __XSLT_REGEXP_H__
+#define __XSLT_REGEXP_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef LIBEXSLT_PUBLIC
+#define LIBEXSLT_PUBLIC
+#endif
+
+#define cX              (const xmlChar *)
+
+/**
+ * XSLT_REGEXP_NAMESPACE:
+ *
+ * Namespace for XSLT regexp functions
+ */
+#define XSLT_REGEXP_NAMESPACE (cX"https://iarthair.github.io/posix-regex")
+
+#ifdef MODULE
+#define xsltRegexpRegister iarthair_github_io_posix_regex_init
+#endif
+
+LIBEXSLT_PUBLIC void xsltRegexpRegister (void);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* __XSLT_REGEXP_H__ */
+
diff --git a/lang/lang.c b/lang/lang.c
new file mode 100644
index 0000000..7a96792
--- /dev/null
+++ b/lang/lang.c
@@ -0,0 +1,207 @@
+#include <string.h>
+#include <ctype.h>
+#include "rfc4647.h"
+
+#if !defined (__GNUC__) || __GNUC__ < 2
+# define __attribute__(x)
+#endif
+#define _unused	__attribute__((unused))
+
+const char *__lookup_canonic (const char *tag, int len);
+const char *lookup_canonic (const char *tag, int len)
+		__attribute__ ((weak, alias ("__lookup_canonic")));
+
+const char *__lookup_un_region (const char *tag, int len);
+const char *lookup_un_region (const char *tag, int len)
+		__attribute__ ((weak, alias ("__lookup_un_region")));
+
+const char *
+__lookup_canonic (const char *tag _unused, int len _unused)
+{
+  return NULL;
+}
+
+const char *
+__lookup_un_region (const char *tag _unused, int len _unused)
+{
+  return NULL;
+}
+
+/****************************************************************************/
+
+static const char *step_irregular (const char *tag);
+
+static int
+alnum_span (const char *str)
+{
+  int len;
+
+  for (len = 0; isalnum (str[len]); len++)
+    ;
+  return len;
+}
+
+static int
+step_tag (const char *tag)
+{
+  size_t len;
+
+  len = alnum_span (tag);
+  if (len == 1 && tag[0] != '*' && tag[1] == '-') /* step over singleton tag */
+    len = 2 + alnum_span (&tag[2]);
+  return len;
+}
+
+static void
+lcase (char *str, int len)
+{
+  for (; len-- > 0 && *str != '\0'; str++)
+    *str = tolower (*str);
+}
+
+static void
+ucase (char *str, int len)
+{
+  for (; len-- > 0 && *str != '\0'; str++)
+    *str = toupper (*str);
+}
+
+char *
+canonic_tag (char *buf, size_t bufsize, const char *tag, int full)
+{
+  const char *irregular, *canon, *subtag;
+  char *dest;
+  int len, tlen;
+
+  if (strlen (tag) >= bufsize)
+    return NULL;
+
+  /* Initial tag is the language.  Look up canonic version, if available,
+     otherwise len must be 2 or 3 or it is a grandfathered tag */
+  if ((irregular = step_irregular (tag)) != NULL)
+    len = tlen = strlen (irregular);
+  else
+    len = tlen = step_tag (tag);
+  canon = lookup_canonic (irregular != NULL ? irregular : tag, len);
+  if (canon != NULL)
+    {
+      len = strlen (canon);
+      memcpy (buf, canon, len);
+    }
+  else if (irregular != NULL)
+    memcpy (buf, irregular, len);
+  else if (len == 2 || len == 3			/* ISO 639 */
+           || (len == 1 && tag[1] == '*')	/* wildcard */
+	   || (len >= 4 && tag[1] == '-'))	/* grandfathered */
+    {
+      memcpy (buf, tag, len);
+      lcase (buf, len);
+    }
+  else
+    return NULL;
+  dest = buf + len;
+
+  /* handle remainder of the subtags */
+  if (full)
+    for (subtag = tag + tlen; *subtag == '-'; subtag += len)
+      {
+	len = step_tag (++subtag);
+	*dest++ = '-';
+	if (len == 4 && isalpha (subtag[1]))	/* script - title case */
+	  {
+	    memcpy (dest, subtag, len);
+	    ucase (dest, 1);
+	    lcase (&dest[1], len - 1);
+	    dest += len;
+	  }
+	else if (len == 2 && isalpha (*subtag))	/* region - upper case */
+	  {
+	    memcpy (dest, subtag, len);
+	    ucase (dest, len);
+	    dest += len;
+	  }
+	else if (len == 3 && isdigit (*subtag))	/* UN numeric region */
+	  {
+	    /* replace with ISO 639 region where available */
+	    if ((canon = lookup_un_region (subtag, len)) != NULL)
+	      {
+		len = strlen (canon);
+		memcpy (dest, canon, len);
+	      }
+	    else
+	      memcpy (dest, subtag, len);
+	    dest += len;
+	  }
+	else					/* other - lower case */
+	  {
+	    memcpy (dest, subtag, len);
+	    lcase (dest, len);
+	    dest += len;
+	  }
+      }
+  *dest = '\0';
+  return buf;
+}
+
+/****************************************************************************/
+
+/* Table of irregular tags with the following exceptions, zh-cmn-Hans and
+   zh-cmn-Hant are omitted so that zh-cmn is extracted and there are some
+   additional entries (these use the ADD macro instead of IRR).
+   The table is ordered in descending length of the tags */
+struct irregular
+  {
+    const char *tag;
+    int len;
+  };
+#define IRR(s)	{ s, sizeof s - 1, },
+#define ADD(s)	{ s, sizeof s - 1, },
+static const struct irregular irregular[] =
+  {
+  /*IRR("zh-cmn-Hans")*/
+  /*IRR("zh-cmn-Hant")*/
+    IRR("zh-min-nan")
+    IRR("i-enochian")
+    IRR("sgn-BE-fr")
+    IRR("sgn-BE-nl")
+    IRR("sgn-CH-de")
+    IRR("en-GB-oed")
+    IRR("i-default")
+    IRR("i-klingon")
+    IRR("i-navajo")
+    ADD("zh-guoyu")
+    ADD("zh-hakka")
+    ADD("zh-xiang")
+    IRR("i-mingo")
+    IRR("no-bok")
+    IRR("no-nyn")
+    IRR("zh-cmn")
+    IRR("zh-gan")
+    IRR("zh-min")
+    IRR("zh-wuu")
+    IRR("zh-yue")
+    IRR("i-ami")
+    IRR("i-bnn")
+    IRR("i-hak")
+    IRR("i-lux")
+    IRR("i-pwn")
+    IRR("i-tao")
+    IRR("i-tay")
+    IRR("i-tsu")
+  };
+
+static const char *
+step_irregular (const char *tag)
+{
+  int len;
+  size_t i;
+
+  len = strlen (tag);
+  for (i = 0; i < sizeof irregular / sizeof irregular[0]; i++)
+    if ((irregular[i].len == len 
+	 || (irregular[i].len < len && tag[irregular[i].len] == '-'))
+	&& strncasecmp (tag, irregular[i].tag, irregular[i].len) == 0)
+      return irregular[i].tag;
+  return NULL;
+}
+
diff --git a/lang/meson.build b/lang/meson.build
new file mode 100644
index 0000000..23ed6f0
--- /dev/null
+++ b/lang/meson.build
@@ -0,0 +1,15 @@
+# build the lang extension
+
+lang_source = [
+    'xslt-lang.c',
+    'xslt-lang.h',
+    'lang.c',
+    'rfc4647.c',
+    'rfc4647.h'
+]
+
+shared_module('lang', lang_source,
+	      name_prefix : prefix_iarthair,
+	      dependencies : [xsldep],
+	      install_dir: plugin_dir,
+	      install : true)
diff --git a/lang/rfc4647.c b/lang/rfc4647.c
new file mode 100644
index 0000000..7a52b5d
--- /dev/null
+++ b/lang/rfc4647.c
@@ -0,0 +1,104 @@
+#include <stdio.h>
+#include <string.h>
+#include "rfc4647.h"
+
+/* Implement the extended language matching algorithm described in RFC 4647 */
+
+/* Return 1 if lang matches range according to the rules in
+   RFC 4647 section 3.3.2 */
+int
+rfc4647_extended_match (const char *lang, const char *range)
+{
+  const char *tag_lang, *end_tag_lang, *tag_range, *end_tag_range;
+
+  /* 1. Split both the extended language range and the language tag being
+	compared into a list of subtags by dividing on the hyphen (%x2D)
+	character.  Two subtags match if either they are the same when
+	compared case-insensitively or the language range's subtag is the
+	wildcard '*'.  */
+  tag_range = range;
+  if ((end_tag_range = strchr (tag_range, '-')) == NULL)
+    end_tag_range = strchr (tag_range, '\0');
+  tag_lang = lang;
+  if ((end_tag_lang = strchr (tag_lang, '-')) == NULL)
+    end_tag_lang = strchr (tag_lang, '\0');
+
+  /* 2. Begin with the first subtag in each list.  If the first subtag in
+	the range does not match the first subtag in the tag, the overall
+	match fails.  Otherwise, move to the next subtag in both the
+	range and the tag.  */
+  if (end_tag_range - tag_range != 1 || *tag_range != '*')
+    {
+      if (end_tag_range - tag_range != end_tag_lang - tag_lang
+	  || strncasecmp (tag_range, tag_lang, end_tag_lang - tag_lang) != 0)
+	return 0;
+    }
+  if (*(tag_range = end_tag_range) == '-')
+    tag_range++;
+  if ((end_tag_range = strchr (tag_range, '-')) == NULL)
+    end_tag_range = strchr (tag_range, '\0');
+  if (*(tag_lang = end_tag_lang) == '-')
+    tag_lang++;
+  if ((end_tag_lang = strchr (tag_lang, '-')) == NULL)
+    end_tag_lang = strchr (tag_lang, '\0');
+
+  /* 3. While there are more subtags left in the language range's list:
+   */
+  while (*tag_range != '\0')
+    {
+      /* A. If the subtag currently being examined in the range is the
+	    wildcard ('*'), move to the next subtag in the range and
+	    continue with the loop.  */
+      if (end_tag_range - tag_range == 1 && *tag_range == '*')
+	{
+	  if (*(tag_range = end_tag_range) == '-')
+	    tag_range++;
+	  if ((end_tag_range = strchr (tag_range, '-')) == NULL)
+	    end_tag_range = strchr (tag_range, '\0');
+	}
+
+      /* B. Else, if there are no more subtags in the language tag's
+	    list, the match fails.  */
+      else if (*tag_lang == '\0')
+	{
+	  return 0;
+	}
+
+      /* C. Else, if the current subtag in the range's list matches the
+	    current subtag in the language tag's list, move to the next
+	    subtag in both lists and continue with the loop.  */
+      else if (end_tag_range - tag_range == end_tag_lang - tag_lang
+	  && strncasecmp (tag_range, tag_lang, end_tag_lang - tag_lang) == 0)
+	{
+	  if (*(tag_range = end_tag_range) == '-')
+	    tag_range++;
+	  if ((end_tag_range = strchr (tag_range, '-')) == NULL)
+	    end_tag_range = strchr (tag_range, '\0');
+	  if (*(tag_lang = end_tag_lang) == '-')
+	    tag_lang++;
+	  if ((end_tag_lang = strchr (tag_lang, '-')) == NULL)
+	    end_tag_lang = strchr (tag_lang, '\0');
+	}
+
+      /* D. Else, if the language tag's subtag is a "singleton" (a single
+	    letter or digit, which includes the private-use subtag 'x')
+	    the match fails.  */
+      else if (end_tag_lang - tag_lang == 1)
+	{
+	  return 0;
+	}
+
+      /* E. Else, move to the next subtag in the language tag's list and
+	    continue with the loop.  */
+      else
+	{
+	  if (*(tag_lang = end_tag_lang) == '-')
+	    tag_lang++;
+	  if ((end_tag_lang = strchr (tag_lang, '-')) == NULL)
+	    end_tag_lang = strchr (tag_lang, '\0');
+	}
+    }
+  /* 4. When the language range's list has no more subtags, the match
+	succeeds.  */
+  return 1;
+}
diff --git a/lang/rfc4647.h b/lang/rfc4647.h
new file mode 100644
index 0000000..de55f54
--- /dev/null
+++ b/lang/rfc4647.h
@@ -0,0 +1,8 @@
+#ifndef _rfc4647_h
+#define _rfc4647_h
+
+int rfc4647_extended_match (const char *lang, const char *range);
+
+char *canonic_tag (char *buf, size_t bufsize, const char *tag, int full);
+
+#endif
diff --git a/lang/xslt-lang.c b/lang/xslt-lang.c
new file mode 100644
index 0000000..80e6800
--- /dev/null
+++ b/lang/xslt-lang.c
@@ -0,0 +1,393 @@
+#include <ctype.h>
+#include <string.h>
+
+#include <libxml/globals.h>
+#include <libxml/tree.h>
+#include <libxml/xpath.h>
+#include <libxml/xpathInternals.h>
+#include <libxml/parser.h>
+#include <libxml/encoding.h>
+
+#include <libxslt/xsltconfig.h>
+#include <libxslt/xsltutils.h>
+#include <libxslt/xsltInternals.h>
+#include <libxslt/extensions.h>
+
+#include "xslt-lang.h"
+#include "rfc4647.h"
+
+#if !defined (__GNUC__) || __GNUC__ < 2
+# define __attribute__(x)
+#endif
+#define _unused	__attribute__((unused))
+
+static int scan_range (const char *, const char **, char *, size_t);
+static int scan_name (const char *, const char **, char *, size_t);
+
+/****************************************************************************
+ * boolean lang:lang(string)
+ *
+ * Compare string or node's xml:lang against the range using the
+ * RFC 4647 algorithm.  If the range is omitted an application defined
+ * default range is used.
+ ****************************************************************************/
+static void
+lang_lang (xmlXPathParserContextPtr ctxt, int nargs)
+{
+  char *lang, *range;
+
+  if (nargs != 1)
+    {
+      ctxt->error = XPATH_INVALID_ARITY;
+      xsltTransformError (xsltXPathGetTransformContext (ctxt), NULL, NULL,
+			  "lang() takes 1 argument\n");
+      return;
+    }
+
+  range = (char *) xmlXPathPopString (ctxt);
+  if (range == NULL)
+    {
+      xsltTransformError (xsltXPathGetTransformContext (ctxt), NULL, NULL,
+			  "lang() bad argument\n");
+      return;
+    }
+
+  lang = (char *) xmlNodeGetLang (ctxt->context->node);
+  if (lang == NULL)
+    valuePush (ctxt, xmlXPathNewBoolean (0));
+  else
+    valuePush (ctxt, xmlXPathNewBoolean (rfc4647_extended_match (lang, range)));
+  if (range != NULL)
+    xmlFree (range);
+  if (lang != NULL)
+    xmlFree (lang);
+}
+
+/****************************************************************************
+ * node-set lang:accept-lang(node-set,string)
+ *
+ * Return a node-set of elements whose xml:lang is the most specific match for
+ * the RFC 4647 accept-language range specified in the second argument, if
+ * present, or an application specific default.  The range is a space separated
+ * language tag list in order of decreasing preference.
+ ****************************************************************************/
+
+/* Return the length of the common initial span for strings a and b
+   ignoring case for alpha characters */
+static int
+strncaseinitspan (const char *a, const char *b, int len)
+{
+  const char *l = a;
+
+  while (len > 0
+         && ((*l == *b && *l != '\0')
+	     || (isalpha (*l)
+	         && isalpha (*b)
+		 && (isupper (*l) ? (*l == toupper (*b)) : (toupper (*l) == *b))
+		)
+	    )
+	)
+    l++, b++, len--;
+  return l - a;
+}
+
+static int
+compare_range (const char *lang, const char *range, int rlen)
+{
+  int len;
+
+  len = strncaseinitspan (lang, range, rlen);
+  if (len > 0
+      && lang[len] == '\0'
+      && (range[len] == '\0' || range[len] == ' ' || range[len] == '-')
+      && !(len > 2 && range[len-2] == '-'))
+    return len;
+  return 0;
+}
+
+struct params
+  {
+    const char *range, *erange;
+    const xmlChar *lang;
+    int last_len;
+  };
+
+static void
+lang_comp (void *payload _unused, void *data, const xmlChar *lang)
+{
+  struct params *par = data;
+  int len, rlen;
+
+  rlen = par->erange - par->range;
+  if (rlen == 1 && *par->range == '*')
+    len = strlen ((char *) lang);
+  else
+    len = compare_range ((char *) lang, par->range, rlen);
+  if (len > par->last_len)
+    {
+      par->lang = lang;
+      par->last_len = len;
+    }
+}
+
+static xmlXPathObject *
+rfc4647_lookup (xmlHashTable *table, const char *lang)
+{
+  struct params par;
+  xmlXPathObject *set;
+  char range[64+1], canonic[sizeof range];
+  const char *p;
+  int len;
+
+  memset (&par, 0, sizeof par);
+  while ((len = scan_range (lang, &lang, range, sizeof range)) > 0
+         && (par.range = canonic_tag (canonic, sizeof canonic, range, 1)) != NULL)
+    {
+      par.erange = strchr (par.range, '\0');
+
+      /* probe the table for a preferred exact match (the keys in the
+         table are canonic and the range has just been converted) */
+      if ((set = xmlHashLookup (table, cX canonic)) != NULL)
+        {
+	  xmlHashRemoveEntry (table, cX canonic, NULL);
+	  return set;
+	}
+
+      /* no exact match, scan the table for the best (longest) match */
+      xmlHashScan (table, lang_comp, &par);
+      if (par.lang != NULL)
+        {
+	  set = xmlHashLookup (table, par.lang);
+	  xmlHashRemoveEntry (table, par.lang, NULL);
+	  return set;
+	}
+
+      if ((p = strchr (lang, ',')) != NULL)
+        lang = &p[1];
+      else
+	while (isspace (*lang))
+	  lang++;
+    }
+  return NULL;
+}
+
+static void
+free_table (void *payload, const xmlChar *name _unused)
+{
+  xmlXPathObject *obj = payload;
+
+  if (obj != NULL)
+    xmlXPathFreeObject (obj);
+}
+
+static void
+lang_accept_language (xmlXPathParserContextPtr ctxt, int nargs)
+{
+  xmlNode *node;
+  xmlXPathObject *obj, *set, *default_set;
+  xmlHashTable *table;
+  char *lang;
+  char *range;
+  char ctag[256];
+  int i;
+
+  if (nargs != 2)
+    {
+      ctxt->error = XPATH_INVALID_ARITY;
+      xsltTransformError (xsltXPathGetTransformContext (ctxt), NULL, NULL,
+			  "accept-lang() takes 2 arguments\n");
+      return;
+    }
+
+  range = (char *) xmlXPathPopString (ctxt);
+  if (range == NULL)
+    {
+      xsltTransformError (xsltXPathGetTransformContext (ctxt), NULL, NULL,
+			  "accept-lang() expecting a string\n");
+      return;
+    }
+
+  if (ctxt->value == NULL || ctxt->value->type != XPATH_NODESET)
+    {
+      ctxt->error = XPATH_INVALID_TYPE;
+      xsltTransformError (xsltXPathGetTransformContext (ctxt), NULL, NULL,
+			  "accept-lang() expecting a node-set\n");
+      xmlFree (range);
+      return;
+    }
+  obj = valuePop (ctxt);
+  if (obj->nodesetval == NULL)
+    {
+      valuePush (ctxt, xmlXPathNewNodeSet (NULL));
+      xmlFree (range);
+      return;
+    }
+
+  default_set = xmlXPathNewNodeSet (NULL);
+
+  /* Loop over the nodeset and build subsets for each language tag
+     and store in a hash table. */
+  table = xmlHashCreate (obj->nodesetval->nodeNr);
+  for (i = 0; i < obj->nodesetval->nodeNr; i++)
+    {
+      node = obj->nodesetval->nodeTab[i];
+      if ((lang = (char *) xmlNodeGetLang (node)) == NULL)
+	set = default_set;
+      else
+	{
+	  if (canonic_tag (ctag, sizeof ctag, lang, 1) == NULL)
+	    strcpy (ctag, lang);
+	  if ((set = xmlHashLookup (table, cX ctag)) == NULL)
+	    {
+	      set = xmlXPathNewNodeSet (NULL);
+	      xmlHashAddEntry (table, cX ctag, set);
+	    }
+	  xmlFree (lang);
+	}
+      xmlXPathNodeSetAddUnique (set->nodesetval, node);
+    }
+  xmlXPathFreeObject (obj);
+
+  /* Loop over the available language tags and pick the best match.
+     Remove the entry from the table. Destroy the table. */
+  if (range != NULL && (set = rfc4647_lookup (table, range)) != NULL)
+    xmlXPathFreeObject (default_set);
+  else
+    set = default_set;
+  xmlHashFree (table, free_table);
+
+  /* Return the selected node-set */
+  valuePush (ctxt, set);
+  xmlFree (range);
+}
+
+/****************************************************************************
+ * string lang:canonic-lang(string)
+ *
+ * Return the canonic form of the language tag in the string or "" if it is
+ * not a valid RFC 4646 tag.
+ ****************************************************************************/
+
+static void
+lang_canonic_tag (xmlXPathParserContextPtr ctxt, int nargs)
+{
+  char *tag, ntag[256];
+
+  if (nargs != 1)
+    {
+      ctxt->error = XPATH_INVALID_ARITY;
+      xsltTransformError (xsltXPathGetTransformContext (ctxt), NULL, NULL,
+			  "canonic-lang() takes 1 argument\n");
+      return;
+    }
+
+  tag = (char *) xmlXPathPopString (ctxt);
+  if (tag == NULL)
+    {
+      xsltTransformError (xsltXPathGetTransformContext (ctxt), NULL, NULL,
+			  "canonic-lang() bad argument\n");
+      return;
+    }
+
+  if (canonic_tag (ntag, sizeof ntag, tag, 1) == NULL)
+    ntag[0] = '\0';
+  valuePush (ctxt, xmlXPathNewCString (ntag));
+  xmlFree (tag);
+}
+
+/****************************************************************************
+ * string lang:extract-lang(string)
+ *
+ * Extract the language tag from the string or "" if it is not a valid
+ * RFC 4646 tag.
+ ****************************************************************************/
+
+static void
+lang_tag (xmlXPathParserContextPtr ctxt, int nargs)
+{
+  char *tag, ntag[256];
+
+  if (nargs != 1)
+    {
+      ctxt->error = XPATH_INVALID_ARITY;
+      xsltTransformError (xsltXPathGetTransformContext (ctxt), NULL, NULL,
+			  "extract-lang() takes 1 argument\n");
+      return;
+    }
+
+  tag = (char *) xmlXPathPopString (ctxt);
+  if (tag == NULL)
+    {
+      xsltTransformError (xsltXPathGetTransformContext (ctxt), NULL, NULL,
+			  "extract-lang() bad argument\n");
+      return;
+    }
+
+  if (canonic_tag (ntag, sizeof ntag, tag, 0) == NULL)
+    ntag[0] = '\0';
+  valuePush (ctxt, xmlXPathNewCString (ntag));
+  xmlFree (tag);
+}
+
+/****************************************************************************/
+
+static int
+scan_name (const char *s, const char **es, char *buf, size_t buflen)
+{
+  char *t;
+
+  buflen -= 1;			/* Leave space for \0 */
+  while (isspace (*s))
+    s++;
+  if (!isalpha (*s))
+    return 0;
+  t = buf;
+  *t++ = *s++;
+  if (!(isalnum (*s) || *s == '-'))
+    return 0;
+  do
+    {
+      if (s[0] == '-' && !isalnum (s[1]))
+	return 0;
+      if (t < &buf[buflen])
+	*t++ = *s;
+      s++;
+    }
+  while (isalnum (*s) || *s == '-');
+  *t = '\0';
+  if (es != NULL)
+    *es = s;
+  return t - buf;
+}
+
+static int
+scan_range (const char *s, const char **es, char *buf, size_t buflen)
+{
+  while (isspace (*s))
+    s++;
+  if (*s == '*')
+    {
+      strcpy (buf, "*");
+      if (es != NULL)
+	*es = s + 1;
+      return 1;
+    }
+  return scan_name (s, es, buf, buflen);
+}
+
+/****************************************************************************/
+
+void
+xsltLangRegister (void)
+{
+  /* Tag matching functions */
+  xsltRegisterExtModuleFunction (cX"lang", XSLT_LANG_NAMESPACE, lang_lang);
+  xsltRegisterExtModuleFunction (cX"accept-lang", XSLT_LANG_NAMESPACE,
+  				 lang_accept_language);
+  /* Return the canonic version of the tag */
+  xsltRegisterExtModuleFunction (cX"canonic-lang", XSLT_LANG_NAMESPACE,
+  				 lang_canonic_tag);
+  /* Extract the language portion of the tag */
+  xsltRegisterExtModuleFunction (cX"extract-lang", XSLT_LANG_NAMESPACE,
+  				 lang_tag);
+}
diff --git a/lang/xslt-lang.h b/lang/xslt-lang.h
new file mode 100644
index 0000000..662282f
--- /dev/null
+++ b/lang/xslt-lang.h
@@ -0,0 +1,31 @@
+#ifndef __XSLT_LANG_H__
+#define __XSLT_LANG_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef LIBEXSLT_PUBLIC
+#define LIBEXSLT_PUBLIC
+#endif
+
+#define cX              (const xmlChar *)
+
+/**
+ * XSLT_LANG_NAMESPACE:
+ *
+ * Namespace for EXSLT lang functions
+ */
+#define XSLT_LANG_NAMESPACE (cX"http://iarthair.github.io/lang")
+
+#ifdef MODULE
+#define xsltLangRegister iarthair_github_io_lang_init
+#endif
+
+LIBEXSLT_PUBLIC void xsltLangRegister (void);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* __XSLT_LANG_H__ */
+
diff --git a/meson.build b/meson.build
new file mode 100644
index 0000000..7d808bd
--- /dev/null
+++ b/meson.build
@@ -0,0 +1,42 @@
+project('xslt-extra', 'c', version : '1.0.1', default_options: ['c_std=c11'])
+cc = meson.get_compiler('c')
+
+cflags = [
+    '-D_GNU_SOURCE',
+    '-DMODULE'
+]
+if get_option('warning_level') == '3'
+    cflags += [
+	'-Wstrict-prototypes',
+	'-Wmissing-prototypes',
+	'-Wnested-externs',
+	'-Walloc-zero',
+	'-Wduplicated-branches',
+	'-Wpointer-arith',
+	'-Wcast-align',
+	'-Wwrite-strings',
+	'-Wdeclaration-after-statement',
+	'-Wshadow',
+	'-Wredundant-decls',
+	'-Wpacked',
+	'-Wbad-function-cast',
+    ]
+endif
+add_project_arguments(cc.get_supported_arguments(cflags), language: 'c')
+
+# use for extensions described at www.exslt.org
+ns_exslt = ['exslt','org']
+prefix_exslt = '_'.join(ns_exslt) + '_'
+domain_exslt = '.'.join(ns_exslt)
+
+# use for other extensions
+ns_iarthair = ['iarthair','github','io']
+prefix_iarthair = '_'.join(ns_iarthair) + '_'
+domain_iarthair = '.'.join(ns_iarthair)
+
+xsldep = dependency('libxslt')
+plugin_dir = xsldep.get_variable(pkgconfig : 'libdir') / 'libxslt-plugins'
+
+subdir('script')
+subdir('lang')
+subdir('functions')
diff --git a/mkdocs.yml b/mkdocs.yml
new file mode 100644
index 0000000..0315f06
--- /dev/null
+++ b/mkdocs.yml
@@ -0,0 +1,24 @@
+site_name: Libxslt Extension Modules
+theme: readthedocs
+repo_url: https://github.com/iarthair/xslt-extra
+use_directory_urls: false
+site_author: 'Brian Stafford'
+copyright: '© 2020 Brian Stafford'
+markdown_extensions:
+    - admonition
+nav:
+    - Home: index.md
+    - Download: download.md
+    - Usage: usage.md
+    - Functions:
+        - String: functions.md
+        - URI: uri-functions.md
+        - Language Tags: lang.md
+        - Miscellaneous: misc-functions.md
+        - Posix RE: regexp.md
+    - Scripts: script.md
+    - Lua:
+        - Libxslt: lualibxslt.md
+        - XML doc: luaxmldoc.md
+        - XML node: luaxmlnode.md
+        - XSL-T node-set: luaxpathnodeset.md
diff --git a/script/exslt-script-lua.c b/script/exslt-script-lua.c
new file mode 100644
index 0000000..d18b430
--- /dev/null
+++ b/script/exslt-script-lua.c
@@ -0,0 +1,279 @@
+#include <string.h>
+#include <stdlib.h>
+
+#include <libxml/tree.h>
+#include <libxml/xpath.h>
+#include <libxml/xpathInternals.h>
+
+#include <libxslt/xsltutils.h>
+
+#define cX              (const xmlChar *)
+
+#include "script.h"
+
+#define _unused      __attribute__((unused))
+
+#include <lua.h>
+#include <lualib.h>
+#include <lauxlib.h>
+#include "lua-xml.h"
+
+static script_t *init_lua (const implementation_t *implementation);
+static void compile_lua (const script_t *script, const char *uri, readcb_t reader, void *arg);
+static int call_lua (const script_t *script, const char *uri, const char *function,
+		     xmlXPathParserContext *ctxt, int nargs);
+static void destroy_lua (const script_t *script);
+static void register_extra (lua_State *lua);
+
+static const struct implementation lua_implementation =
+  {
+    init_lua, compile_lua, call_lua, destroy_lua,
+  };
+
+//XXX - real version would load modules etc.
+const implementation_t *
+script_lookup_language (const char *language)
+{
+  return strcmp (language, "Lua") == 0 ? &lua_implementation : NULL;
+}
+
+/*****************************************************************************
+ * Create & destroy the Lua context
+ *****************************************************************************/
+
+static int
+register_libxslt (lua_State *lua)
+{
+  luaopen_xml (lua);
+  register_extra (lua);
+  return 1;
+}
+
+static script_t *
+init_lua (const implementation_t *implementation)
+{
+  lua_State *lua;
+  script_t *script;
+
+  if ((script = malloc (sizeof (script_t))) == NULL
+      || (lua = luaL_newstate ()) == NULL)
+    {
+      xsltGenericError (xsltGenericErrorContext, "Lua Initialisation Error\n");
+      free (script);
+      return NULL;
+    }
+
+  luaL_openlibs (lua);
+  luaL_requiref (lua, "libxslt", register_libxslt, 0);
+  lua_pop (lua, 1);
+
+  script->implementation = (implementation_t *) implementation;
+  script->state = lua;
+  return script;
+}
+
+static void
+destroy_lua (const script_t *script)
+{
+  lua_State *lua = script->state;
+
+  if (lua != NULL)
+    lua_close (lua);
+}
+
+struct ctx
+  {
+    readcb_t reader;
+    void *arg;
+  };
+
+static void
+compile_lua (const script_t *script, const char *uri, readcb_t reader, void *arg)
+{
+  lua_State *lua = script->state;
+  int top;
+  const char *name;
+
+  top = lua_gettop (lua);
+
+  if (lua_load (lua, (lua_Reader) reader, arg, "<func:script>", NULL) != 0)
+    xsltGenericError (xsltGenericErrorContext,
+		      "Lua Parse Error: %s\n", lua_tostring (lua, -1));
+  else if (lua_pcall (lua, 0, 1, 0) != 0)
+    xsltGenericError (xsltGenericErrorContext,
+		      "Lua Execute Error: %s\n", lua_tostring (lua, -1));
+  else
+    {
+      lua_pushvalue (lua, -1);
+      /* save table */
+      lua_setfield (lua, LUA_REGISTRYINDEX, uri);
+      /* iterate table */
+      lua_pushnil (lua);
+      while (lua_next (lua, -2) != 0)
+        {
+	  /* key at -2, value at -1 */
+	  if (lua_isstring (lua, -2) && lua_isfunction (lua, -1))
+	    {
+	      name = lua_tostring (lua, -2);
+	      script_register_hook (name, uri);
+	    }
+	  lua_pop (lua, 1); /* remove value, keep key */
+	}
+    }
+
+  lua_settop (lua, top);
+}
+
+/*****************************************************************************
+ * 
+ *****************************************************************************/
+static int
+call_lua (const script_t *script, const char *uri, const char *function,
+	  xmlXPathParserContext *ctxt, int nargs)
+{
+  lua_State *lua = script->state;
+  int i, top;
+  xmlXPathObject *obj;
+  xmlNodeSet *nodeset;
+  xmlNode *node;
+
+  top = lua_gettop (lua);
+
+  /* save the XPath context in the registry */
+  lua_pushlightuserdata (lua, ctxt->context);
+  lua_setfield (lua, LUA_REGISTRYINDEX, "XPath.ctxt");
+
+  /* Look up Lua function f = REGISTRY[uri][function] and call it */
+  lua_getfield (lua, LUA_REGISTRYINDEX, uri);
+  lua_pushstring (lua, function);
+  lua_gettable (lua, -2);
+  if (!lua_isfunction (lua, -1))
+    {
+      xsltGenericError (xsltGenericErrorContext, "Invalid Lua function\n");
+      lua_settop (lua, top);
+      return 0;
+    }
+
+  /* pop and convert the XPath arguments */
+  for (i = 0; i < nargs; i++)
+    {
+      obj = valuePop (ctxt);
+      switch (obj->type)
+        {
+	case XPATH_NODESET:
+	case XPATH_XSLT_TREE:
+	  luaX_pushnodeset (lua, xmlXPathNodeSetMerge (NULL, obj->nodesetval));
+	  break;
+	case XPATH_BOOLEAN:
+	  lua_pushboolean (lua, obj->boolval);
+	  break;
+	case XPATH_NUMBER:
+	  lua_pushnumber (lua, obj->floatval);
+	  break;
+	case XPATH_STRING:
+	  lua_pushstring (lua, (char *) obj->stringval);
+	  break;
+	default:
+	  xsltGenericError (xsltGenericErrorContext,
+	  		    "pushing unknown argument type %d\n", obj->type);
+	  break;
+	}
+      xmlXPathFreeObject (obj);
+    }
+  /* reverse arguments on the Lua stack */
+  for (i = -nargs; i < -1; i++)
+    lua_insert (lua, i);
+
+  //XXX attach the XPath context somehow so that it's available to
+  //   the Lua callable C functions.
+  /* call the Lua function and convert the result as required */
+  if (lua_pcall (lua, nargs, 1, 0) != 0)
+    xsltGenericError (xsltGenericErrorContext, "Lua Error: %s\n",
+		      lua_tostring (lua, -1));
+  else
+    switch (lua_type (lua, -1))
+      {
+      case LUA_TNUMBER:
+	valuePush (ctxt, xmlXPathNewFloat (lua_tonumber (lua, -1)));
+	break;
+      case LUA_TBOOLEAN:
+	valuePush (ctxt, xmlXPathNewBoolean (lua_toboolean (lua, -1)));
+	break;
+      case LUA_TSTRING:
+	valuePush (ctxt, xmlXPathNewCString (lua_tostring (lua, -1)));
+	break;
+      case LUA_TUSERDATA:
+        if ((nodeset = luaX_tonodeset (lua, -1)) != NULL)
+	  {
+	    valuePush (ctxt, xmlXPathWrapNodeSet (
+					  xmlXPathNodeSetMerge (NULL, nodeset)
+						 ));
+	    break;
+	  }
+	if ((node = luaX_tonode (lua, -1)) != NULL)
+	  {
+	    valuePush (ctxt, xmlXPathNewNodeSet (node));
+	    break;
+	  }
+        /* ELSE FALL THROUGH */
+      default:
+	xsltGenericError (xsltGenericErrorContext, "invalid return value %s\n",
+			  lua_typename (lua, (lua_type (lua, -1))));
+	break;
+      }
+
+  lua_pushnil (lua);
+  lua_setfield (lua, LUA_REGISTRYINDEX, "XPath.ctxt");
+
+  lua_settop (lua, top);
+  return 0;
+}
+
+static int
+nodeset_current (lua_State *lua)
+{
+  xmlXPathContext *ctxt;
+
+  lua_getfield (lua, LUA_REGISTRYINDEX, "XPath.ctxt");
+  ctxt = lua_touserdata (lua, -1);
+  lua_pop (lua, 1);
+  return luaX_pushnodeset (lua, xmlXPathNodeSetCreate (ctxt->node));
+}
+
+static int
+nodeset_position (lua_State *lua)
+{
+  xmlXPathContext *ctxt;
+
+  lua_getfield (lua, LUA_REGISTRYINDEX, "XPath.ctxt");
+  ctxt = lua_touserdata (lua, -1);
+  lua_pop (lua, 1);
+  lua_pushinteger (lua, ctxt->proximityPosition);
+  return 1;
+}
+
+static int
+nodeset_last (lua_State *lua)
+{
+  xmlXPathContext *ctxt;
+
+  lua_getfield (lua, LUA_REGISTRYINDEX, "XPath.ctxt");
+  ctxt = lua_touserdata (lua, -1);
+  lua_pop (lua, 1);
+  lua_pushinteger (lua, ctxt->contextSize);
+  return 1;
+}
+
+static const struct luaL_Reg nodeset_extra_f[] =
+  {
+    { "current", nodeset_current }, /* ns = nodeset.current() */
+    { "position", nodeset_position }, /* pos = nodeset.position() */
+    { "last", nodeset_last }, /* pos = nodeset.last() */
+    { NULL, NULL }
+  };
+
+static void
+register_extra (lua_State *lua)
+{
+  luaL_setfuncs (lua, nodeset_extra_f, 0);
+}
diff --git a/script/exslt-script.c b/script/exslt-script.c
new file mode 100644
index 0000000..58a945d
--- /dev/null
+++ b/script/exslt-script.c
@@ -0,0 +1,265 @@
+#include <string.h>
+#include <stdlib.h>
+#include <ctype.h>
+
+#include <libxml/tree.h>
+#include <libxml/xpath.h>
+#include <libxml/hash.h>
+#include <libxml/xmlerror.h>
+#include <libxml/xpathInternals.h>
+#include <libxml/xmlIO.h>
+#include <libxml/uri.h>
+
+#include <libxslt/xsltutils.h>
+#include <libxslt/xsltInternals.h>
+#include <libxslt/templates.h>
+#include <libxslt/extensions.h>
+
+#include "exslt-script.h"
+#include "script.h"
+
+#define _unused      __attribute__((unused))
+
+/*****************************************************************************
+ *****************************************************************************/
+
+static script_t *
+init_script (const implementation_t *implementation)
+{
+  return (*implementation->init) (implementation);
+}
+
+static void
+destroy_script (script_t *script)
+{
+  (*script->implementation->destroy) (script);
+}
+
+static void
+compile_script (script_t *script, const char *uri, readcb_t reader, void *arg)
+{
+  (*script->implementation->compile) (script, uri, reader, arg);
+}
+
+static int
+call_script_function (script_t *script, const char *uri, const char *function,
+		      xmlXPathParserContext *ctxt, int nargs)
+{
+  return (*script->implementation->call) (script, uri, function, ctxt, nargs);
+}
+
+/*****************************************************************************
+ *****************************************************************************/
+
+static void *
+script_style_init (xsltStylesheet *style _unused, const xmlChar *uri _unused)
+{
+  return xmlHashCreate (10);
+}
+
+static void
+destroy_script_cb (void *payload, const xmlChar *name _unused)
+{
+  script_t *script = payload;
+
+  destroy_script (script);
+}
+
+static void
+script_style_shutdown (xsltStylesheet *style _unused,
+		       const xmlChar *uri _unused, void *data)
+{
+  xmlHashFree (data, destroy_script_cb);
+}
+
+/*****************************************************************************
+ *****************************************************************************/
+
+struct buffer
+  {
+    const char *(*reader) (void *, void *, size_t *);
+    void *arg;
+    const char *uri;
+    char data[4096];
+  };
+
+static const char *
+script_readfile_cb (void *state _unused, void *stream, size_t *size)
+{
+  struct buffer *buf = stream;
+  size_t len;
+
+  len = fread (buf->data, sizeof (char), sizeof buf->data, buf->arg);
+  *size = len;
+  return len > 0 ? buf->data : NULL;
+}
+
+static const char *
+script_readstring_cb (void *state _unused, void *stream, size_t *size)
+{
+  struct buffer *buf = stream;
+  const char *data;
+
+  if (buf->arg == NULL)
+    return NULL;
+  data = buf->arg;
+  buf->arg = NULL;
+  *size = strlen (data);
+  return data;
+}
+
+/*****************************************************************************
+ *****************************************************************************/
+
+static void
+script_comp (xsltStylesheet *style, xmlNode *inst)
+{
+  xmlHashTable *style_data;
+  xmlNs *ns;
+  const xmlChar *prefix, *language, *value;
+  xmlChar *base;
+  char *src, *source;
+  script_t *script;
+  const implementation_t *implementation;
+  struct buffer buf;
+  FILE *fp;
+
+  if (style == NULL || inst == NULL)
+    return;
+
+  style_data = xsltStyleGetExtData (style, EXSLT_SCRIPT_NAMESPACE);
+  if (style_data == NULL)
+    {
+      xsltGenericError (xsltGenericErrorContext,
+			"script_comp: no stylesheet data\n");
+      return;
+    }
+
+  /* check required attributes are present */
+  prefix = xsltGetCNsProp (style, inst, cX"implements-prefix",
+			   EXSLT_SCRIPT_NAMESPACE);
+  language = xsltGetCNsProp (style, inst, cX"language", EXSLT_SCRIPT_NAMESPACE);
+  if (prefix == NULL || language == NULL)
+    {
+      xsltGenericError (xsltGenericErrorContext, "script_comp: "
+			"implements-prefix and language attributes "
+			"must both be specified\n");
+      return;
+    }
+
+  /* check prefix */
+  if ((ns = xmlSearchNs (inst->doc, inst, prefix)) == NULL)
+    {
+      xsltGenericError (xsltGenericErrorContext, "script_comp: "
+      			"unknown prefix '%s'\n", prefix);
+      return;
+    }
+
+  /* check language is implemented */
+  if ((implementation = script_lookup_language ((const char *) language)) == NULL)
+    {
+      xsltGenericError (xsltGenericErrorContext, "script_comp: "
+      			"unknown language '%s'\n", language);
+      return;
+    }
+
+  /* ignore element if this namespace is already implemented by a
+     different language */
+  if ((script = xmlHashLookup (style_data, ns->href)) != NULL
+      && script->implementation != implementation)
+    return;
+
+  /* fetch the source either from the element content or the src attribute */
+  source = NULL;
+  src = NULL;
+  fp = NULL;
+  value = xsltGetCNsProp (style, inst, cX"src", EXSLT_SCRIPT_NAMESPACE);
+  if (value != NULL)
+    {
+      if ((base = xmlNodeGetBase (inst->doc, inst)) != NULL)
+	{
+	  src = (char *) xmlBuildURI (value, base);
+	  xmlFree (base);
+	}
+      else
+	src = (char *) xmlBuildURI (value, inst->doc->URL);
+      if ((fp = fopen (src, "r")) == NULL)
+        {
+	  xsltGenericError (xsltGenericErrorContext, "script_comp: "
+			    "can't open %s\n", src);
+	  xmlFree (src);
+	  return;
+	}
+      buf.reader = script_readfile_cb;
+      buf.arg = fp;
+      buf.uri = src;
+    }
+  else if ((source = (char *) xmlNodeGetContent (inst)) != NULL
+  	   && *source != '\0')
+    {
+      buf.reader = script_readstring_cb;
+      buf.arg = source;
+      value = xsltGetCNsProp (style, inst, cX"id", EXSLT_SCRIPT_NAMESPACE);
+      buf.uri = (value != NULL) ? (const char *) value : "node-content";
+    }
+  else
+    {
+      xsltGenericError (xsltGenericErrorContext, "script_comp: "
+      			"missing script source\n");
+      return;
+    }
+
+  /* compile_script() creates a registry for Lua functions accessed by a
+     combination of namespace URI and function name.
+     xsltRegisterExtModuleFunction () is called to register
+     script_function_hook() for each Lua function.  Implementation
+     dependent variables are set up when compile_script() is first called
+     for a particular scripting language. */
+  if (script == NULL)
+    {
+      script = init_script (implementation);
+      xmlHashAddEntry (style_data, ns->href, script);
+    }
+  compile_script (script, (const char *) ns->href, buf.reader, &buf);
+  if (fp != NULL)
+    fclose (fp);
+  xmlFree (source);
+  xmlFree (src);
+}
+
+static void
+script_function_hook (xmlXPathParserContextPtr ctxt, int nargs)
+{
+  xsltTransformContext *tctxt;
+  xmlHashTable *style_data;
+  script_t *script;
+
+  tctxt = xsltXPathGetTransformContext (ctxt);
+  style_data = xsltStyleGetExtData (tctxt->style, EXSLT_SCRIPT_NAMESPACE);
+  script = xmlHashLookup (style_data, ctxt->context->functionURI);
+  call_script_function (script, (const char *) ctxt->context->functionURI,
+		        (const char *) ctxt->context->function, ctxt, nargs);
+}
+
+void
+script_register_hook (const char *name, const char *uri)
+{
+  xsltRegisterExtModuleFunction (cX name, cX uri, script_function_hook);
+}
+
+
+
+/*****************************************************************************
+ * 
+ *****************************************************************************/
+
+void
+exslt_script_register (void)
+{
+  xsltRegisterExtModuleFull (EXSLT_SCRIPT_NAMESPACE,
+			     NULL, NULL,
+			     script_style_init, script_style_shutdown);
+
+  xsltRegisterExtModuleTopLevel ((const xmlChar *) "script",
+				 EXSLT_SCRIPT_NAMESPACE, script_comp);
+}
diff --git a/script/exslt-script.h b/script/exslt-script.h
new file mode 100644
index 0000000..52410dd
--- /dev/null
+++ b/script/exslt-script.h
@@ -0,0 +1,31 @@
+#ifndef __EXSLT_SCRIPT_H__
+#define __EXSLT_SCRIPT_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef LIBEXSLT_PUBLIC
+#define LIBEXSLT_PUBLIC
+#endif
+
+#define cX              (const xmlChar *)
+
+/**
+ * EXSLT_SCRIPT_NAMESPACE:
+ *
+ * Namespace for EXSLT script functions
+ */
+#define EXSLT_SCRIPT_NAMESPACE (cX"http://exslt.org/functions")
+
+#ifdef MODULE
+#define exslt_script_register exslt_org_functions_init
+#endif
+
+LIBEXSLT_PUBLIC void exslt_script_register (void);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* __EXSLT_SCRIPT_H__ */
+
diff --git a/script/lua-xml.c b/script/lua-xml.c
new file mode 100644
index 0000000..b03a2de
--- /dev/null
+++ b/script/lua-xml.c
@@ -0,0 +1,896 @@
+#include <assert.h>
+#include <syslog.h>
+#include <string.h>
+#include <stddef.h>
+
+#include <libxml/tree.h>
+#include <libxml/xmlsave.h>
+#include <libxml/xpath.h>
+#include <libxml/xpathInternals.h>
+
+#include <lua.h>
+#include <lualib.h>
+#include <lauxlib.h>
+#include "luatools.h"
+#include "lua-xml.h"
+
+#define cX              (const xmlChar *)
+#define container_of(ptr, type, member) ( \
+      (type *) \
+      ((char *)(1 ? (ptr) : &((type *)0)->member) - offsetof(type, member)) \
+)
+
+/*****************************************************************************
+ 	Utility functions
+ *****************************************************************************/
+static int
+userdata_index (lua_State *lua)
+{
+  const struct luaL_Reg *prop;
+
+  lua_getmetatable (lua, 1);
+  lua_pushvalue (lua, 2);
+  lua_rawget (lua, -2);
+  if (lua_islightuserdata (lua, -1))
+    {
+      prop = lua_touserdata (lua, -1);
+      lua_pop (lua, 2);	/* pop metatable and lightuserdata */
+      return (*prop->func) (lua);
+    }
+  lua_replace (lua, -2); /* remove metatable */
+  return 1;
+}
+
+static void
+luaX_registerprop (lua_State *lua, const struct luaL_Reg *props)
+{
+  lua_pushcfunction (lua, userdata_index);
+  lua_setfield (lua, -2, "__index");
+  while (props->name != NULL)
+    {
+      lua_pushlightuserdata (lua, (void *) props);
+      lua_setfield (lua, -2, props->name);
+      props++;
+    }
+}
+
+/*****************************************************************************/
+
+static int
+serialize_cb (void *context, const char *buffer, int len)
+{
+  lua_State *lua = context;
+
+  lua_pushvalue (lua, -1);
+  lua_pushlstring (lua, buffer, len);
+  lua_call (lua, 1, 0);
+  return len;
+}
+
+/*****************************************************************************
+	Documents
+ *****************************************************************************/
+xmlDoc *
+luaX_checkdoc (lua_State *lua, int index)
+{
+  return luatool_checktype (lua, index, "luaX.doc");
+}
+
+xmlDoc *
+luaX_todoc (lua_State *lua, int index)
+{
+  return luatool_totype (lua, index, "luaX.doc");
+}
+
+int
+luaX_pushdoc (lua_State *lua, xmlDoc *doc)
+{
+  return luatool_wrap_unique (lua, doc, "luaX.doc");
+}
+
+static void *do_gc = &do_gc;
+
+void
+doc_mark_gc (xmlDoc *doc)
+{
+  doc->_private = &do_gc;
+}
+
+static int
+doc_name (lua_State *lua)
+{
+  xmlDoc *doc = luaX_checkdoc (lua, 1);
+
+  lua_pushstring (lua, (const char *) doc->name);
+  return 1;
+}
+
+static int
+doc_url (lua_State *lua)
+{
+  xmlDoc *doc = luaX_checkdoc (lua, 1);
+
+  lua_pushstring (lua, (const char *) doc->URL);
+  return 1;
+}
+
+/* usage: doc:serialize(function (text) io.write (text) end) */
+static int
+doc_serialize (lua_State *lua)
+{
+  xmlDoc *doc = luaX_todoc (lua, 1);
+  xmlSaveCtxt *ctxt;
+
+  if (!lua_isfunction (lua, 2))
+    {
+      syslog (LOG_ERR, "XML serialize: Invalid callback\n");
+      return 0;
+    }
+  ctxt = xmlSaveToIO (serialize_cb, NULL, lua, "UTF-8", XML_SAVE_FORMAT);
+  xmlSaveDoc (ctxt, doc);
+  xmlSaveClose (ctxt);
+  return 0;
+}
+
+static int
+doc_setroot (lua_State *lua)
+{
+  xmlDoc *doc = luaX_checkdoc (lua, 1);
+  xmlNode *node = luaX_checknode (lua, 2);
+
+  return luaX_pushnode (lua, xmlDocSetRootElement (doc, node));
+}
+
+static int
+doc_root (lua_State *lua)
+{
+  xmlDoc *doc = luaX_checkdoc (lua, 1);
+
+  return luaX_pushnode (lua, xmlDocGetRootElement (doc));
+}
+
+static int
+doc_node_new (lua_State *lua)
+{
+  xmlDoc *doc = luaX_checkdoc (lua, 1);
+  const char *name;
+  xmlNode *node;
+
+  name = lua_tostring (lua, 2);
+  node = xmlNewDocNode (doc, NULL, (xmlChar *) name, NULL);
+  return luaX_pushnode (lua, node);
+}
+
+static int
+doc_gc (lua_State *lua)
+{
+  xmlDoc *doc = luaX_checkdoc (lua, 1);
+
+  if (doc->_private == &do_gc)
+    xmlFreeDoc (doc);
+  return 1;
+}
+
+static const struct luaL_Reg doc_m[] =
+  {
+    { "__gc", doc_gc }, /* f(t) */
+    { "node", doc_node_new }, /* f(t,name) */
+    { "serialize", doc_serialize }, /* f(t,func) */
+    { "setroot", doc_setroot }, /* f(t,node) */
+    { NULL, NULL }
+  };
+
+static const struct luaL_Reg doc_p[] =
+  {
+    { "name", doc_name }, /* string */
+    { "root", doc_root }, /* doc */
+    { "url", doc_url }, /* string */
+    { NULL, NULL }
+  };
+
+/*****************************************************************************
+ * XPath Node Sets
+ *****************************************************************************/
+xmlNodeSet *
+luaX_checknodeset (lua_State *lua, int index)
+{
+  return luatool_checktype (lua, index, "luaX.nodeset");
+}
+
+xmlNodeSet *
+luaX_tonodeset (lua_State *lua, int index)
+{
+  return luatool_totype (lua, index, "luaX.nodeset");
+}
+
+int
+luaX_pushnodeset (lua_State *lua, xmlNodeSet *nodeset)
+{
+  return luatool_wrap (lua, nodeset, "luaX.nodeset");
+}
+
+/*****************************************************************************/
+
+static int
+nodeset_new (lua_State *lua)
+{
+  xmlNode *node = luaX_tonode (lua, 1);
+
+  return luaX_pushnodeset (lua, xmlXPathNodeSetCreate (node));
+}
+
+static int
+nodeset_new_empty (lua_State *lua)
+{
+  return luaX_pushnodeset (lua, xmlXPathNodeSetCreate (NULL));
+}
+
+
+static int
+nodeset_free (lua_State *lua)
+{
+  xmlNodeSet *set = luaX_checknodeset (lua, 1);
+
+  xmlXPathFreeNodeSet (set);
+  return 1;
+}
+
+static int
+nodeset_tostring (lua_State *lua)
+{
+  xmlNodeSet *set = luaX_checknodeset (lua, 1);
+  char *str;
+
+  str = (char *) xmlXPathCastNodeSetToString (set);
+  lua_pushstring (lua, str);
+  xmlFree (str);
+  return 1;
+}
+
+static int
+nodeset_merge (lua_State *lua)
+{
+  xmlNodeSet *lhs = luaX_checknodeset (lua, 1);
+  xmlNodeSet *rhs = luaX_checknodeset (lua, 2);
+  xmlNodeSet *nodeset;
+
+  nodeset = xmlXPathNodeSetMerge (NULL, lhs);
+  return luaX_pushnodeset (lua, xmlXPathNodeSetMerge (nodeset, rhs));
+}
+
+static int
+nodeset_intersection (lua_State *lua)
+{
+  xmlNodeSet *lhs = luaX_checknodeset (lua, 1);
+  xmlNodeSet *rhs = luaX_checknodeset (lua, 2);
+
+  return luaX_pushnodeset (lua, xmlXPathIntersection (lhs, rhs));
+}
+
+static int
+nodeset_difference (lua_State *lua)
+{
+  xmlNodeSet *lhs = luaX_checknodeset (lua, 1);
+  xmlNodeSet *rhs = luaX_checknodeset (lua, 2);
+
+  return luaX_pushnodeset (lua, xmlXPathDifference (lhs, rhs));
+}
+
+static int
+nodeset_size (lua_State *lua)
+{
+  xmlNodeSet *set = luaX_checknodeset (lua, 1);
+
+  lua_pushnumber (lua, xmlXPathNodeSetGetLength (set));
+  return 1;
+}
+
+static int
+nodeset_sort (lua_State *lua)
+{
+  xmlNodeSet *set = luaX_checknodeset (lua, 1);
+  xmlNodeSet *nodeset;
+
+  nodeset = xmlXPathNodeSetMerge (NULL, set);
+  xmlXPathNodeSetSort (nodeset);
+  return luaX_pushnodeset (lua, nodeset);
+}
+
+static int
+nodeset_index (lua_State *lua)
+{
+  xmlNodeSet *set = luaX_checknodeset (lua, 1);
+  int index;
+  xmlNode *node;
+
+  if (lua_isnumber (lua, 2))
+    {
+      index = lua_tointeger (lua, 2);
+      node = xmlXPathNodeSetItem (set, index - 1);
+      luaL_argcheck (lua, node != NULL, 2, "index out of range");
+      return luaX_pushnode (lua, node);
+    }
+
+  /* try to find the method function in the metatable */
+  lua_getmetatable (lua, 1);
+  lua_pushvalue (lua, 2);
+  lua_rawget (lua, -2);
+  lua_replace (lua, -2);	/* remove unneeded metatable from the stack */
+  return 1;
+}
+
+static int
+nodeset_add (lua_State *lua)
+{
+  xmlNodeSet *set = luaX_checknodeset (lua, 1);
+  xmlNode *node = luaX_checknode (lua, 2);
+
+  xmlXPathNodeSetAddUnique (set, node);
+  lua_settop (lua, 1);
+  return 1;
+}
+
+struct nodeset_iterator
+  {
+    xmlNodeSet *set;
+    int index;
+  };
+
+static int
+nodeset_iterator (lua_State *lua)
+{
+  struct nodeset_iterator *nsi;
+
+  nsi = lua_touserdata (lua, lua_upvalueindex (1));
+  if (nsi->index >= nsi->set->nodeNr)
+    return 0;
+  luaX_pushnode (lua, nsi->set->nodeTab[nsi->index++]);
+  return 1;
+}
+
+static int
+nodeset_list (lua_State *lua)
+{
+  struct nodeset_iterator *nsi;
+
+  nsi = lua_newuserdata (lua, sizeof (struct nodeset_iterator));
+  nsi->index = 0;
+  nsi->set = luaX_checknodeset (lua, 1);
+  lua_pushcclosure (lua, nodeset_iterator, 1);
+  return 1;
+}
+
+
+static const struct luaL_Reg nodesetlib_m[] =
+  {
+    { "__add", nodeset_merge }, /* f(lhs,rhs) */
+    { "__gc", nodeset_free }, /* f(op) */
+    { "__index", nodeset_index }, /* f(t,key) */
+    { "__len", nodeset_size }, /* f(op) */
+    { "__mul", nodeset_intersection }, /* f(lhs,rhs) */
+    { "__sub", nodeset_difference }, /* f(lhs,rhs) */
+    { "__tostring", nodeset_tostring }, /* f(op) */
+    { "add", nodeset_add }, /* f(ns,node) */
+    { "list", nodeset_list }, /* f(ns,node) */
+    { "sort", nodeset_sort }, /* f(ns) */
+    { NULL, NULL }
+  };
+
+/*****************************************************************************
+	Attributes
+  NB must offset node pointer otherwise luatool_wrap_unique() will fail.
+ *****************************************************************************/
+
+xmlNode *
+luaX_toattrs (lua_State *lua, int index)
+{
+  xmlAttr **attrs = luatool_totype (lua, index, "luaX.attr");
+
+  return container_of (attrs, xmlNode, properties);
+}
+
+int
+luaX_pushattrs (lua_State *lua, xmlNode *node)
+{
+  return luatool_wrap_unique (lua, &node->properties, "luaX.attr");
+}
+
+/*****************************************************************************/
+
+static int
+attr_nth (lua_State *lua)
+{
+  xmlNode *node = luaX_toattrs (lua, 1);
+  int index = lua_tointeger (lua, 2);
+  xmlAttr *attr = NULL;
+
+  if (index > 0)
+    for (attr = node->properties;
+	 attr != NULL && index > 1;
+	 attr = attr->next, index--)
+      ;
+  if (attr != NULL)
+    lua_pushstring (lua, (const char *) attr->name);
+  else
+    lua_pushnil (lua);
+  return 1;
+}
+
+static int
+attr_get (lua_State *lua)
+{
+  xmlNode *node = luaX_toattrs (lua, 1);
+  const char *prop = lua_tostring (lua, 2);
+  char *value;
+
+  value = (char *) xmlGetProp (node, (xmlChar *) prop);
+  lua_pushstring (lua, value);
+  xmlFree (value);
+  return 1;
+}
+
+static int
+attr_set (lua_State *lua)
+{
+  xmlNode *node = luaX_toattrs (lua, 1);
+  const char *prop = lua_tostring (lua, 2);
+  const char *value = lua_tostring (lua, 3);
+
+  xmlSetProp (node, (xmlChar *) prop, (xmlChar *) value);
+  return 0;
+}
+
+static const struct luaL_Reg attr_m[] =
+  {
+    { "__newindex", attr_set }, /* f(t,attr,value) */
+    { "__index", attr_get }, /* f(t,attr) */
+    { "nth", attr_nth }, /* f(t,index) */
+    { NULL, NULL }
+  };
+
+/*****************************************************************************
+	Nodes
+ *****************************************************************************/
+xmlNode *
+luaX_checknode (lua_State *lua, int index)
+{
+  return luatool_checktype (lua, index, "luaX.node");
+}
+
+xmlNode *
+luaX_tonode (lua_State *lua, int index)
+{
+  return luatool_totype (lua, index, "luaX.node");
+}
+
+int
+luaX_pushnode (lua_State *lua, xmlNode *node)
+{
+  return luatool_wrap_unique (lua, node, "luaX.node");
+}
+
+static int
+node_tostring (lua_State *lua)
+{
+  xmlNode *node = luaX_checknode (lua, 1);
+  char *str;
+
+  str = (char *) xmlNodeGetContent (node);
+  lua_pushstring (lua, str);
+  xmlFree (str);
+  return 1;
+}
+
+static int
+node_children (lua_State *lua)
+{
+  xmlNode *node = luaX_checknode (lua, 1);
+
+  return luaX_pushnode (lua, node->children);
+}
+
+static int
+node_last (lua_State *lua)
+{
+  xmlNode *node = luaX_checknode (lua, 1);
+
+  return luaX_pushnode (lua, node->last);
+}
+
+static int
+node_next (lua_State *lua)
+{
+  xmlNode *node = luaX_checknode (lua, 1);
+
+  return luaX_pushnode (lua, node->next);
+}
+
+static int
+node_prev (lua_State *lua)
+{
+  xmlNode *node = luaX_checknode (lua, 1);
+
+  return luaX_pushnode (lua, node->prev);
+}
+
+static int
+node_parent (lua_State *lua)
+{
+  xmlNode *node = luaX_checknode (lua, 1);
+
+  return luaX_pushnode (lua, node->parent);
+}
+
+struct node_iterator
+  {
+    xmlNode *node;
+  };
+
+static int
+node_iterator (lua_State *lua)
+{
+  struct node_iterator *nsi;
+  xmlNode *node;
+
+  nsi = lua_touserdata (lua, lua_upvalueindex (1));
+  node = nsi->node;
+  if (nsi->node == NULL)
+    return 0;
+  nsi->node = node->next;
+  luaX_pushnode (lua, node);
+  return 1;
+}
+
+static int
+node_list (lua_State *lua)
+{
+  xmlNode *node = luaX_checknode (lua, 1);
+  struct node_iterator *nsi;
+
+  nsi = lua_newuserdata (lua, sizeof (struct node_iterator));
+  nsi->node = node->children;
+  lua_pushcclosure (lua, node_iterator, 1);
+  return 1;
+}
+
+static int
+node_getattr (lua_State *lua)
+{
+  xmlNode *node = luaX_checknode (lua, 1);
+  const char *prop = lua_tostring (lua, 2);
+  char *value;
+
+  value = (char *) xmlGetProp (node, (xmlChar *) prop);
+  lua_pushstring (lua, value);
+  xmlFree (value);
+  return 1;
+}
+
+static int
+node_setattr (lua_State *lua)
+{
+  xmlNode *node = luaX_checknode (lua, 1);
+  const char *prop = lua_tostring (lua, 2);
+  const char *value = lua_tostring (lua, 3);
+
+  xmlSetProp (node, (xmlChar *) prop, (xmlChar *) value);
+  lua_settop (lua, 1);
+  return 1;
+}
+
+static int
+node_unsetattr (lua_State *lua)
+{
+  xmlNode *node = luaX_checknode (lua, 1);
+  const char *prop = lua_tostring (lua, 2);
+
+  xmlUnsetProp (node, (xmlChar *) prop);
+  lua_settop (lua, 1);
+  return 1;
+}
+
+static int
+node_local_name (lua_State *lua)
+{
+  xmlNode *node = luaX_checknode (lua, 1);
+
+  lua_pushstring (lua, (char *) node->name);
+  return 1;
+}
+
+static int
+node_name (lua_State *lua)
+{
+  xmlNode *node = luaX_checknode (lua, 1);
+  xmlNs *ns;
+
+  if ((ns = node->ns) == NULL)
+    lua_pushstring (lua, (char *) node->name);
+  else
+    lua_pushfstring (lua, "%s:%s", (char *) ns->prefix, (char *) node->name);
+  return 1;
+}
+
+static int
+node_prefix (lua_State *lua)
+{
+  xmlNode *node = luaX_checknode (lua, 1);
+  xmlNs *ns;
+
+  if ((ns = node->ns) == NULL)
+    lua_pushnil (lua);
+  else
+    lua_pushstring (lua, (char *) ns->prefix);
+  return 1;
+}
+
+static int
+node_namespace_uri (lua_State *lua)
+{
+  xmlNode *node = luaX_checknode (lua, 1);
+  xmlNs *ns;
+
+  if ((ns = node->ns) == NULL)
+    lua_pushnil (lua);
+  else
+    lua_pushstring (lua, (char *) ns->href);
+  return 1;
+}
+
+static int
+node_eq (lua_State *lua)
+{
+  xmlNode *lhs = luaX_checknode (lua, 1);
+  xmlNode *rhs = luaX_checknode (lua, 2);
+
+  lua_pushboolean (lua, lhs == rhs);
+  return 1;
+}
+
+static int
+node_lt (lua_State *lua)
+{
+  xmlNode *lhs = luaX_checknode (lua, 1);
+  xmlNode *rhs = luaX_checknode (lua, 2);
+
+  lua_pushboolean (lua, xmlXPathCmpNodes (lhs, rhs) > 0);
+  return 1;
+}
+
+static int
+node_le (lua_State *lua)
+{
+  xmlNode *lhs = luaX_checknode (lua, 1);
+  xmlNode *rhs = luaX_checknode (lua, 2);
+
+  lua_pushboolean (lua, xmlXPathCmpNodes (lhs, rhs) >= 0);
+  return 1;
+}
+
+static int
+node_copy (lua_State *lua)
+{
+  xmlNode *dst = luaX_checknode (lua, 1);
+  xmlNode *src = luaX_checknode (lua, 2);
+  int deep = lua_toboolean (lua, 3);
+  xmlNode *node;
+
+  node = xmlDocCopyNode (src, dst->doc, !!deep);
+  xmlAddChild (dst, node);
+  return luaX_pushnode (lua, node);
+}
+
+static int
+node_replace (lua_State *lua)
+{
+  xmlNode *dst = luaX_checknode (lua, 1);
+  xmlNode *src = luaX_checknode (lua, 2);
+  xmlNode *node;
+
+  node = xmlReplaceNode (dst, src);
+  return luaX_pushnode (lua, node);
+}
+
+static int
+node_unlink (lua_State *lua)
+{
+  xmlNode *node = luaX_checknode (lua, 1);
+
+  xmlUnlinkNode (node);
+  return 0;
+}
+
+static int
+node_new (lua_State *lua)
+{
+  xmlNode *lhs = luaX_checknode (lua, 1);
+  const char *name;
+  xmlNode *node;
+
+  name = lua_tostring (lua, 2);
+  node = xmlNewDocNode (lhs->doc, NULL, (xmlChar *) name, NULL);
+  return luaX_pushnode (lua, node);
+}
+
+static int
+node_text (lua_State *lua)
+{
+  xmlNode *lhs = luaX_checknode (lua, 1);
+  const char *text;
+  size_t len;
+  xmlNode *node;
+
+  text = lua_tolstring (lua, 2, &len);
+  node = xmlNewDocTextLen (lhs->doc, cX text, len);
+  xmlAddChild (lhs, node);
+  return luaX_pushnode (lua, node);
+}
+
+static int
+node_append_child (lua_State *lua)
+{
+  xmlNode *node = luaX_checknode (lua, 1);
+  xmlNode *child = luaX_checknode (lua, 2);
+
+  xmlAddChild (node, child);
+  lua_settop (lua, 1);
+  return 1;
+}
+
+static int
+node_root (lua_State *lua)
+{
+  xmlNode *src = luaX_checknode (lua, 1);
+
+  return luaX_pushnode (lua, xmlDocGetRootElement (src->doc));
+}
+
+static int
+node_attr (lua_State *lua)
+{
+  xmlNode *node = luaX_checknode (lua, 1);
+
+  return luaX_pushattrs (lua, node);
+}
+
+static int
+node_document (lua_State *lua)
+{
+  xmlNode *src = luaX_checknode (lua, 1);
+
+  //XXX this could leak documents not to be garbage collected
+  return luaX_pushdoc (lua, src->doc);
+}
+
+/* usage: node:parse("<tag> ...well balanced content... </tag>") */
+static int
+node_parse_chunk (lua_State *lua)
+{
+  xmlNode *ref = luaX_tonode (lua, 1);
+  const char *value = lua_tostring (lua, 2);
+  xmlNode *list = NULL;
+
+  /* value is a well balanced XML fragment */
+  if (xmlParseBalancedChunkMemory (ref->doc, NULL, NULL, 0,
+  				   cX value, &list) == 0)
+    xmlAddChildList (ref, list);
+  return 0;
+}
+
+/* usage: node:serialize(function (text) io.write (text) end) */
+static int
+node_serialize (lua_State *lua)
+{
+  xmlNode *node = luaX_tonode (lua, 1);
+  xmlSaveCtxt *ctxt;
+
+  if (!lua_isfunction (lua, 2))
+    {
+      syslog (LOG_ERR, "XML serialize: Invalid callback\n");
+      return 0;
+    }
+  ctxt = xmlSaveToIO (serialize_cb, NULL, lua, "UTF-8", XML_SAVE_FORMAT);
+  xmlSaveTree (ctxt, node);
+  xmlSaveClose (ctxt);
+  return 0;
+}
+
+static int
+node_new_attr (lua_State *lua)
+{
+  xmlNode *node = luaX_checknode (lua, 1);
+  const char *name, *value;
+
+  name = lua_tostring (lua, 2);
+  value = lua_tostring (lua, 3);
+  xmlNewProp (node, cX name, cX value);
+  return 0;
+}
+
+static int
+node_gc (lua_State *lua)
+{
+  xmlNode *node = luaX_checknode (lua, 1);
+
+  /* assume only unlinked nodes are to be collected */
+  if (node->parent == NULL && node->next == NULL && node->prev == NULL)
+    xmlFreeNode (node);
+  return 0;
+}
+
+/* methods - node:method(...) */
+static const struct luaL_Reg node_m[] =
+  {
+    { "__eq", node_eq }, /* f(lhs,rhs) */
+    { "__gc", node_gc }, /* f(t) */
+    { "__le", node_le }, /* f(lhs,rhs) */
+    { "__lt", node_lt }, /* f(lhs,rhs) */
+    { "__tostring", node_tostring }, /* f(op) */
+    { "append_child", node_append_child }, /* f(t,child,ref) */
+    { "children", node_list }, /* f(t) */
+    { "copy", node_copy }, /* f(t,node,[deep]) */
+    { "getattr", node_getattr }, /* f(t,attr) */
+    { "newattr", node_new_attr }, /* f(t,name,value) */
+    { "new", node_new }, /* f(t,name) */
+    { "nodeset", nodeset_new }, /* f(t) */
+    { "parse", node_parse_chunk }, /* f(t,string) */
+    { "replace", node_replace }, /* f(t,node) */
+    { "serialize", node_serialize }, /* f(t,func) */
+    { "setattr", node_setattr }, /* f(t,attr,value) */
+    { "text", node_text }, /* f(t,text) */
+    { "unlink", node_unlink }, /* f(t) */
+    { "unsetattr", node_unsetattr }, /* f(t,attr) */
+    { NULL, NULL }
+  };
+
+/* methods - node.prop */
+static const struct luaL_Reg node_p[] =
+  {
+    { "attr", node_attr }, /* attr */
+    { "document", node_document }, /* node */
+    { "first_child", node_children }, /* node */
+    { "last_child", node_last }, /* node */
+    { "local_name", node_local_name }, /* string */
+    { "name", node_name }, /* string */
+    { "namespace_uri", node_namespace_uri }, /* string */
+    { "next_sibling", node_next }, /* node */
+    { "parent", node_parent }, /* node */
+    { "prefix", node_prefix }, /* string */
+    { "previous_sibling", node_prev }, /* node */
+    { "root", node_root }, /* node */
+    { NULL, NULL }
+  };
+
+/*****************************************************************************/
+
+static const struct luaL_Reg xmllib_f[] =
+  {
+    { "nodeset", nodeset_new_empty }, /* nodeset = xmllib.nodelib() */
+    { NULL, NULL }
+  };
+
+int
+luaopen_xml (lua_State *lua)
+{
+  luaL_newmetatable (lua, "luaX.doc");
+  luaL_setfuncs (lua, doc_m, 0);
+  luaX_registerprop (lua, doc_p);
+  lua_pop (lua, 1);
+
+  luaL_newmetatable (lua, "luaX.node");
+  luaL_setfuncs (lua, node_m, 0);
+  luaX_registerprop (lua, node_p);
+  lua_pop (lua, 1);
+
+  luaL_newmetatable (lua, "luaX.attr");
+  luaL_setfuncs (lua, attr_m, 0);
+  lua_pop (lua, 1);
+
+  luaL_newmetatable (lua, "luaX.nodeset");
+  luaL_setfuncs (lua, nodesetlib_m, 0);
+  lua_pop (lua, 1);
+
+  lua_newtable (lua);
+  luaL_setfuncs (lua, xmllib_f, 0);
+  return 1;
+}
diff --git a/script/lua-xml.h b/script/lua-xml.h
new file mode 100644
index 0000000..560118e
--- /dev/null
+++ b/script/lua-xml.h
@@ -0,0 +1,24 @@
+#ifndef _luaxml_h
+#define _luaxml_h
+
+#ifdef NOLIBXML
+#define xmlNode void
+#define xmlNodeSet void
+#endif
+
+int luaopen_xml (lua_State *lua);
+void doc_mark_gc (xmlDoc *doc);
+int luaX_pushdoc (lua_State *lua, xmlDoc *doc);
+xmlDoc *luaX_checkdoc (lua_State *lua, int index);
+xmlDoc *luaX_todoc (lua_State *lua, int index);
+int luaX_pushnode (lua_State *lua, xmlNode *node);
+xmlNode *luaX_checknode (lua_State *lua, int index);
+xmlNode *luaX_tonode (lua_State *lua, int index);
+xmlNode *luaX_toattrs (lua_State *lua, int index);
+int luaX_pushattrs (lua_State *lua, xmlNode *node);
+
+int luaX_pushnodeset (lua_State *lua, struct _xmlNodeSet *nodeset);
+struct _xmlNodeSet *luaX_tonodeset (lua_State *lua, int index);
+struct _xmlNodeSet *luaX_checknodeset (lua_State *lua, int index);
+
+#endif
diff --git a/script/luatools.c b/script/luatools.c
new file mode 100644
index 0000000..e9246f6
--- /dev/null
+++ b/script/luatools.c
@@ -0,0 +1,124 @@
+#include <assert.h>
+#include <syslog.h>
+#include <stdlib.h>
+#include <string.h>
+#include <pthread.h>
+
+#include <lua.h>
+#include <lualib.h>
+#include <lauxlib.h>
+
+#include "luatools.h"
+
+/*****************************************************************************
+ * Pointer wrapping
+ *****************************************************************************/
+struct wrap
+  {
+    void *ptr;
+  };
+
+int
+luatool_wrap_unique (lua_State *lua, void *ptr, const char *type)
+{
+  struct wrap *wrap;
+
+  if (ptr == NULL)
+    {
+      lua_pushnil (lua);
+      return 1;
+    }
+
+  lua_getfield (lua, LUA_REGISTRYINDEX, "luaX.wrappers");
+  if (lua_isnil (lua, -1))
+    {
+      lua_pop (lua, 1);
+      lua_newtable (lua);
+      lua_pushstring (lua, "kv");
+      lua_setfield (lua, -2, "__mode");
+      lua_pushvalue (lua, -1);
+      lua_setfield (lua, LUA_REGISTRYINDEX, "luaX.wrappers");
+    }
+
+  lua_pushlightuserdata (lua, ptr);
+  lua_gettable (lua, -2);
+  if (!lua_isnil (lua, -1))
+    {
+      wrap = luatool_checkudata (lua, -1, type);
+      assert (wrap->ptr == ptr);
+    }
+  else
+    {
+      /* pop nil */
+      lua_pop (lua, 1);
+
+      /* wrap pointer */
+      wrap = lua_newuserdata (lua, sizeof (struct wrap));
+      wrap->ptr = ptr;
+      luaL_newmetatable (lua, type);
+      lua_setmetatable (lua, -2);
+
+      /* duplicate wrapper at TOS and store in wrappers table */
+      lua_pushlightuserdata (lua, ptr);
+      lua_pushvalue (lua, -2);
+      lua_settable (lua, -4);
+    }
+  /* delete wrappers table from stack leaving wrapped pointer at TOS */
+  lua_replace (lua, -2);
+  return 1;
+}
+
+int
+luatool_wrap (lua_State *lua, void *ptr, const char *type)
+{
+  struct wrap *wrap;
+
+  if (ptr == NULL)
+    {
+      lua_pushnil (lua);
+      return 1;
+    }
+
+  /* wrap pointer */
+  wrap = lua_newuserdata (lua, sizeof (struct wrap));
+  wrap->ptr = ptr;
+  luaL_getmetatable (lua, type);
+  lua_setmetatable (lua, -2);
+  return 1;
+}
+
+void *
+luatool_checktype (lua_State *lua, int index, const char *type)
+{
+  struct wrap *wrap;
+
+  wrap = luaL_checkudata (lua, index, type);
+  luaL_argcheck (lua, wrap->ptr != NULL, index, NULL);
+  return wrap->ptr;
+}
+
+void *
+luatool_totype (lua_State *lua, int index, const char *type)
+{
+  struct wrap *wrap;
+
+  wrap = luatool_checkudata (lua, index, type);
+  return wrap != NULL ? wrap->ptr : NULL;
+}
+
+void *
+luatool_checkudata (lua_State *lua, int index, const char *type)
+{
+  void *udata = lua_touserdata (lua, index);
+  int eq;
+
+  if (udata != NULL && lua_getmetatable (lua, index))
+    {
+      luaL_getmetatable (lua, type);
+      eq = lua_rawequal (lua, -1, -2);
+      lua_pop (lua, 2);
+      return eq ? udata : NULL;
+    }
+  return NULL;
+}
+
diff --git a/script/luatools.h b/script/luatools.h
new file mode 100644
index 0000000..30832d6
--- /dev/null
+++ b/script/luatools.h
@@ -0,0 +1,14 @@
+#ifndef _luatools_h
+#define _luatools_h
+
+void luatool_require (lua_State *lua, const char *module);
+
+#define luatool_wrap_pointer(l,p,t) luatool_wrap_unique((l),(p),(t))
+int luatool_wrap_unique (lua_State *lua, void *ptr, const char *type);
+int luatool_wrap (lua_State *lua, void *ptr, const char *type);
+void *luatool_checktype (lua_State *lua, int index, const char *type);
+void *luatool_totype (lua_State *lua, int index, const char *type);
+
+void *luatool_checkudata (lua_State *lua, int index, const char *type);
+
+#endif
diff --git a/script/meson.build b/script/meson.build
new file mode 100644
index 0000000..eb43f96
--- /dev/null
+++ b/script/meson.build
@@ -0,0 +1,21 @@
+# build the script extension from exslt.org/functions
+
+script_source = [
+    'exslt-script.c',
+    'exslt-script.h',
+    'exslt-script-lua.c',
+    'luatools.c',
+    'luatools.h',
+    'lua-xml.c',
+    'lua-xml.h',
+    'script.h',
+]
+
+luadep = dependency('lua5.3', required : false)
+if luadep.found()
+    shared_module('functions', script_source,
+		  name_prefix : prefix_exslt,
+		  dependencies : [xsldep, luadep],
+		  install_dir: plugin_dir,
+		  install : true)
+endif
diff --git a/script/script.h b/script/script.h
new file mode 100644
index 0000000..147058f
--- /dev/null
+++ b/script/script.h
@@ -0,0 +1,27 @@
+#ifndef _script_h
+#define _script_h
+
+typedef struct script script_t;
+typedef struct implementation implementation_t;
+typedef const char *(*readcb_t) (void *, void *, size_t *);
+
+struct script
+  {
+    struct implementation *implementation;
+    void *state;
+  };
+
+struct implementation
+  {
+    struct script *(*init) (const struct implementation *);
+    void (*compile) (const struct script *, const char *uri,
+		     readcb_t reader, void *arg);
+    int (*call) (const struct script *, const char *uri, const char *function,
+		 xmlXPathParserContext *ctxt, int nargs);
+    void (*destroy) (const struct script *);
+  };
+
+const implementation_t *script_lookup_language (const char *language);
+void script_register_hook (const char *name, const char *uri);
+
+#endif