jtlt 0.2.0 → 0.3.0

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;GAGG;AACH;;;GAGG;AACH;;;;;GAKG;AACH;;;GAGG;AACH;;;GAGG;AACH;;;GAGG;AAEH;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH;;;GAGG;AACH;;;GAGG;AAEH;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH;;;;;;;;;;GAUG;AAEH;;;;;;;;;;;GAWG;AAEH,oEAAoE;AAEpE;;;;;;GAMG;AAGH,gCAAiC,IAAI,CAAC;yCA3HzB,OAAO,iCAAiC,EAAE,OAAO;sCAIjD,OAAO,8BAA8B,EAAE,OAAO;yCAI9C,OAAO,iCAAiC,EAAE,OAAO,CAAC,QAAQ,CAAC,GACvE,OAAW,iCAAiC,EAAE,OAAO,CAAC,MAAM,CAAC,GAC7D,OAAW,iCAAiC,EAAE,OAAO,CAAC,KAAK,CAAC;oCAIhD,OAAO,4BAA4B,EAAE,OAAO;qCAI5C,OAAO,6BAA6B,EAAE,OAAO;uCAI7C,OAAO,+BAA+B,EAAE,OAAO;;;;6BAM/C,IAAI,IACJ,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,CAAC,EAAE,OAAO,EACpC,GAAG,CAAC,EAAE;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAC,KAClB,OAAO;;;;2BAKF,IAAI;UAEH,MAAM;;;;cAeN,gBAAgB,CAAC,IAAI,CAAC;;qCAIvB,cAAc,CAAC,0BAA0B,CAAC;kCAI1C,cAAc,CAAC,uBAAuB,CAAC;;;;;;;;;aAOtC,CAAC,MAAM,EAAE,OAAO,KAAK,IAAI;;;;WAEzB,OAAO;;;;;;;;;;;qBAQA,WAAW,KAAK,OAAO;0CACvB,MAAM,KAAK,CAAC,GAAC,GAAG,GAAC,CAAC,GAAG;;;aAG5B,OAAO;;;;;;;kCAOR,eAAe,GAAG;IAC1B,SAAS,CAAC,EAAE,sBAAsB,EAAE,GAClC,gBAAgB,CAAC,0BAA0B,CAAC,CAAC;IAC/C,QAAQ,CAAC,EAAE,sBAAsB,GAC/B,gBAAgB,CAAC,0BAA0B,CAAC,CAAC;IAC/C,KAAK,CAAC,EAAE,gBAAgB,CAAC,0BAA0B,CAAC,CAAC;IACrD,UAAU,CAAC,EAAE,UAAU,CAAA;CACxB;;;;+BAKS,eAAe,GAAG;IAC1B,SAAS,CAAC,EAAE,mBAAmB,EAAE,GAC/B,gBAAgB,CAAC,uBAAuB,CAAC,CAAC;IAC5C,QAAQ,CAAC,EAAE,mBAAmB,GAC5B,gBAAgB,CAAC,uBAAuB,CAAC,CAAC;IAC5C,KAAK,CAAC,EAAE,gBAAgB,CAAC,uBAAuB,CAAC,CAAC;IAClD,UAAU,EAAE,OAAO,CAAC;IACpB,YAAY,CAAC,EAAE,CAAC,GAAC,CAAC,CAAA;CACnB;0BAGU,mBAAmB,GAAG,gBAAgB;;;;;kCAKvC,WAAW,GAAG;IACtB,yBAAyB,CAAC,EAAE,OAAO,CAAA;CACpC"}

package/docs/API.expanded.md

@@ -54,7 +54,7 @@ const out = new JTLT({
 ```ts
 interface TemplateObject {
   name?: string;        // Optional identifier (for callTemplate)
-  path: string;         // JSONPath or XPath expression
+  path?: string;        // JSONPath or XPath expression (required for pattern-matching)
   mode?: string;        // Optional mode segregation
   priority?: number;    // Numeric priority (higher wins); fallback uses specificity resolver
   template(nodeValue, cfg): any; // Executed with `this` bound to context
@@ -62,6 +62,8 @@ interface TemplateObject {
 ```
 
 Edge cases:
+- Either `path` or `name` (or both) must be provided
+- Templates with only `name` (no `path`) are callable only via `callTemplate`
 - For JSONPath: `path` examples: `$.items[*]`, `$['prop']`, `$..deep`.
 - For XPath: `//item`, `/root/item`, `//*[@id='x']`.
 - Root template: path `$` (JSONPath) or `/` (XPath).
@@ -93,7 +95,7 @@ Config additions:
 ```js
 import {XPathTransformer, StringJoiningTransformer} from 'jtlt';
 // Assume `doc` is an XML Document
-const joiner = new StringJoiningTransformer('', {document: doc});
+const joiner = new StringJoiningTransformer('');
 const templates = [
   {
     name: 'root',
@@ -131,10 +133,19 @@ Methods (subset):
 - `applyTemplates(select, mode?, sort?)`
 - `forEach(select, cb, sort?)`
 - `valueOf(select?)`
+- `if(select, cb)` — conditionally execute `cb` when selection is truthy
+  (non-empty result set or truthy scalar)
+- `choose(select, whenCb, otherwiseCb?)` — like `if()`, but invokes
+  `otherwiseCb` when the condition is not met (akin to xsl:choose +
+  xsl:otherwise). Selection is evaluated relative to current context
+  object (its own `$`).
 - `variable(name, select)` – stores value/array from JSONPath.
 - `callTemplate(name, withParam?)`
 - `key(name, match, use)` / `getKey(name, value)`
 - Joiner passthrough: `string()`, `text()`, `element()`, `object()`, `array()`, `number()`, `boolean()`, etc.
+\- Cloning helpers:
+  - `copy(propertySets?)` — Shallow clone of current context value (object/array). Nested references are preserved. Optional `propertySets` (array of registered names) merge into the top-level clone when object-like.
+  - `copyOf(select?, propertySets?)` — Deep clone (prefers `structuredClone`; falls back to JSON + manual). When `select` is provided, clones that target instead of the current value; primitives append directly. Optional `propertySets` merge when cloning objects.
 
 ### `XPathTransformerContext`
 
@@ -142,9 +153,18 @@ Parallels JSONPath context with XPath evaluation:
 - `get(select, asNodes?)` – returns node array when `asNodes=true` (v1 uses snapshot type; v2 coerces scalar to array).
 - `forEach(select, cb)` – iterates matches.
 - `applyTemplates(select, mode?)` – default initialization to `.` then `*` for subsequent calls.
+- `if(select, cb)` — conditionally executes `cb` when XPath selects nodes
+  (non-empty) or evaluates to a truthy scalar value. In XPath v1 environments
+  without strict result typing, node-set existence is the primary check.
+- `choose(select, whenCb, otherwiseCb?)` — same semantics as `if()` but with
+  fallback callback when condition fails. Relative XPath resolves from the
+  current context node; absolute paths (`/`, `//`) target the document root.
 - `variable(name, select)` – always stores node arrays for XPath.
 - `key(name, match, use)` – index by attribute value; `getKey` returns matching Element or context sentinel (`this`).
 - Default template rules: root traverses `.`, element traverses `*`, text nodes emit `nodeValue`, scalars emit `valueOf('.')`.
+\- Cloning helpers:
+  - `copy()` — Shallow clone of the current context node (`cloneNode(false)`) appended to the joiner.
+  - `copyOf(select?)` — Deep clone of each node matched by `select` (node-set) or the current node if omitted, using `cloneNode(true)`. If `select` yields a scalar, that scalar is appended. Document nodes in scalar fallback emit their `documentElement` text. Chainable.
 
 ## Sorting API
 
@@ -226,6 +246,11 @@ When no user template matches:
 Common joiner methods summary:
 - `append(value)`
 - `get()`
+- `document(cb, cfg?)` — Creates a new output document. Similar to XSLT's
+  `xsl:document`, this allows templates to generate multiple output documents.
+  The callback builds the document content, and optional `cfg` provides output
+  configuration (encoding, doctype, etc.). When `exposeDocuments` is enabled,
+  each document is added to the array returned by `get()`.
 - `object(seed?, cb?, usePropertySets?, propSets?)`
 - `array(seed?, cb?)`
 - `element(name, attrs?, children?, cb?)`
@@ -233,6 +258,146 @@ Common joiner methods summary:
 - `text(str)` vs `string(str, cb?)` vs `plainText(str)`
 - `number()`, `boolean()`, `null()`, `undefined()` (JS mode), `nonfiniteNumber()`, `function(fn)`
 
+### document() method details
+
+The `document()` method creates a new output document in isolation:
+
+**DOM Joiner**: Creates a new XMLDocument with proper declaration and DOCTYPE
+when configured via `output()`.
+
+**JSON Joiner**: Creates a new document wrapper object with `$document` property
+containing the Jamilih representation.
+
+**String Joiner**: Creates a new document string with XML declaration and
+DOCTYPE when configured.
+
+**Signature**: `document(callback, outputConfig?)`
+
+**Example**:
+```js
+joiner.document(() => {
+  joiner.output({
+    method: 'xml',
+    version: '1.0',
+    encoding: 'utf8',
+    doctypePublic: '-//W3C//DTD XHTML 1.0//EN',
+    doctypeSystem: 'http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd'
+  });
+  joiner.element('html', {xmlns: 'http://www.w3.org/1999/xhtml'}, () => {
+    joiner.element('head', {}, () => {
+      joiner.element('title', {}, () => {
+        joiner.text('Document 1');
+      });
+    });
+  });
+});
+
+joiner.document(() => {
+  joiner.element('html', {}, () => {
+    joiner.element('body', {}, () => {
+      joiner.text('Document 2');
+    });
+  });
+});
+
+// When exposeDocuments is true, get() returns array of documents
+const docs = joiner.get();
+```
+
+The method preserves the current joiner state, resets it for the new document,
+executes the callback, captures the result, then restores the previous state.
+
+### resultDocument() method details
+
+The `resultDocument()` method creates output documents with associated metadata,
+paralleling XSLT's `xsl:result-document` functionality. Unlike `document()`,
+which stores documents in `_docs`, `resultDocument()` stores them in
+`_resultDocuments` with metadata including href URI and output format.
+
+**DOM Joiner**: Creates XMLDocument with href and format metadata.
+
+**JSON Joiner**: Creates document wrapper object or raw JSON with metadata.
+
+**String Joiner**: Creates document string with XML/HTML markup and metadata.
+
+**Signature**: `resultDocument(href, callback, outputConfig?)`
+
+**Parameters**:
+- `href` (string): URI or path for the result document (e.g., `'output/page1.html'`)
+- `callback` (function): Builds the document content with `this` bound to joiner
+- `outputConfig` (optional): Output configuration (encoding, doctype, method, etc.)
+
+**Result document structure**:
+```ts
+{
+  href: string,        // The URI/path provided
+  document: any,       // The generated document (XMLDocument, object, or string)
+  format: string       // Output format from config.method ('xml', 'html', 'text', 'xhtml', 'json')
+}
+```
+
+**Example use case - Multi-page site generation**:
+```js
+const pages = [
+  {title: 'Home', slug: 'index', content: 'Welcome'},
+  {title: 'About', slug: 'about', content: 'About us'},
+  {title: 'Contact', slug: 'contact', content: 'Get in touch'}
+];
+
+pages.forEach((page) => {
+  joiner.resultDocument(`output/${page.slug}.html`, () => {
+    joiner.output({
+      method: 'html',
+      doctypePublic: '-//W3C//DTD XHTML 1.0 Strict//EN',
+      doctypeSystem: 'http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd'
+    });
+    joiner.element('html', {xmlns: 'http://www.w3.org/1999/xhtml'}, () => {
+      joiner.element('head', {}, () => {
+        joiner.element('title', {}, () => {
+          joiner.text(page.title);
+        });
+      });
+      joiner.element('body', {}, () => {
+        joiner.element('h1', {}, () => {
+          joiner.text(page.title);
+        });
+        joiner.element('p', {}, () => {
+          joiner.text(page.content);
+        });
+      });
+    });
+  });
+});
+
+// Write each result document to its href location
+joiner._resultDocuments.forEach((result) => {
+  fs.writeFileSync(result.href, result.document);
+  console.log(`Generated: ${result.href} (${result.format})`);
+});
+```
+
+**Interoperability**: `document()` and `resultDocument()` can be used together in
+the same transformation. `document()` populates `_docs` (accessible via `get()`
+when `exposeDocuments` is true), while `resultDocument()` populates
+`_resultDocuments` with metadata.
+
+### Output configuration and formats
+
+Joiners accept an output configuration via `output(cfg)` and within `document()`/`resultDocument()`.
+
+- `cfg.method`: one of `xml`, `html`, `text`, `xhtml`, or `json`.
+  - `xml` and `xhtml` are XML-like: an XML declaration is emitted unless `omitXmlDeclaration` is true; DOCTYPE is included when `doctypePublic` or `doctypeSystem` is provided. For the JSON joiner, DOCTYPE entries are included in `$document.childNodes` only when `method` is `xml` or `xhtml`.
+  - `html` emits HTML; the String and DOM joiners serialize accordingly. The JSON joiner does not include a DOCTYPE node in its `$document` wrapper for `html`.
+  - `text` emits raw text (no element wrappers). The JSON joiner will not add DOCTYPE; the String joiner writes plain strings.
+  - `json` indicates a JSON-centric output; for the JSON joiner, this is the natural mode and does not add XML declarations or DOCTYPE.
+- `omitXmlDeclaration`: when false (or for `xml`/`xhtml` with default), include XML declaration with optional `version`, `encoding`, `standalone`.
+- `doctypePublic`/`doctypeSystem`: when provided and `method` is `xml`/`xhtml`, include a DOCTYPE entry.
+
+Notes for JSON joiner with `exposeDocuments`:
+
+- When `exposeDocuments` is enabled in the joiner config, `get()` returns an array of `$document` wrappers. Each wrapper has a `childNodes` array where the root element is the last entry; the first entry may be a DOCTYPE object when `method` is `xml` or `xhtml`.
+- For `html`, `text`, or `json` methods, no DOCTYPE is included in the JSON wrapper by default.
+
 ## Error handling
 
 - Equal priority templates: either last wins (default) or error if `errorOnEqualPriority=true`.

package/docs/API.md

@@ -33,11 +33,101 @@ new JTLT({
 `variable(name, select)`, `key(name, match, use)`, `getKey(name, value)`.
 JSONPath variables store values; XPath variables store arrays of nodes.
 
+Cloning:
+`copy()` (shallow clone current JSON value or DOM node) and
+`copyOf(select?)` (deep clone; optional selector overrides target; scalar
+selectors append the scalar). JSONPath deep cloning uses `structuredClone`
+fallbacks; XPath uses `cloneNode(true)`.
+
+Conditional execution:
+- `if(select, cb)` — runs `cb` when the selector matches (non-empty
+  result set) or coerces to a truthy scalar.
+- `choose(select, whenCb, otherwiseCb?)` — like `if()`, but also runs
+  `otherwiseCb` when the condition fails.
+
 ## Joiners
 
 StringJoiningTransformer, DOMJoiningTransformer, JSONJoiningTransformer with
 helpers: `string`, `text`, `element`, `attribute`, `object`, `array`,
-`number`, `boolean`, `plainText`, `append`, `get`.
+`number`, `boolean`, `plainText`, `append`, `get`, `document`.
+
+### document() method
+
+Similar to XSLT's `xsl:document`, the `document()` method allows templates to
+generate multiple output documents. It accepts a callback that builds the
+document content, and an optional output configuration.
+
+**Signature**: `document(callback, outputConfig?)`
+
+When `exposeDocuments` is enabled, each document created with `document()` is
+added to the array returned by `get()`.
+
+**Example**:
+```js
+joiner.document(() => {
+  joiner.output({method: 'xml', version: '1.0'});
+  joiner.element('doc1', {}, () => {
+    joiner.text('First document');
+  });
+});
+
+joiner.document(() => {
+  joiner.element('doc2', {}, () => {
+    joiner.text('Second document');
+  });
+});
+
+const docs = joiner.get(); // Returns array of 2 documents
+```
+
+### resultDocument() method
+
+Similar to XSLT's `xsl:result-document`, the `resultDocument()` method allows
+templates to generate multiple output documents **with metadata** (href URI,
+format). Documents are stored in `joiner._resultDocuments` array.
+
+**Signature**: `resultDocument(href, callback, outputConfig?)`
+
+Each result document is stored with:
+- `href`: The URI/path for the document (e.g., `'output/page1.html'`)
+- `document`: The generated document content
+- `format`: The output format (from `method` in config). One of `xml`, `html`, `text`, `xhtml`, or `json`.
+
+**Example**:
+```js
+joiner.resultDocument('output/doc1.xml', () => {
+  joiner.output({method: 'xml', version: '1.0'});
+  joiner.element('doc1', {}, () => {
+    joiner.text('First document');
+  });
+});
+
+joiner.resultDocument('output/doc2.html', () => {
+  joiner.output({method: 'html'});
+  joiner.element('html', {}, () => {
+    joiner.text('Second document');
+  });
+}, {method: 'html'});
+
+// Access result documents with metadata
+joiner._resultDocuments.forEach((result) => {
+  console.log(result.href); // e.g., 'output/doc1.xml'
+  console.log(result.format); // e.g., 'xml'
+  console.log(result.document); // The document content
+});
+```
+
+### Output configuration (quick reference)
+
+- `method`: `xml` | `html` | `text` | `xhtml` | `json`
+  - `xml`/`xhtml`: XML declaration unless `omitXmlDeclaration`; DOCTYPE included when `doctypePublic`/`doctypeSystem` present. For the JSON joiner, a DOCTYPE entry appears in `$document.childNodes` only for these methods.
+  - `html`: HTML output; JSON joiner wrapper omits DOCTYPE.
+  - `text`: raw text; no DOCTYPE.
+  - `json`: native JSON output; no XML declaration or DOCTYPE.
+- `omitXmlDeclaration`, `version`, `encoding`, `standalone`: control XML declaration (applicable to `xml`/`xhtml`).
+- `doctypePublic`, `doctypeSystem`: control DOCTYPE (applicable to `xml`/`xhtml`).
+
+Note: With `exposeDocuments` enabled on a joiner, `get()` returns an array of `$document` wrappers. In the JSON joiner, the root element is the last entry of `$document.childNodes`; a DOCTYPE may precede it for `xml`/`xhtml`.
 
 ## Sorting
 

package/docs/TO-DO.md

@@ -0,0 +1,144 @@
+## To-dos
+
+1.  Document and add test cases to cover current features! (Could adapt an XSLT/XQuery test suite)
+
+    1.  Implement and demo equivalent to applying and calling templates, and
+        root template
+
+    2.  Demo chaining of methods, including [equivalents](https://www.saxonica.com/papers/XTech2005/mhkpaper.html#S4.)
+        to XQuery's FLWOR expressions (see also Promises to-do), perhaps
+        even making aliases so that XQuery's friendlier terms can be used
+        instead of XSLT's.
+
+2.  Support processing of JSON documents with `$jtlt-stylesheet` to let
+    documents define their own targeted stylesheets.
+
+3.  When sufficiently documented, add as example library/tool to
+    JSONPath wiki.
+
+4.  Allow alternative to `element()`, `array()`, etc. methods by just
+    detecting those types from return values (and generic of each
+    type like `dom()` and `json()`).
+
+5.  Allow, depending on mode, containers to contain containers of other
+    types (e.g., a JS container containing DOM objects, or temporary use
+    of a string container, etc.).
+
+    1.  Support XML and add [hXML](https://github.com/brettz9/hxml) methods.
+
+    2.  Support [JHTML](https://github.com/brettz9/jhtml).
+
+    3.  Support `appendJSON()`/`appendDOM()` and
+        `appendType('json', ...)` (allowing type extensions).
+
+6.  Add `appendResult(function () {return result})`.
+
+7.  Add JSON update functions (equivalent to Xquery Update Facility for
+    XML ([overview](http://www.xmlplease.com/xquery-update))) and create
+    JSON serialization (as with XSLT expressed itself in declarative XML)
+    so one can submit and evaluate
+    through [HTTPQuery](https://github.com/brettz9/httpquery) (and also
+    supply to JSONEditor, etc.). Utilize updating by reference.
+
+8. Demo narrowing to subset of JavaScript (as with `jspe`) to make
+    JTLT truly "declarative" as far as freedom from scripting
+
+9. Use [fontoxpath](https://github.com/FontoXML/fontoxpath)
+    for XPath 3.1 implementation?
+
+## Possible to-dos
+
+1.  Make schema-aware so that templates could target types. Most reusable
+    application may be having a type-driven view of a JSON Schema instance
+    (e.g., dates could be shown inside a calendar widget). Perhaps this
+    schema-awareness could also drive a JSON editor (as with other existing
+    projects) (even using same API as JSONEditor?) (or type-aware filtered
+    search/raw queries). This would help not only for editors which edit a
+    JSON file in full, but also for providing schema paths or other identifiers
+    so that a transformed/queried subset of a file (or joining of multiple
+    files) could point the way for edited contents to be saved back to the
+    correct JSON file and position in the JSON file.
+
+2.  Add a [non-eval PR for JSONPath](https://github.com/s3u/JSONPath/pull/4).
+    The OR condition (outside of filters) is another important feature as
+    would be schema-aware path results.
+
+3.  Allow hybrid JSON/[Jamilih](https://github.com/brettz9/jamilih) or
+    JSON/(X)HTML/XML so that one can add
+    XPath or query into HTML in a relevant manner
+
+4.  Support pull parsing/streaming? Pass `done()` function to templates to
+    signal completion?
+
+5.  Support Promise API in addition to callbacks (reconcile with
+    current chaining; see also XQuery FLWOR to-do)
+
+6.  Add [XQuery Functions](https://code.google.com/p/jsxqueryparser/source/browse/trunk/jsxqueryparser/XQueryParser.js#1768)
+    (also supporting DOM and JSON where possible) as plug-in (also any
+    missing from XSLT/XQuery 3.0). Also add, if not present among these
+    functions (or in XQuery), add equivalents to XSLT's
+    `document()` and `unparsed-text()` for allowing non-JSON file
+    retrieval (as well as variables/parameters) and also methods for
+    iterating or retrieving IndexedDB, `localStorage`, and cookies
+    (names, keys and values).
+
+7.  Add `outputType` which uses a DOM joiner but allows specialized
+    serialized output (e.g., pretty-printed HTML) so the users
+    don't need to build it themselves (likewise with stringified
+    JSON output).
+
+8.  See code for other possible to-dos
+
+9. Consider implementing the following elements from <https://www.w3.org/TR/xslt20/>
+    which are not yet implemented.
+
+  "xsl:analyze-string",
+  "xsl:apply-imports",
+  ~~"xsl:apply-templates",~~
+  ~~"xsl:attribute",~~
+  "xsl:attribute-set",
+  ~~"xsl:call-template",~~
+  "xsl:character-map",
+  ~~"xsl:choose",~~
+  ~~"xsl:comment",~~
+  ~~"xsl:copy",~~
+  ~~"xsl:copy-of",~~
+  "xsl:decimal-format",
+  ~~"xsl:document",~~
+  ~~"xsl:element",~~
+  "xsl:fallback",
+  ~~"xsl:for-each",~~
+  "xsl:for-each-group",
+  "xsl:function",
+  ~~"xsl:if",~~
+  "xsl:import",
+  "xsl:import-schema",
+  "xsl:include",
+  ~~"xsl:key",~~
+  "xsl:matching-substring",
+  ~~"xsl:message",~~
+  "xsl:namespace",
+  "xsl:namespace-alias",
+  "xsl:next-match",
+  "xsl:non-matching-substring",
+  "xsl:number",
+  ~~"xsl:otherwise",~~
+  ~~"xsl:output",~~
+  "xsl:output-character",
+  "xsl:param",
+  "xsl:perform-sort",
+  "xsl:preserve-space",
+  ~~"xsl:processing-instruction",~~
+  ~~"xsl:result-document",~~
+  "xsl:sequence",
+  ~~"xsl:sort",~~
+  "xsl:strip-space",
+  ~~"xsl:stylesheet",~~
+  ~~"xsl:template",~~
+  ~~"xsl:text",~~
+  ~~"xsl:transform",~~
+  ~~"xsl:value-of",~~
+  ~~"xsl:variable",~~
+  ~~"xsl:when",~~
+  ~~"xsl:with-param"~~
+