@jinntec/fore 0.25.0 → 1.0.0-2

package/src/xpath-evaluation.js

@@ -1,17 +1,512 @@
 import {
   evaluateXPath as fxEvaluateXPath,
+  evaluateXPathToBoolean as fxEvaluateXPathToBoolean,
   evaluateXPathToFirstNode as fxEvaluateXPathToFirstNode,
   evaluateXPathToNodes as fxEvaluateXPathToNodes,
-  evaluateXPathToBoolean as fxEvaluateXPathToBoolean,
-  evaluateXPathToString as fxEvaluateXPathToString,
   evaluateXPathToNumber as fxEvaluateXPathToNumber,
+  evaluateXPathToString as fxEvaluateXPathToString,
+  evaluateXPathToStrings as fxEvaluateXPathToStrings,
+  parseScript,
   registerCustomXPathFunction,
   registerXQueryModule,
 } from 'fontoxpath';
-import getInScopeContext from './getInScopeContext.js';
+import { XPathUtil } from './xpath-util.js';
 
 const XFORMS_NAMESPACE_URI = 'http://www.w3.org/2002/xforms';
 
+const createdNamespaceResolversByXPathQueryAndNode = new Map();
+
+function prettifyXml(source) {
+  const xmlDoc = new DOMParser().parseFromString(source, 'application/xml');
+  const xsltDoc = new DOMParser().parseFromString(
+    [
+      // describes how we want to modify the XML - indent everything
+      '<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform">',
+      '  <xsl:strip-space elements="*"/>',
+      '  <xsl:template match="para[content-style][not(text())]">', // change to just text() to strip space in text nodes
+      '    <xsl:value-of select="normalize-space(.)"/>',
+      '  </xsl:template>',
+      '  <xsl:template match="node()|@*">',
+      '    <xsl:copy><xsl:apply-templates select="node()|@*"/></xsl:copy>',
+      '  </xsl:template>',
+      '  <xsl:output indent="yes"/>',
+      '</xsl:stylesheet>',
+    ].join('\n'),
+    'application/xml',
+  );
+
+  const xsltProcessor = new XSLTProcessor();
+  xsltProcessor.importStylesheet(xsltDoc);
+  const resultDoc = xsltProcessor.transformToDocument(xmlDoc);
+  const resultXml = new XMLSerializer().serializeToString(resultDoc);
+  return resultXml;
+}
+
+function getCachedNamespaceResolver(xpath, node) {
+  if (!createdNamespaceResolversByXPathQueryAndNode.has(xpath)) {
+    return null;
+  }
+  return createdNamespaceResolversByXPathQueryAndNode.get(xpath).get(node) || null;
+}
+function setCachedNamespaceResolver(xpath, node, resolver) {
+  if (!createdNamespaceResolversByXPathQueryAndNode.has(xpath)) {
+    return createdNamespaceResolversByXPathQueryAndNode.set(xpath, new Map());
+  }
+  return createdNamespaceResolversByXPathQueryAndNode.get(xpath).set(node, resolver);
+}
+
+const xhtmlNamespaceResolver = prefix => {
+  if (!prefix) {
+    return 'http://www.w3.org/1999/xhtml';
+  }
+  return undefined;
+};
+
+/**
+ * Resolve a namespace. Needs a namespace prefix and the element that is most closely related to the
+ * XPath in which the namespace is being resolved. The prefix will be resolved by using the
+ * ancestry of said element.
+ *
+ * It has two ways of doing so:
+ *
+ * - If the prefix is defined in an `xmlns:XXX="YYY"` namespace declaration, it will return 'YYY'.
+ * - If the prefix is the empty prefix and there is an `xpath-default-namespace="YYY"` attribute in the
+ * - ancestry, that attribute will be used and 'YYY' will be returned
+ *
+ * @param  {Node}  contextElement  The element that is most closely related with the XPath in which this prefix is resolved.
+ * @param  {string}   prefix          The prefix to resolve
+ */
+function createNamespaceResolver(xpathQuery, formElement) {
+  const cachedResolver = getCachedNamespaceResolver(xpathQuery, formElement);
+  if (cachedResolver) {
+    return cachedResolver;
+  }
+
+  // Make namespace resolving use the `instance` element that is related to here
+  const xmlDocument = new DOMParser().parseFromString('<xml />', 'text/xml');
+
+  const xpathAST = parseScript(xpathQuery, {}, xmlDocument);
+  let instanceReferences = fxEvaluateXPathToStrings(
+    `descendant::xqx:functionCallExpr
+				[xqx:functionName = "instance"]
+				/xqx:arguments
+				/xqx:stringConstantExpr
+				/xqx:value`,
+    xpathAST,
+    null,
+    {},
+    {
+      namespaceResolver: prefix =>
+        prefix === 'xqx' ? 'http://www.w3.org/2005/XQueryX' : undefined,
+    },
+  );
+  if (instanceReferences.length === 0) {
+    // No instance functions. Look up further in the hierarchy to see if we can deduce the intended context from there
+    const ancestorComponent = fxEvaluateXPathToFirstNode('ancestor::*[@ref][1]', formElement);
+    if (ancestorComponent) {
+      const resolver = createNamespaceResolver(
+        ancestorComponent.getAttribute('ref'),
+        ancestorComponent,
+      );
+      setCachedNamespaceResolver(xpathQuery, formElement, resolver);
+      return resolver;
+    }
+    // Nothing found: let's just assume we're supposed to use the `default` instance
+    instanceReferences = ['default'];
+  }
+
+  if (instanceReferences.length === 1) {
+    // console.log(`resolving ${xpathQuery} with ${instanceReferences[0]}`);
+    let instance;
+    if (instanceReferences[0] === 'default') {
+      const actualForeElement = fxEvaluateXPathToFirstNode(
+        'ancestor-or-self::fx-fore',
+        formElement,
+        null,
+        null,
+        { namespaceResolver: xhtmlNamespaceResolver },
+      );
+
+      instance = actualForeElement && actualForeElement.querySelector('fx-instance');
+    } else {
+      instance = resolveId(instanceReferences[0], formElement, 'fx-instance');
+    }
+    if (instance && instance.hasAttribute('xpath-default-namespace')) {
+      const xpathDefaultNamespace = instance.getAttribute('xpath-default-namespace');
+      /*
+      console.log(
+        `Resolving the xpath ${xpathQuery} with the default namespace set to ${xpathDefaultNamespace}`,
+      );
+*/
+      const resolveNamespacePrefix = prefix => {
+        if (!prefix) {
+          return xpathDefaultNamespace;
+        }
+        return undefined;
+      };
+      setCachedNamespaceResolver(xpathQuery, formElement, resolveNamespacePrefix);
+      return resolveNamespacePrefix;
+    }
+  }
+  if (instanceReferences.length > 1) {
+    console.warn(
+      `More than one instance is used in the query "${xpathQuery}". The default namespace resolving will be used`,
+    );
+  }
+
+  const xpathDefaultNamespace =
+    fxEvaluateXPathToString('ancestor-or-self::*/@xpath-default-namespace[last()]', formElement) ||
+    '';
+
+  const resolveNamespacePrefix = function resolveNamespacePrefix(prefix) {
+    if (prefix === '') {
+      return xpathDefaultNamespace;
+    }
+
+    // Note: ideally we should use Node#lookupNamespaceURI. However, the nodes we are passed are
+    // XML. The best we can do is emulate the `xmlns:xxx` namespace declarations by regarding them as
+    // attributes. Which they technically ARE NOT!
+
+    return fxEvaluateXPathToString(
+      'ancestor-or-self::*/@*[name() = "xmlns:" || $prefix][last()]',
+      formElement,
+      null,
+      { prefix },
+    );
+  };
+
+  setCachedNamespaceResolver(xpathQuery, formElement, resolveNamespacePrefix);
+  return resolveNamespacePrefix;
+}
+
+function createNamespaceResolverForNode(query, contextNode, formElement) {
+  if (((contextNode && contextNode.ownerDocument) || contextNode) === window.document) {
+    // Running a query on the HTML DOM. Don't bother resolving namespaces in any other way
+    return xhtmlNamespaceResolver;
+  }
+  return createNamespaceResolver(query, formElement);
+}
+
+/**
+ * Implementation of the functionNameResolver passed to FontoXPath to
+ * redirect function resolving for unprefixed functions to either the fn or the xf namespace
+ */
+// eslint-disable-next-line no-unused-vars
+function functionNameResolver({ prefix, localName }, _arity) {
+  switch (localName) {
+    // TODO: put the full XForms library functions set here
+    case 'context':
+    case 'base64encode':
+    case 'boolean-from-string':
+    case 'current':
+    case 'depends':
+    case 'event':
+    case 'index':
+    case 'instance':
+    case 'log':
+    case 'logtree':
+      return { namespaceURI: XFORMS_NAMESPACE_URI, localName };
+    default:
+      if (prefix === '' || prefix === 'fn') {
+        return { namespaceURI: 'http://www.w3.org/2005/xpath-functions', localName };
+      }
+      if (prefix === 'local') {
+        return { namespaceURI: 'http://www.w3.org/2005/xquery-local-functions', localName };
+      }
+      return null;
+  }
+}
+
+/**
+ * Evaluate an XPath to _any_ type. When possible, prefer to use any other function to ensure the
+ * type of the output is more predictable.
+ *
+ * @param  {string} xpath  The XPath to run
+ * @param  {Node} contextNode The start of the XPath
+ * @param  {{parentNode}|ForeElementMixin} formElement  The form element associated to the XPath
+ */
+export function evaluateXPath(xpath, contextNode, formElement, variables = {}) {
+  const namespaceResolver = createNamespaceResolverForNode(xpath, contextNode, formElement);
+
+  return fxEvaluateXPath(xpath, contextNode, null, variables, 'xs:anyType', {
+    currentContext: { formElement, variables },
+    moduleImports: {
+      xf: XFORMS_NAMESPACE_URI,
+    },
+    functionNameResolver,
+    namespaceResolver,
+  });
+}
+
+/**
+ * Evaluate an XPath to the first Node
+ *
+ * @param  {string} xpath  The XPath to run
+ * @param  {Node} contextNode The start of the XPath
+ * @param  {Node} formElement  The form element associated to the XPath
+ * @return {Node}  The first node found by the XPath
+ */
+export function evaluateXPathToFirstNode(xpath, contextNode, formElement) {
+  const namespaceResolver = createNamespaceResolverForNode(xpath, contextNode, formElement);
+  return fxEvaluateXPathToFirstNode(
+    xpath,
+    contextNode,
+    null,
+    {},
+    {
+      defaultFunctionNamespaceURI: XFORMS_NAMESPACE_URI,
+      moduleImports: {
+        xf: XFORMS_NAMESPACE_URI,
+      },
+      currentContext: { formElement },
+      namespaceResolver,
+    },
+  );
+}
+
+/**
+ * Evaluate an XPath to all nodes
+ *
+ * @param  {string} xpath  The XPath to run
+ * @param  {Node} contextNode The start of the XPath
+ * @param  {Node} formElement  The form element associated to the XPath
+ * @return {Node[]}  All nodes
+ */
+export function evaluateXPathToNodes(xpath, contextNode, formElement) {
+  const namespaceResolver = createNamespaceResolverForNode(xpath, contextNode, formElement);
+  return fxEvaluateXPathToNodes(
+    xpath,
+    contextNode,
+    null,
+    {},
+    {
+      currentContext: { formElement },
+      functionNameResolver,
+      moduleImports: {
+        xf: XFORMS_NAMESPACE_URI,
+      },
+      namespaceResolver,
+    },
+  );
+}
+
+/**
+ * Evaluate an XPath to a boolean
+ *
+ * @param  {string} xpath  The XPath to run
+ * @param  {Node} contextNode The start of the XPath
+ * @param  {Node} formElement  The form element associated to the XPath
+ * @return {boolean}
+ */
+export function evaluateXPathToBoolean(xpath, contextNode, formElement) {
+  const namespaceResolver = createNamespaceResolverForNode(xpath, contextNode, formElement);
+  return fxEvaluateXPathToBoolean(
+    xpath,
+    contextNode,
+    null,
+    {},
+    {
+      currentContext: { formElement },
+      functionNameResolver,
+      moduleImports: {
+        xf: XFORMS_NAMESPACE_URI,
+      },
+      namespaceResolver,
+    },
+  );
+}
+
+/**
+ * Evaluate an XPath to a string
+ *
+ * @param  {string}     xpath             The XPath to run
+ * @param  {Node}       contextNode       The start of the XPath
+ * @param  {Node}       formElement       The form element associated to the XPath
+ * @param  {DomFacade}  [domFacade=null]  A DomFacade is used in bindings to intercept DOM
+ * access. This is used to determine dependencies between bind elements.
+ * @param  {Node}       formElement       The element where the XPath is defined: used for namespace resolving
+ * @return {string}
+ */
+export function evaluateXPathToString(
+  xpath,
+  contextNode,
+  formElement,
+  domFacade = null,
+  namespaceReferenceNode = formElement,
+) {
+  const namespaceResolver = createNamespaceResolverForNode(xpath, contextNode, formElement);
+  return fxEvaluateXPathToString(
+    xpath,
+    contextNode,
+    domFacade,
+    {},
+
+    {
+      currentContext: { formElement },
+      functionNameResolver,
+      moduleImports: {
+        xf: XFORMS_NAMESPACE_URI,
+      },
+      namespaceResolver,
+    },
+  );
+}
+
+/**
+ * Evaluate an XPath to a number
+ *
+ * @param  {string}     xpath             The XPath to run
+ * @param  {Node}       contextNode       The start of the XPath
+ * @param  {Node}       formElement       The form element associated to the XPath
+ * @param  {DomFacade}  [domFacade=null]  A DomFacade is used in bindings to intercept DOM
+ * @param  {Node}       formElement       The element where the XPath is defined: used for namespace resolving
+ * access. This is used to determine dependencies between bind elements.
+ * @return {Number}
+ */
+export function evaluateXPathToNumber(
+  xpath,
+  contextNode,
+  formElement,
+  domFacade = null,
+  namespaceReferenceNode = formElement,
+) {
+  const namespaceResolver = createNamespaceResolverForNode(xpath, contextNode, formElement);
+  return fxEvaluateXPathToNumber(
+    xpath,
+    contextNode,
+    domFacade,
+    {},
+    {
+      currentContext: { formElement },
+      functionNameResolver,
+      moduleImports: {
+        xf: XFORMS_NAMESPACE_URI,
+      },
+      namespaceResolver,
+    },
+  );
+}
+
+/**
+ * Resolve an id in scope. Behaves like the algorithm defined on https://www.w3.org/community/xformsusers/wiki/XForms_2.0#idref-resolve
+ */
+export function resolveId(id, sourceObject, nodeName = null) {
+  const allMatchingTargetObjects = fxEvaluateXPathToNodes(
+    'outermost(ancestor-or-self::fx-fore[1]/(descendant::xf-fore|descendant::*[@id = $id]))[not(self::fx-fore)]',
+    sourceObject,
+    null,
+    { id },
+    { namespaceResolver: xhtmlNamespaceResolver },
+  );
+
+  if (allMatchingTargetObjects.length === 0) {
+    return null;
+  }
+
+  if (
+    allMatchingTargetObjects.length === 1 &&
+    fxEvaluateXPathToBoolean(
+      '(ancestor::fx-fore | ancestor::fx-repeat)[last()]/self::fx-fore',
+      allMatchingTargetObjects[0],
+      null,
+      null,
+      { namespaceResolver: xhtmlNamespaceResolver },
+    )
+  ) {
+    // If the target element is not repeated, then the search for the target object is trivial since
+    // there is only one associated with the target element that bears the matching ID. This is true
+    // regardless of whether or not the source object is repeated. However, if the target element is
+    // repeated, then additional information must be used to help select a target object from among
+    // those associated with the identified target element.
+    const targetObject = allMatchingTargetObjects[0];
+    if (nodeName && targetObject.localName !== nodeName) {
+      return null;
+    }
+    return targetObject;
+  }
+
+  // SPEC:
+
+  // 12.2.1 References to Elements within a repeat Element
+
+  // When the target element that is identified by the IDREF of a source object has one or more
+  // repeat elements as ancestors, then the set of ancestor repeats are partitioned into two
+  // subsets, those in common with the source element and those that are not in common. Any ancestor
+  // repeat elements of the target element not in common with the source element are descendants of
+  // the repeat elements that the source and target element have in common, if any.
+
+  // For the repeat elements that are in common, the desired target object exists in the same set of
+  // run-time objects that contains the source object. Then, for each ancestor repeat of the target
+  // element that is not in common with the source element, the current index of the repeat
+  // determines the set of run-time objects that contains the desired target object.
+  for (const ancestorRepeatItem of fxEvaluateXPathToNodes(
+    'ancestor::fx-repeatitem => reverse()',
+    sourceObject,
+    null,
+    null,
+    { namespaceResolver: xhtmlNamespaceResolver },
+  )) {
+    const foundTargetObjects = allMatchingTargetObjects.filter(to =>
+      ancestorRepeatItem.contains(to),
+    );
+    switch (foundTargetObjects.length) {
+      case 0:
+        // Nothing found: ignore
+        break;
+      case 1: {
+        // A single one is found: the target object is directly in a common repeat
+        const targetObject = foundTargetObjects[0];
+        if (nodeName && targetObject.localName !== nodeName) {
+          return null;
+        }
+        return targetObject;
+      }
+      default: {
+        // Multiple target objects are found: they are in a repeat that is not common with the source object
+        // We found a target object in a common repeat! We now need to find the one that is in the repeatitem identified at the current index
+        const targetObject = foundTargetObjects.find(to =>
+          fxEvaluateXPathToNodes(
+            'every $ancestor of ancestor::fx-repeatitem satisfies $ancestor is $ancestor/../child::fx-repeatitem[../@repeat-index]',
+            to,
+            null,
+            {},
+          ),
+        );
+        if (!targetObject) {
+          // Nothing valid found for whatever reason. This might be something dynamic?
+          return null;
+        }
+        if (nodeName && targetObject.localName !== nodeName) {
+          return null;
+        }
+        return targetObject;
+      }
+    }
+  }
+  // We found no target objects in common repeats. The id is unresolvable
+  return null;
+}
+
+/**
+ * @param id as string
+ * @return instance data for given id serialized to string.
+ */
+registerCustomXPathFunction(
+  { namespaceURI: XFORMS_NAMESPACE_URI, localName: 'context' },
+  [],
+  'item()?',
+  (dynamicContext, string) => {
+    const caller = dynamicContext.currentContext.formElement;
+    const parent = XPathUtil.getParentBindingElement(caller);
+    // const instance = resolveId('default', caller, 'fx-instance');
+    const p = caller.nodeName;
+    // const p = dynamicContext.domFacade.getParentElement();
+
+    if (parent) return parent;
+    return caller.getInScopeContext();
+  },
+);
+
 /**
  * @param id as string
  * @return instance data for given id serialized to string.
@@ -22,10 +517,15 @@ registerCustomXPathFunction(
   'xs:string?',
   (dynamicContext, string) => {
     const { formElement } = dynamicContext.currentContext;
-    const instance = formElement.querySelector(`fx-instance[id=${string}]`);
+    const instance = resolveId(string, formElement, 'fx-instance');
     if (instance) {
-      const def = new XMLSerializer().serializeToString(instance.getDefaultContext());
-      return def;
+      if (instance.getAttribute('type') === 'json') {
+        console.warn('log() does not work for JSON yet');
+        // return JSON.stringify(instance.getDefaultContext());
+      } else {
+        const def = new XMLSerializer().serializeToString(instance.getDefaultContext());
+        return prettifyXml(def);
+      }
     }
     return null;
   },
@@ -93,13 +593,14 @@ registerCustomXPathFunction(
   'element()?',
   (dynamicContext, string) => {
     const { formElement } = dynamicContext.currentContext;
-    const instance = formElement.querySelector(`fx-instance[id=${string}]`);
+    const instance = resolveId(string, formElement, 'fx-instance');
+
     if (instance) {
       // const def = new XMLSerializer().serializeToString(instance.getDefaultContext());
       // const def = JSON.stringify(instance.getDefaultContext());
 
-      const tree = document.createElement('div');
-      tree.setAttribute('class', 'logtree');
+      const treeDiv = document.createElement('div');
+      treeDiv.setAttribute('class', 'logtree');
       // const datatree = buildTree(tree,instance.getDefaultContext());
       // return tree.appendChild(datatree);
       // return  buildTree(root,instance.getDefaultContext());;
@@ -108,7 +609,10 @@ registerCustomXPathFunction(
       if (logtree) {
         logtree.parentNode.removeChild(logtree);
       }
-      form.appendChild(buildTree(tree, instance.getDefaultContext()));
+      const tree = buildTree(treeDiv, instance.getDefaultContext());
+      if (tree) {
+        form.appendChild(tree);
+      }
     }
     return null;
   },
@@ -118,13 +622,19 @@ const instance = (dynamicContext, string) => {
   // Spec: https://www.w3.org/TR/xforms-xpath/#The_XForms_Function_Library#The_instance.28.29_Function
   // TODO: handle no string passed (null will be passed instead)
 
-  const { formElement } = dynamicContext.currentContext;
+  const formElement = fxEvaluateXPathToFirstNode(
+    'ancestor-or-self::fx-fore',
+    dynamicContext.currentContext.formElement,
+    null,
+    null,
+    { namespaceResolver: xhtmlNamespaceResolver },
+  );
 
   // console.log('fnInstance dynamicContext: ', dynamicContext);
   // console.log('fnInstance string: ', string);
 
   const inst = string
-    ? formElement.querySelector(`fx-instance[id=${string}]`)
+    ? resolveId(string, formElement, 'fx-instance')
     : formElement.querySelector(`fx-instance`);
 
   // const def = instance.getInstanceData();
@@ -143,7 +653,10 @@ registerCustomXPathFunction(
   'xs:integer?',
   (dynamicContext, string) => {
     const { formElement } = dynamicContext.currentContext;
-    const repeat = string ? formElement.querySelector(`fx-repeat[id=${string}]`) : null;
+    if (string === null) {
+      return 1;
+    }
+    const repeat = resolveId(string, formElement, 'fx-repeat');
 
     // const def = instance.getInstanceData();
     if (repeat) {
@@ -225,227 +738,12 @@ executePendingUpdateList(pendingUpdatesAndXdmValue.pendingUpdateList, null, null
 */
 
 /**
- * Implementation of the functionNameResolver passed to FontoXPath to
- * redirect function resolving for unprefixed functions to either the fn or the xf namespace
- */
-// eslint-disable-next-line no-unused-vars
-function functionNameResolver({ prefix, localName }, _arity) {
-  switch (localName) {
-    // TODO: put the full XForms library functions set here
-    case 'boolean-from-string':
-    case 'depends':
-    case 'event':
-    case 'index':
-    case 'instance':
-    case 'log':
-    case 'logtree':
-      return { namespaceURI: XFORMS_NAMESPACE_URI, localName };
-    default:
-      if (prefix === '' || prefix === 'fn') {
-        return { namespaceURI: 'http://www.w3.org/2005/xpath-functions', localName };
-      }
-      if (prefix === 'local') {
-        return { namespaceURI: 'http://www.w3.org/2005/xquery-local-functions', localName };
-      }
-      return null;
-  }
-}
-
-function namespaceResolver(prefix) {
-  // TODO: Do proper namespace resolving. Look at the ancestry / namespacesInScope of the declaration
-
-  /**
-   * for (let ancestor = this; ancestor; ancestor = ancestor.parentNode) {
-   * 	if (ancestor.getAttribute(`xmlns:${prefix}`)) {
-   *   // Return value
-   *  }
-   * }
-   */
-
-  // console.log('namespaceResolver  prefix', prefix);
-  const ns = {
-    xhtml: 'http://www.w3.org/1999/xhtml',
-    tei: 'http://www.tei-c.org/ns/1.0',
-    // ''    : Fore.XFORMS_NAMESPACE_URI
-  };
-  return ns[prefix] || null;
-}
-
-/**
- * Evaluate an XPath to _any_ type. When possible, prefer to use any other function to ensure the
- * type of the output is more predictable.
- *
- * @param  {string} xpath  The XPath to run
- * @param  {Node} contextNode The start of the XPath
- * @param  {Node} formElement  The form element associated to the XPath
- */
-export function evaluateXPath(xpath, contextNode, formElement, variables = {}) {
-  return fxEvaluateXPath(xpath, contextNode, null, variables, 'xs:anyType', {
-    currentContext: { formElement, variables },
-    moduleImports: {
-      xf: XFORMS_NAMESPACE_URI,
-    },
-    functionNameResolver,
-    namespaceResolver,
-  });
-}
-
-/**
- * Evaluate an XPath to the first Node
- *
- * @param  {string} xpath  The XPath to run
- * @param  {Node} contextNode The start of the XPath
- * @param  {Node} formElement  The form element associated to the XPath
- * @return {Node}  The first node found by the XPath
- */
-export function evaluateXPathToFirstNode(xpath, contextNode, formElement) {
-  return fxEvaluateXPathToFirstNode(
-    xpath,
-    contextNode,
-    null,
-    {},
-    {
-      namespaceResolver,
-      defaultFunctionNamespaceURI: XFORMS_NAMESPACE_URI,
-      moduleImports: {
-        xf: XFORMS_NAMESPACE_URI,
-      },
-      currentContext: { formElement },
-    },
-  );
-}
-
-/**
- * Evaluate an XPath to all nodes
- *
- * @param  {string} xpath  The XPath to run
- * @param  {Node} contextNode The start of the XPath
- * @param  {Node} formElement  The form element associated to the XPath
- * @return {Node[]}  All nodes
- */
-export function evaluateXPathToNodes(xpath, contextNode, formElement) {
-  return fxEvaluateXPathToNodes(
-    xpath,
-    contextNode,
-    null,
-    {},
-    {
-      currentContext: { formElement },
-      functionNameResolver,
-      moduleImports: {
-        xf: XFORMS_NAMESPACE_URI,
-      },
-      namespaceResolver,
-    },
-  );
-}
-
-/**
- * Evaluate an XPath to a boolean
- *
- * @param  {string} xpath  The XPath to run
- * @param  {Node} contextNode The start of the XPath
- * @param  {Node} formElement  The form element associated to the XPath
- * @return {boolean}
- */
-export function evaluateXPathToBoolean(xpath, contextNode, formElement) {
-  return fxEvaluateXPathToBoolean(
-    xpath,
-    contextNode,
-    null,
-    {},
-    {
-      currentContext: { formElement },
-      functionNameResolver,
-      moduleImports: {
-        xf: XFORMS_NAMESPACE_URI,
-      },
-      namespaceResolver,
-    },
-  );
-}
-
-/**
- * Evaluate an XPath to a string
- *
- * @param  {string}     xpath             The XPath to run
- * @param  {Node}       contextNode       The start of the XPath
- * @param  {Node}       formElement       The form element associated to the XPath
- * @param  {DomFacade}  [domFacade=null]  A DomFacade is used in bindings to intercept DOM
- * access. This is used to determine dependencies between bind elements.
+ * @param input as string
  * @return {string}
  */
-export function evaluateXPathToString(xpath, contextNode, formElement, domFacade = null) {
-  return fxEvaluateXPathToString(
-    xpath,
-    contextNode,
-    domFacade,
-    {},
-
-    {
-      currentContext: { formElement },
-      functionNameResolver,
-      moduleImports: {
-        xf: XFORMS_NAMESPACE_URI,
-      },
-      namespaceResolver,
-    },
-  );
-}
-/**
- * Evaluate an XPath to a number
- *
- * @param  {string}     xpath             The XPath to run
- * @param  {Node}       contextNode       The start of the XPath
- * @param  {Node}       formElement       The form element associated to the XPath
- * @param  {DomFacade}  [domFacade=null]  A DomFacade is used in bindings to intercept DOM
- * access. This is used to determine dependencies between bind elements.
- * @return {string}
- */
-export function evaluateXPathToNumber(xpath, contextNode, formElement, domFacade = null) {
-  return fxEvaluateXPathToNumber(
-    xpath,
-    contextNode,
-    domFacade,
-    {},
-
-    {
-      currentContext: { formElement },
-      functionNameResolver,
-      moduleImports: {
-        xf: XFORMS_NAMESPACE_URI,
-      },
-      namespaceResolver,
-    },
-  );
-}
-/**
- * evaluate a template expression (some expression in {} brackets) on a node (either text- or attribute node.
- * @param expr the XPath to evaluate
- * @param node the node which will get updated with evaluation result
- * @param form the form element
- */
-export function evaluateTemplateExpression(expr, node, form) {
-  const matches = expr.match(/{[^}]*}/g);
-  if (matches) {
-    matches.forEach(match => {
-      console.log('match ', match);
-      const naked = match.substring(1, match.length - 1);
-      const inscope = getInScopeContext(node, naked);
-      const result = evaluateXPathToString(naked, inscope, form);
-
-      // console.log('result of eval ', result);
-      const replaced = expr.replaceAll(match, result);
-      console.log('result of replacing ', replaced);
-
-      if (node.nodeType === Node.ATTRIBUTE_NODE) {
-        const parent = node.ownerElement;
-
-        // parent.setAttribute(name, replaced);
-        parent.setAttribute(node.nodeName, replaced);
-      } else if (node.nodeType === Node.TEXT_NODE) {
-        node.textContent = replaced;
-      }
-    });
-  }
-}
+registerCustomXPathFunction(
+  { namespaceURI: XFORMS_NAMESPACE_URI, localName: 'base64encode' },
+  ['xs:string?'],
+  'xs:string?',
+  (dynamicContext, string) => btoa(string),
+);