jtlt 0.13.0 → 0.15.0

package/src/JSONPathTransformerContext.js

@@ -1,5 +1,10 @@
 import {JSONPath as jsonpath} from 'jsonpath-plus';
 import JSONPathTransformer from './JSONPathTransformer.js';
+import {maybeAsyncLoop} from './maybeAsync.js';
+import applyExtensions from './extendContext.js';
+import {
+  parseIndexedDBExpression, queryIndexedDB, resolveIndexedDBQuery
+} from './indexedDB.js';
 
 /**
  * @param {string} string
@@ -52,7 +57,7 @@ const escapeRegexReplacement = (string) => {
  *   ctx: JSONPathTransformerContext
  * ) => number} SortComparator
  * @typedef {string | SortObject | SortComparator |
- *   Array<string|SortObject>} SortSpec
+ *   Array<string|SortObject> | null} SortSpec
  */
 
 /**
@@ -88,10 +93,17 @@ const escapeRegexReplacement = (string) => {
  * @property {JoiningTransformerMap[T]} joiningTransformer - Joining transformer
  * @property {boolean} [preventEval] - Whether to prevent eval in
  *   JSONPath
+ * @property {boolean} [sync] - When true, throw if a template returns a
+ *   Promise instead of awaiting it (disables `indexedDB()`)
  * @property {(path: string) => number} [specificityPriorityResolver]
  *   Priority resolver function
  * @property {import('./index.js').JSONPathTemplateObject<T>[]|
  *   import('./index.js').JSONPathTemplateArray<T>[]} [templates]
+ * @property {Record<string, unknown> & ThisType<
+ *   import('./JSONPathTransformerContext.js').default<T> &
+ *   import('./context-extensions.js').ContextExtensions
+ * >} [extensions] Extra methods/values
+ *   merged onto this context so templates can call `this.myHelper()`
  */
 
 /**
@@ -143,6 +155,9 @@ class JSONPathTransformerContext {
     this._preserveSpaceElements = [];
     /** @type {string[]} */
     this._stripSpaceElements = [];
+    if (config.extensions) {
+      applyExtensions(this, config.extensions);
+    }
   }
 
   /**
@@ -195,7 +210,7 @@ class JSONPathTransformerContext {
 
   /**
    * Gets the current output.
-   * @returns {any} The output from the joining transformer
+   * @returns {unknown} The output from the joining transformer
    */
   getOutput () {
     return this._getJoiningTransformer().get();
@@ -221,7 +236,7 @@ class JSONPathTransformerContext {
   }
 
   /**
-   * @param {any} v - Value to set
+   * @param {unknown} v - Value to set
    * @returns {this}
    */
   set (v) {
@@ -403,7 +418,7 @@ class JSONPathTransformerContext {
     const prevCurrPath = that._currPath;
 
     // Process in (sorted) order
-    for (const o of matches) {
+    const loopResult = maybeAsyncLoop(matches, (o) => {
       const {value, parent, parentProperty, path} = o;
       const _oldPath = that._currPath;
       that._currPath += path.replace(/^\$/v, '');
@@ -454,17 +469,19 @@ class JSONPathTransformerContext {
           }
           if (onNoMatch === 'deep-skip') {
             // Skip this node and its descendants entirely
-            continue;
+            return;
           }
           if (onNoMatch === 'shallow-copy') {
             // Output the value as-is without processing children
             joiner.append(value);
-            continue;
+            that._currPath = _oldPath;
+            return;
           }
           if (onNoMatch === 'deep-copy') {
             // Output the value and all descendants as-is
             joiner.append(JSON.stringify(value));
-            continue;
+            that._currPath = _oldPath;
+            return;
           }
           if (onNoMatch === 'text-only-copy') {
             // Output only text content (primitives)
@@ -472,7 +489,8 @@ class JSONPathTransformerContext {
                 typeof value === 'boolean') {
               joiner.append(String(value));
             }
-            continue;
+            that._currPath = _oldPath;
+            return;
           }
           // 'apply-templates', 'shallow-skip', or other:
           // use default template rules
@@ -573,15 +591,58 @@ class JSONPathTransformerContext {
       const prevTemplateParams = that._params;
       that._params = {0: value};
 
+      /**
+       * The template may return synchronously or return a Promise (e.g. from
+       * `await this.indexedDB(...)`), which is awaited unless `config.sync`.
+       * @type {any}
+       */
       const ret =
         /** @type {import('./index.js').JSONPathTemplateObject<T>} */ (
           templateObj
         ).template.call(
-          that, value, {mode, parent, parentProperty}
+          // `this` carries runtime `extensions`; a consumer's
+          // `ContextExtensions` augmentation would otherwise reject `that`.
+          /** @type {any} */ (that), value, {mode, parent, parentProperty}
         );
 
       // Restore previous parameter context
       that._params = prevTemplateParams;
+      if (ret !== null && typeof ret !== 'undefined' &&
+          typeof ret.then === 'function') {
+        if (that._config.sync) {
+          throw new Error(
+            'A template returned a Promise but JTLT is configured with ' +
+            '`sync: true`.'
+          );
+        }
+        // The loop body deliberately mixes value and no-value returns so
+        // `maybeAsyncLoop` can stay synchronous unless a template awaits.
+        // eslint-disable-next-line @stylistic/max-len -- Long
+        // eslint-disable-next-line promise/prefer-await-to-then, consistent-return -- intentional dynamic sync/async
+        return ret.then((/** @type {any} */ resolvedRet) => {
+          that._params = prevTemplateParams;
+          if (typeof resolvedRet !== 'undefined') {
+            const joiner = that._getJoiningTransformer();
+            /* c8 ignore start -- _openTagState only on
+               StringJoiningTransformer; string-output defensive check */
+            // @ts-expect-error -- _openTagState: StringJoiningTransformer only
+            if (joiner._openTagState) {
+              joiner.append('>');
+              // @ts-expect-error -- _openTagState: StringJoiningTransformer
+              joiner._openTagState = false;
+            }
+            /* c8 ignore stop */
+            joiner.append(resolvedRet);
+          }
+          that._parent = parent;
+          // Matches reached here always carry a parentProperty; the sync
+          // path covers the root-node fallback.
+          /* c8 ignore next */
+          that._parentProperty = (parentProperty ?? that._parentProperty);
+          that._currPath = _oldPath;
+          return undefined;
+        });
+      }
       if (typeof ret !== 'undefined') {
         // After the undefined check, ret is ResultType<T>
         const joiner = that._getJoiningTransformer();
@@ -604,12 +665,27 @@ class JSONPathTransformerContext {
       that._parent = parent;
       that._parentProperty = (parentProperty ?? that._parentProperty);
       that._currPath = _oldPath;
+    });
+
+    if (typeof loopResult?.then === 'function') {
+      // Returns a Promise<this> when a nested template ran asynchronously.
+      return /** @type {any} */ (
+        // eslint-disable-next-line @stylistic/max-len -- Long
+        // eslint-disable-next-line promise/prefer-await-to-then -- intentional dynamic sync/async
+        loopResult.then(() => {
+          this._contextObj = prevContext;
+          this._parent = prevParent;
+          this._parentProperty = prevParentProp;
+          this._currPath = prevCurrPath;
+          return this;
+        })
+      );
     }
-    // Restore outer context
-    that._contextObj = prevContext;
-    that._parent = prevParent;
-    that._parentProperty = prevParentProp;
-    that._currPath = prevCurrPath;
+
+    this._contextObj = prevContext;
+    this._parent = prevParent;
+    this._parentProperty = prevParentProp;
+    this._currPath = prevCurrPath;
     return this;
   }
 
@@ -657,7 +733,11 @@ class JSONPathTransformerContext {
       );
     }
 
-    const result = templateObj.template.call(this, this._contextObj, {});
+    const result = templateObj.template.call(
+      // `this` carries runtime `extensions`; a consumer's `ContextExtensions`
+      // augmentation would otherwise reject the bare context.
+      /** @type {any} */ (this), this._contextObj, {}
+    );
     if (typeof result !== 'undefined') {
       /** @type {any} */ (results).append(result);
     }
@@ -819,9 +899,12 @@ class JSONPathTransformerContext {
    *   expression matches
    * @param {string} [options.groupEndingWith] - Ends group when expression
    *   matches
-   * @param {any} [options.sort] - Sort specification (same as forEach)
+   * @param {SortSpec<V>} [options.sort] - Sort specification (same as forEach)
    * @param {(
-   *   this: JSONPathTransformerContext<T>, key: any, items: any[], ctx: any
+   *   this: JSONPathTransformerContext<T>,
+   *   key: unknown,
+   *   items: unknown[],
+   *   ctx: JSONPathTransformerContext<T>
    * ) => void} cb - Callback receives (groupingKey, groupItems, context)
    * @returns {this}
    */
@@ -1087,7 +1170,7 @@ class JSONPathTransformerContext {
           return 0;
         }
         if (Number.isNaN(an)) {
-          return Number(order);
+          return order;
         }
         if (Number.isNaN(bn)) {
           return -order;
@@ -1135,7 +1218,7 @@ class JSONPathTransformerContext {
 
   /**
    * Returns the current group (for use within forEachGroup callback).
-   * @returns {any[]|undefined}
+   * @returns {unknown[]|undefined}
    */
   currentGroup () {
     return /** @type {any} */ (this)._currentGroup;
@@ -1143,12 +1226,48 @@ class JSONPathTransformerContext {
 
   /**
    * Returns the current grouping key (for use within forEachGroup callback).
-   * @returns {any}
+   * @returns {unknown}
    */
   currentGroupingKey () {
     return /** @type {any} */ (this)._currentGroupingKey;
   }
 
+  /**
+   * Directly query IndexedDB from within a template, e.g.
+   * `await this.indexedDB('myDB', 'myStore', {index: 'byAge'})`.
+   *
+   * Since IndexedDB access is asynchronous, this is unavailable when JTLT is
+   * configured with `sync: true`.
+   * @param {string} dbName - Database name
+   * @param {string} storeName - Object store name
+   * @param {import('./indexedDB.js').QueryOptions} [options] - Query options
+   * @returns {Promise<unknown[]>} The matching records
+   */
+  indexedDB (dbName, storeName, options) {
+    if (this._config.sync) {
+      throw new Error(
+        'The `indexedDB()` API is unavailable when JTLT is configured with ' +
+        '`sync: true`.'
+      );
+    }
+    return queryIndexedDB(dbName, storeName, options);
+  }
+
+  /**
+   * Await a parsed `indexedDB(...)` expression and append its (stringified)
+   * value to the output. Used by {@link valueOf}. Callers reject `config.sync`.
+   * @param {import('./indexedDB.js').ParsedIndexedDBExpression} parsed
+   * @param {any} results - The joining transformer
+   * @returns {Promise<this>}
+   */
+  async _appendIndexedDBValue (parsed, results) {
+    const value = await resolveIndexedDBQuery(parsed, {
+      preventEval: this._config.preventEval
+    });
+    results.text(String(value));
+    return this;
+  }
+
   /**
    * @param {string|object} [select] - JSONPath selector
    * @returns {this}
@@ -1159,6 +1278,26 @@ class JSONPathTransformerContext {
     const results = this._getJoiningTransformer();
     let result;
 
+    const selectString = select && typeof select === 'object'
+      ? /** @type {{select?: string}} */ (select).select
+      : select;
+
+    // Intercept `indexedDB('db', 'store')<trailing JSONPath>` expressions and
+    // resolve them asynchronously before appending. Returns a Promise so
+    // templates can `await this.valueOf(...)`.
+    if (typeof selectString === 'string') {
+      const parsed = parseIndexedDBExpression(selectString);
+      if (parsed) {
+        if (this._config.sync) {
+          throw new Error(
+            'The `indexedDB()` function is unavailable when JTLT is ' +
+            'configured with `sync: true`.'
+          );
+        }
+        return /** @type {any} */ (this._appendIndexedDBValue(parsed, results));
+      }
+    }
+
     if (select && typeof select === 'object' &&
     /** @type {{select?: string}} */ (select).select === '.') {
       result = this._contextObj;
@@ -2079,8 +2218,8 @@ class JSONPathTransformerContext {
   /**
    * Invoke a registered stylesheet function with positional arguments.
    * @param {string} name - Function name (with namespace)
-   * @param {any[]} args - Positional arguments
-   * @returns {any} Function return value
+   * @param {unknown[]} args - Positional arguments
+   * @returns {unknown} Function return value
    */
   invokeFunctionByArity (name, args = []) {
     return this._getJoiningTransformer().invokeFunctionByArity(name, args);
@@ -2233,12 +2372,23 @@ class JSONPathTransformerContext {
 
   /**
    * @param {string} name - Key name
-   * @param {any} value - Value to match
-   * @returns {any}
+   * @param {unknown} value - Value to match
+   * @returns {unknown}
    */
   getKey (name, value) {
     const key = this.keys[name];
-    const matches = this.get(key.match, true);
+    // Keys are document-global (like `xsl:key`): resolve `match` against the
+    // root, not the current context (which may be a `forEach`/`applyTemplates`
+    // item).
+    const matches = /** @type {any[]} */ (
+      (/** @type {any} */ (jsonpath))({
+        path: JSONPathTransformer.makeJSONPathAbsolute(key.match),
+        json: this._origObj,
+        preventEval: this._config.preventEval,
+        wrap: true,
+        returnType: 'value'
+      })
+    );
     for (const match of matches) { // For objects or arrays
       if (match && typeof match === 'object' &&
         match[key.use] === value) {

package/src/XPathTransformer.js

@@ -7,6 +7,8 @@ import XPathTransformerContext from './XPathTransformerContext.js';
  * @property {import('./index.js').
  *   XPathTemplateArray<T>} templates Template objects
  * @property {number} [xpathVersion] XPath version (1|2|3.1)
+ * @property {boolean} [sync] When true, throw if a template returns a Promise
+ *   instead of awaiting it (disables `indexedDB()` and other async features)
  */
 
 /**
@@ -21,7 +23,7 @@ class XPathTransformer {
   static DefaultTemplateRules = {
     transformRoot: {
       /**
-       * @param {any} node Node
+       * @param {unknown} node Node
        * @param {{mode:string}} cfg Config
        * @returns {void}
        */
@@ -106,7 +108,37 @@ class XPathTransformer {
     }
     // Set up parameter context for valueOf() access in root template
     xte._params = {0: xte._contextNode};
+    /**
+     * The template may return synchronously or return a Promise (e.g. from
+     * `await this.indexedDB(...)`), which is awaited unless `config.sync`.
+     * @type {any}
+     */
     const ret = templateObj.template.call(xte, undefined, {mode});
+
+    if (ret !== null && typeof ret !== 'undefined' &&
+        typeof ret.then === 'function') {
+      if (this._config.sync) {
+        throw new Error(
+          'A template returned a Promise but JTLT is configured with ' +
+          '`sync: true`.'
+        );
+      }
+      return /** @type {any} */ (
+        // eslint-disable-next-line @stylistic/max-len -- Long
+        // eslint-disable-next-line promise/prefer-await-to-then -- intentional dynamic sync/async
+        ret.then((/** @type {any} */ resolvedRet) => {
+          if (typeof resolvedRet !== 'undefined') {
+            /** @type {any} */ (xte)._getJoiningTransformer().append(
+              resolvedRet
+            );
+          }
+          return /** @type {import('./index.js').ResultType<T>} */ (
+            xte.getOutput()
+          );
+        })
+      );
+    }
+
     if (typeof ret !== 'undefined') {
       /** @type {any} */ (xte)._getJoiningTransformer().append(ret);
     }

package/src/XPathTransformerContext.js

@@ -2,6 +2,13 @@ import xpath2 from 'xpath2.js'; // Runtime JS import; ambient types declared
 // eslint-disable-next-line @stylistic/max-len -- Long
 // xpathVersion: 1 => browser/native XPathEvaluator API; 2 => xpath2.js, 3 => fontoxpath
 import fontoxpath from 'fontoxpath';
+import {maybeAsyncLoop} from './maybeAsync.js';
+import applyExtensions from './extendContext.js';
+import {
+  queryIndexedDB,
+  xpathExpressionUsesIndexedDB,
+  evaluateXPathWithIndexedDB
+} from './indexedDB.js';
 // import xsdValidator from 'xsd-validator';
 
 /**
@@ -19,7 +26,16 @@ const escapeRegexReplacement = (string) => {
  * @property {import('./index.js').
  *   JoiningTransformer} joiningTransformer Joiner
  * @property {boolean} [errorOnEqualPriority]
+ * @property {boolean} [sync] - When true, throw if a template returns a
+ *   Promise instead of awaiting it (disables `indexedDB()`)
+ * @property {boolean} [preventEval] - Whether to prevent eval in the JSONPath
+ *   trailing segment of an `indexedDB(...)` expression
  * @property {(path: string) => number} [specificityPriorityResolver]
+ * @property {Record<string, unknown> & ThisType<
+ *   import('./XPathTransformerContext.js').default &
+ *   import('./context-extensions.js').ContextExtensions
+ * >} [extensions] Extra methods/values
+ *   merged onto this context so templates can call `this.myHelper()`
  */
 
 /**
@@ -124,11 +140,19 @@ class XPathTransformerContext {
     this._preserveSpaceElements = [];
     /** @type {string[]} */
     this._stripSpaceElements = [];
+    if (config.extensions) {
+      applyExtensions(this, config.extensions);
+    }
   }
 
-  /** @returns {import('./index.js').JoiningTransformer} */
+  /** @returns {import('./index.js').BuiltinJoiningTransformer} */
   _getJoiningTransformer () {
-    return this._config.joiningTransformer;
+    // Engine internals only ever run against a built-in joiner (they touch
+    // concrete members such as `_modeConfig`); a custom stub is the caller's
+    // responsibility.
+    return /** @type {import('./index.js').BuiltinJoiningTransformer} */ (
+      this._config.joiningTransformer
+    );
   }
 
   /**
@@ -398,9 +422,13 @@ class XPathTransformerContext {
     });
 
     const preApplyContext = this._contextNode;
+    const isSync = Boolean(/** @type {any} */ (this._config).sync);
 
-    // Process each node
-    for (const node of nodes) {
+    // Process each node. `maybeAsyncLoop` keeps this a plain synchronous
+    // loop unless a template returns a Promise (e.g. via
+    // `await this.indexedDB(...)`), in which case it chains and the whole
+    // call becomes asynchronous.
+    const loopResult = maybeAsyncLoop(nodes, (node) => {
     // Path resolution simplified (could track full XPath if needed)
       const pathMatchedTemplates = modeMatched.filter((t) => {
         // Basic matching: template.path is XPath tested for existence
@@ -438,7 +466,7 @@ class XPathTransformerContext {
           }
           if (onNoMatch === 'deep-skip') {
             // Skip this node entirely
-            continue;
+            return undefined;
           }
           if (onNoMatch === 'shallow-copy') {
             // Output the node without processing children
@@ -451,7 +479,7 @@ class XPathTransformerContext {
             } else if (node.nodeType === 3 && node.nodeValue) { // Text
               joiner.text(node.nodeValue);
             }
-            continue;
+            return undefined;
           }
           if (onNoMatch === 'deep-copy') {
             // Output the node and all descendants
@@ -462,7 +490,7 @@ class XPathTransformerContext {
             } else if (node.nodeType === 3 && node.nodeValue) { // Text
               joiner.text(node.nodeValue);
             }
-            continue;
+            return undefined;
           }
           if (onNoMatch === 'text-only-copy') {
             // Output only text content
@@ -474,7 +502,7 @@ class XPathTransformerContext {
                 joiner.text(textContent);
               }
             }
-            continue;
+            return undefined;
           }
           // 'apply-templates', 'shallow-skip', or other:
           // use default template rules
@@ -569,11 +597,45 @@ class XPathTransformerContext {
       const prevTemplateParams = this._params;
       this._params = {0: node};
 
+      /**
+       * The template may return synchronously or return a Promise (e.g. from
+       * `await this.indexedDB(...)`), which is awaited unless `config.sync`.
+       * @type {any}
+       */
       const ret = templateObj.template.call(this, node, {mode});
 
       // Restore previous parameter context
       this._params = prevTemplateParams;
 
+      if (ret !== null && typeof ret !== 'undefined' &&
+          typeof ret.then === 'function') {
+        if (isSync) {
+          throw new Error(
+            'A template returned a Promise but JTLT is configured with ' +
+            '`sync: true`.'
+          );
+        }
+        // eslint-disable-next-line @stylistic/max-len -- Long
+        // eslint-disable-next-line promise/prefer-await-to-then -- intentional dynamic sync/async
+        return ret.then((/** @type {any} */ resolvedRet) => {
+          if (typeof resolvedRet !== 'undefined') {
+            const joiner = this._getJoiningTransformer();
+            /* c8 ignore start -- _openTagState only on
+               StringJoiningTransformer; string-output defensive check */
+            // @ts-expect-error -- _openTagState: StringJoiningTransformer only
+            if (joiner._openTagState) {
+              joiner.append('>');
+              // @ts-expect-error -- _openTagState: StringJoiningTransformer
+              joiner._openTagState = false;
+            }
+            /* c8 ignore stop */
+            joiner.append(resolvedRet);
+          }
+          this._contextNode = node;
+          return undefined;
+        });
+      }
+
       if (typeof ret !== 'undefined') {
         const joiner = this._getJoiningTransformer();
         // Close any open tag before appending template return value
@@ -586,6 +648,18 @@ class XPathTransformerContext {
         joiner.append(ret);
       }
       this._contextNode = node; // Restore (placeholder for more complex state)
+      return undefined;
+    });
+
+    if (typeof loopResult?.then === 'function') {
+      return /** @type {any} */ (
+        // eslint-disable-next-line @stylistic/max-len -- Long
+        // eslint-disable-next-line promise/prefer-await-to-then -- intentional dynamic sync/async
+        loopResult.then(() => {
+          this._contextNode = preApplyContext;
+          return this;
+        })
+      );
     }
 
     this._contextNode = preApplyContext;
@@ -691,7 +765,10 @@ class XPathTransformerContext {
    * @param {string} [options.groupEndingWith] - Ends group when expression
    *   matches
    * @param {(
-   *   this: XPathTransformerContext, key: any, items: Node[], ctx: any
+   *   this: XPathTransformerContext,
+   *   key: unknown,
+   *   items: Node[],
+   *   ctx: XPathTransformerContext
    * ) => void} cb - Callback receives (groupingKey, groupItems, context)
    * @returns {this}
    */
@@ -919,25 +996,77 @@ class XPathTransformerContext {
 
   /**
    * Returns the current grouping key (for use within forEachGroup callback).
-   * @returns {any}
+   * @returns {unknown}
    */
   currentGroupingKey () {
     return /** @type {any} */ (this)._currentGroupingKey;
   }
 
+  /**
+   * Directly query IndexedDB from within a template, e.g.
+   * `await this.indexedDB('myDB', 'myStore', {index: 'byAge'})`.
+   *
+   * Since IndexedDB access is asynchronous, this is unavailable when JTLT is
+   * configured with `sync: true`.
+   * @param {string} dbName - Database name
+   * @param {string} storeName - Object store name
+   * @param {import('./indexedDB.js').QueryOptions} [options] - Query options
+   * @returns {Promise<unknown[]>} The matching records
+   */
+  indexedDB (dbName, storeName, options) {
+    if (/** @type {any} */ (this._config).sync) {
+      throw new Error(
+        'The `indexedDB()` API is unavailable when JTLT is configured with ' +
+        '`sync: true`.'
+      );
+    }
+    return queryIndexedDB(dbName, storeName, options);
+  }
+
+  /**
+   * Evaluate an XPath selector that calls the `jtlt:indexedDB(...)` function,
+   * awaiting the underlying IndexedDB reads, then append the string result.
+   * Used by {@link valueOf}. Callers reject `config.sync`.
+   * @param {string} selectStr
+   * @returns {Promise<XPathTransformerContext>}
+   */
+  async _appendIndexedDBValue (selectStr) {
+    const value = await evaluateXPathWithIndexedDB(
+      selectStr, this._contextNode
+    );
+    this._getJoiningTransformer().text(value);
+    return this;
+  }
+
   /**
    * Append the value from an XPath expression or the context node text.
    * @param {string|object} [select]
    * @returns {XPathTransformerContext}
    */
   valueOf (select) {
-    const jt = this._getJoiningTransformer();
-    let val;
-
     const selectStr = typeof select === 'object'
       ? /** @type {{select?: string}} */ (select).select
       : select;
 
+    // `jtlt:indexedDB(...)` is a registered XPath function backed by async
+    // IndexedDB reads. When it appears in the selector, evaluate the whole
+    // expression asynchronously (fontoxpath itself stays synchronous) and
+    // return a Promise so templates can `await this.valueOf(...)`.
+    if (xpathExpressionUsesIndexedDB(selectStr)) {
+      if (/** @type {any} */ (this._config).sync) {
+        throw new Error(
+          'The `indexedDB()` XPath function is unavailable when JTLT is ' +
+          'configured with `sync: true`.'
+        );
+      }
+      return /** @type {any} */ (
+        this._appendIndexedDBValue(/** @type {string} */ (selectStr))
+      );
+    }
+
+    const jt = this._getJoiningTransformer();
+    let val;
+
     // Check if select is a custom function call: prefix:name(...)
     // Try to parse and invoke registered function
     if (selectStr && (/^[^:]+:[^\(]+\(/v).test(selectStr)) {
@@ -1039,7 +1168,7 @@ class XPathTransformerContext {
           const resultToAppend = Array.isArray(result)
             ? result.join(' ')
             : result;
-          jt.append(resultToAppend);
+          jt.append(/** @type {string | Node} */ (resultToAppend));
           return this;
         }
       /* c8 ignore start -- Error handler for malformed function calls */
@@ -2002,8 +2131,8 @@ class XPathTransformerContext {
   /**
    * Invoke a registered stylesheet function with positional arguments.
    * @param {string} name - Function name (with namespace)
-   * @param {any[]} args - Positional arguments
-   * @returns {any} Function return value
+   * @param {unknown[]} args - Positional arguments
+   * @returns {unknown} Function return value
    */
   invokeFunctionByArity (name, args = []) {
     return this._getJoiningTransformer().invokeFunctionByArity(name, args);