@tradik/xslt3 0.0.0-stage → 1.0.0

package/src/xpath/index.js

@@ -0,0 +1,217 @@
+/**
+ * XPath 3.1: compile an expression once, evaluate it many times.
+ *
+ * ```js
+ * import { compileXPath, evaluateXPath } from "@tradik/xslt3/xpath";
+ * const expr = compileXPath("//item[@price > $min]", { variables: ["min"] });
+ * expr.evaluate(document, { variables: { min: 10 } }); // [Element, ...]
+ * evaluateXPath("sum(1 to 10)", null); // [AtomicValue xs:integer 55]
+ * ```
+ *
+ * Results are arrays of XDM items: DOM nodes, AtomicValue (xdm/atomic.js),
+ * XdmMap, XdmArray and FunctionItem (items/). JavaScript values given as
+ * variables or context item are converted (see eval/values.js).
+ *
+ * @module @tradik/xslt3/xpath
+ */
+
+import { XPathError } from "../errors.js";
+import { coreFunctions } from "../functions/core.js";
+import {
+  createFunctionLibrary,
+  FunctionLibrary,
+} from "../functions/registry.js";
+import { compileNode, withinLimits } from "./eval/compiler.js";
+import { createDescendantMemo } from "./eval/descendantMemo.js";
+import { createDynamicContext } from "./eval/dynamicContext.js";
+import { rootScope } from "./eval/scope.js";
+import { createStaticContext, variableKey } from "./eval/staticContext.js";
+import { toSequence } from "./eval/values.js";
+import { parseXPath } from "./syntax/index.js";
+
+/** The library of the built-in functions. */
+export const defaultFunctionLibrary = createFunctionLibrary(coreFunctions);
+
+/**
+ * @typedef {object} StaticOptions
+ * @property {object|Map|Array<{prefix: string, uri: string}>} [namespaces]
+ *   - Prefix bindings added to the predeclared ones (xml, xs, xsi, fn,
+ *   map, array, math, err); the prefix "" sets the default element namespace
+ * @property {string} [defaultElementNamespace] - Default element/type namespace
+ * @property {string} [defaultFunctionNamespace] - Default: the fn namespace
+ * @property {string[]|object} [variables] - Names of the external
+ *   variables (`name`, `prefix:name` or `Q{uri}name`), or an object whose
+ *   keys are the names
+ * @property {Array|FunctionLibrary} [functions] - Function definitions or
+ *   modules (arrays of definitions) added to the built-in ones, or a
+ *   complete library
+ * @property {boolean} [backwardsCompatible] - XPath 1.0 compatibility mode
+ * @property {string} [baseUri] - Static base URI
+ * @property {string} [defaultCollation] - Only the codepoint collation
+ * @property {Array<object>|object|Map} [decimalFormats] - Decimal formats
+ *   for fn:format-number: an array of definitions with a `name` (none for
+ *   the default format), or definitions by name; properties in camelCase
+ *   or as xsl:decimal-format attribute names (see eval/decimalFormats.js)
+ */
+
+/**
+ * @typedef {object} DynamicOptions
+ * @property {object} [variables] - Values of the external variables by name
+ * @property {number} [implicitTimezone] - Minutes, default 0 (UTC)
+ * @property {Date|import("../xdm/datetime.js").DateTimeValue} [currentDateTime]
+ * @property {(uri: string) => Node} [documentLoader] - Loads fn:doc URIs
+ *   (absolute, resolved against the base URI)
+ * @property {(uri: string) => (string|Uint8Array|ArrayBuffer|{content: string|Uint8Array|ArrayBuffer, encoding?: string, mediaType?: string})} [textLoader]
+ *   - Loads the text resources of fn:unparsed-text, fn:unparsed-text-lines,
+ *   fn:unparsed-text-available and fn:json-doc (absolute URIs, resolved
+ *   against the base URI); bytes are decoded by BOM, `encoding` (external
+ *   information), the XML declaration of an XML `mediaType`, the
+ *   function's encoding argument, else UTF-8. Return null or throw when
+ *   there is no resource (FOUT1170). Default: no resources at all;
+ *   `readFileUri` (exported) reads `file:` URIs in Node.js, for trusted
+ *   expressions only
+ * @property {(text: string, baseUri?: string) => Document} [xmlParser]
+ *   - Parses the strings of fn:parse-xml and fn:parse-xml-fragment; throws
+ *   when the text is not well-formed. Default: `globalThis.DOMParser`,
+ *   FODC0006 without it
+ * @property {(uri: string|null) => Array|null} [collections] - The items
+ *   of fn:collection by absolute URI (null: the default collection);
+ *   fn:uri-collection gives their document URIs (xs:anyURI items are
+ *   returned as they are). Null for an unknown collection (FODC0002).
+ *   Default: no collections
+ * @property {(value: Array, label: string) => void} [trace] - fn:trace output
+ * @property {() => Document} [createDocument] - Creates the empty
+ *   documents in which functions build new nodes (default: from the DOM of
+ *   the context item, else of the global document)
+ * @property {import("./eval/documentOrder.js").DocumentOrder} [documentOrder]
+ *   - Document order cache to share between evaluations over unchanged trees
+ */
+
+/**
+ * @param {StaticOptions["functions"]} functions
+ * @returns {FunctionLibrary}
+ */
+function libraryOf(functions) {
+  if (functions instanceof FunctionLibrary) return functions;
+  if (!functions || functions.length === 0) return defaultFunctionLibrary;
+  return defaultFunctionLibrary.extend(...functions);
+}
+
+/**
+ * @param {string[]|object|undefined} variables
+ * @returns {string[]} the variable names
+ */
+const variableNames = (variables) =>
+  Array.isArray(variables) ? variables : Object.keys(variables ?? {});
+
+/**
+ * Compiles an XPath 3.1 expression.
+ * @param {string} expression
+ * @param {StaticOptions} [options]
+ * @returns {{evaluate: (contextItem?: *, options?: DynamicOptions) => Array}}
+ *   the compiled expression; `evaluate` takes the context item (undefined
+ *   for none) and returns the result sequence
+ * @throws {XPathError} static errors: XPST0003 (syntax), XPST0008,
+ *   XPST0017, XPST0051, XPST0080, XPST0081...; XPDY0130 when the
+ *   expression is nested too deeply
+ */
+export function compileXPath(expression, options = {}) {
+  const sc = createStaticContext(options, libraryOf(options.functions));
+  const keys = variableNames(options.variables).map((name) =>
+    variableKey(name, sc),
+  );
+  const evaluator = withinLimits(() =>
+    compileNode(parseXPath(expression), rootScope(sc, keys)),
+  );
+  return {
+    evaluate(contextItem, dynamicOptions = {}) {
+      const values = new Map();
+      for (const [name, value] of Object.entries(
+        dynamicOptions.variables ?? {},
+      )) {
+        values.set(variableKey(name, sc), toSequence(value));
+      }
+      let env = null;
+      for (const key of keys) env = { value: values.get(key), next: env };
+      const focus = toSequence(contextItem);
+      if (focus.length > 1) {
+        throw new XPathError("XPTY0004", "The context item must be one item");
+      }
+      const ctx = {
+        item: focus[0],
+        position: 1,
+        size: 1,
+        env,
+        dyn: createDynamicContext(sc, dynamicOptions, focus[0]),
+      };
+      ctx.dyn.descendantMemo = createDescendantMemo();
+      return withinLimits(() => evaluator(ctx));
+    },
+  };
+}
+
+/** Static options other than `variables`; any of them disables the cache. */
+const STATIC_OPTIONS = [
+  "namespaces",
+  "defaultElementNamespace",
+  "defaultFunctionNamespace",
+  "functions",
+  "backwardsCompatible",
+  "baseUri",
+  "defaultCollation",
+  "decimalFormats",
+];
+
+/** Most compiled expressions kept by evaluateXPath. */
+export const COMPILED_CACHE_SIZE = 64;
+
+/** Compiled expressions of evaluateXPath by key, least recently used first. */
+const compiledCache = new Map();
+
+/**
+ * The compiled expression of evaluateXPath, from a small LRU cache when
+ * the only static option is `variables` (the names are part of the key):
+ * other static options can be objects that change between calls, so their
+ * expressions are compiled every time.
+ * @param {string} expression
+ * @param {StaticOptions} options
+ * @returns {ReturnType<typeof compileXPath>}
+ */
+function compiledFor(expression, options) {
+  const names = variableNames(options.variables);
+  const compile = () =>
+    compileXPath(expression, { ...options, variables: names });
+  if (STATIC_OPTIONS.some((name) => options[name] !== undefined)) {
+    return compile();
+  }
+  const key = JSON.stringify([expression, names]);
+  let compiled = compiledCache.get(key);
+  if (compiled) compiledCache.delete(key);
+  else {
+    compiled = compile();
+    if (compiledCache.size >= COMPILED_CACHE_SIZE) {
+      compiledCache.delete(compiledCache.keys().next().value);
+    }
+  }
+  compiledCache.set(key, compiled);
+  return compiled;
+}
+
+/**
+ * Compiles and evaluates an expression; the names of `options.variables`
+ * are the external variables. Without other static options, the compiled
+ * expression is kept in a small LRU cache (COMPILED_CACHE_SIZE
+ * expressions) and reused by the next calls with the same text and
+ * variable names; for repeated evaluations, compileXPath once is still
+ * the faster way.
+ * @param {string} expression
+ * @param {*} [contextItem] - Context item, undefined or null for none
+ * @param {StaticOptions & DynamicOptions} [options]
+ * @returns {Array} the result sequence
+ */
+export function evaluateXPath(expression, contextItem, options = {}) {
+  return compiledFor(expression, options).evaluate(contextItem, options);
+}
+
+export { createFunctionLibrary, FunctionLibrary, XPathError };
+export { readFileUri } from "./eval/resources.js";

package/src/xpath/syntax/ast.js

@@ -0,0 +1,130 @@
+/**
+ * The XPath 3.1 abstract syntax tree: expression nodes. Node tests and
+ * sequence types are described in typeAst.js.
+ *
+ * Every node is a plain object `{ type, ...fields, start, end }`, where
+ * `start` and `end` are offsets (UTF-16 code units) into the expression.
+ * Parentheses leave no node: `(E)` is the node of E, `()` an EmptySequence.
+ * Names stay as written ({@link QName}); the evaluator resolves prefixes and
+ * default namespaces. Numeric literals keep their lexical form, so decimals
+ * lose no precision before the data model sees them.
+ *
+ * @module @tradik/xslt3/xpath/syntax/ast
+ */
+
+/**
+ * A name as written: `local`, `prefix:local` or `Q{uri}local`.
+ *
+ * @typedef {object} QName
+ * @property {string|null} prefix - Prefix, null when absent
+ * @property {string} local - Local part
+ * @property {string|null} uri - Namespace of an EQName `Q{uri}local`, else null
+ */
+
+/**
+ * Any expression node.
+ *
+ * @typedef {SequenceExpr|EmptySequence|ForExpr|LetExpr|QuantifiedExpr|IfExpr|
+ *   LogicalExpr|ComparisonExpr|StringConcatExpr|RangeExpr|ArithmeticExpr|
+ *   SetExpr|InstanceOfExpr|TreatExpr|CastableExpr|CastExpr|ArrowExpr|
+ *   UnaryExpr|SimpleMapExpr|PathExpr|AxisStep|FilterExpr|DynamicFunctionCall|
+ *   Lookup|UnaryLookup|NumericLiteral|StringLiteral|VarRef|ContextItemExpr|
+ *   FunctionCall|NamedFunctionRef|InlineFunctionExpr|MapConstructor|
+ *   SquareArrayConstructor|CurlyArrayConstructor} Expr
+ */
+
+/** @typedef {{type: "SequenceExpr", items: Expr[], start: number, end: number}} SequenceExpr `E1, E2, ...` (two or more items) */
+/** @typedef {{type: "EmptySequence", start: number, end: number}} EmptySequence `()` */
+/** @typedef {{type: "Binding", name: QName, expr: Expr, start: number, end: number}} Binding `$name in E` or `$name := E` */
+/** @typedef {{type: "ForExpr", bindings: Binding[], returnExpr: Expr, start: number, end: number}} ForExpr `for $a in A, $b in B return R` */
+/** @typedef {{type: "LetExpr", bindings: Binding[], returnExpr: Expr, start: number, end: number}} LetExpr `let $a := A, $b := B return R` */
+/** @typedef {{type: "QuantifiedExpr", quantifier: "some"|"every", bindings: Binding[], satisfies: Expr, start: number, end: number}} QuantifiedExpr */
+/** @typedef {{type: "IfExpr", condition: Expr, thenExpr: Expr, elseExpr: Expr, start: number, end: number}} IfExpr */
+/** @typedef {{type: "LogicalExpr", operator: "or"|"and", left: Expr, right: Expr, start: number, end: number}} LogicalExpr */
+
+/**
+ * Comparison; `kind` is "general" (= != < <= > >=), "value" (eq ne lt le gt
+ * ge) or "node" (is << >>). Comparisons do not chain.
+ *
+ * @typedef {{type: "ComparisonExpr", kind: "general"|"value"|"node", operator: string, left: Expr, right: Expr, start: number, end: number}} ComparisonExpr
+ */
+
+/** @typedef {{type: "StringConcatExpr", left: Expr, right: Expr, start: number, end: number}} StringConcatExpr `A || B` */
+/** @typedef {{type: "RangeExpr", left: Expr, right: Expr, start: number, end: number}} RangeExpr `A to B` */
+/** @typedef {{type: "ArithmeticExpr", operator: "+"|"-"|"*"|"div"|"idiv"|"mod", left: Expr, right: Expr, start: number, end: number}} ArithmeticExpr */
+/** @typedef {{type: "SetExpr", operator: "union"|"intersect"|"except", left: Expr, right: Expr, start: number, end: number}} SetExpr `|` is stored as "union" */
+/** @typedef {{type: "InstanceOfExpr", expr: Expr, sequenceType: import("./typeAst.js").SequenceType, start: number, end: number}} InstanceOfExpr */
+/** @typedef {{type: "TreatExpr", expr: Expr, sequenceType: import("./typeAst.js").SequenceType, start: number, end: number}} TreatExpr */
+/** @typedef {{type: "CastableExpr", expr: Expr, targetType: QName, emptyAllowed: boolean, start: number, end: number}} CastableExpr `E castable as T?` */
+/** @typedef {{type: "CastExpr", expr: Expr, targetType: QName, emptyAllowed: boolean, start: number, end: number}} CastExpr `E cast as T?` */
+
+/**
+ * `E => f(args)`, `E => $f(args)` or `E => (expr)(args)`: exactly one of
+ * `functionName` and `functionExpr` is set. Arguments do not include E.
+ *
+ * @typedef {{type: "ArrowExpr", expr: Expr, functionName: QName|null, functionExpr: Expr|null, arguments: Array<Expr|ArgumentPlaceholder>, start: number, end: number}} ArrowExpr
+ */
+
+/** @typedef {{type: "UnaryExpr", operator: "+"|"-", operand: Expr, start: number, end: number}} UnaryExpr `--E` nests two nodes */
+/** @typedef {{type: "SimpleMapExpr", left: Expr, right: Expr, start: number, end: number}} SimpleMapExpr `A ! B` */
+
+/**
+ * A path with at least one `/` or `//`. `absolute` is true for a leading
+ * slash; a lone `/` has no steps. `//` is expanded to
+ * `/descendant-or-self::node()/`, so `//a` has two steps.
+ *
+ * @typedef {{type: "PathExpr", absolute: boolean, steps: Expr[], start: number, end: number}} PathExpr
+ */
+
+/**
+ * An axis step, abbreviated or not: `@a` has axis "attribute", `..` is
+ * `parent::node()`, and a step without axis takes "child", or "attribute"
+ * for an attribute()/schema-attribute() test, or "namespace" for
+ * namespace-node() (XPath 3.1 section 3.3.5).
+ *
+ * @typedef {{type: "AxisStep", axis: string, nodeTest: import("./typeAst.js").NodeTest, predicates: Expr[], start: number, end: number}} AxisStep
+ */
+
+/** @typedef {{type: "FilterExpr", base: Expr, predicate: Expr, start: number, end: number}} FilterExpr `E[P]` on a primary expression */
+/** @typedef {{type: "DynamicFunctionCall", functionExpr: Expr, arguments: Array<Expr|ArgumentPlaceholder>, start: number, end: number}} DynamicFunctionCall `$f(1, ?)` */
+
+/**
+ * Lookup `E?key`. `keyKind` "name" (`key` is the NCName), "integer" (`key`
+ * is the lexical integer), "expr" (`key` is the parenthesized Expr) or
+ * "wildcard" (`?*`, `key` null).
+ *
+ * @typedef {{type: "Lookup", base: Expr, keyKind: "name"|"integer"|"expr"|"wildcard", key: string|Expr|null, start: number, end: number}} Lookup
+ */
+
+/** @typedef {{type: "UnaryLookup", keyKind: "name"|"integer"|"expr"|"wildcard", key: string|Expr|null, start: number, end: number}} UnaryLookup `?key` on the context item */
+/** @typedef {{type: "NumericLiteral", kind: "integer"|"decimal"|"double", value: string, start: number, end: number}} NumericLiteral `value` is the lexical form */
+/** @typedef {{type: "StringLiteral", value: string, start: number, end: number}} StringLiteral Doubled quotes already unescaped */
+/** @typedef {{type: "VarRef", name: QName, start: number, end: number}} VarRef */
+/** @typedef {{type: "ContextItemExpr", start: number, end: number}} ContextItemExpr `.` */
+/** @typedef {{type: "FunctionCall", name: QName, arguments: Array<Expr|ArgumentPlaceholder>, start: number, end: number}} FunctionCall With a placeholder it is a partial application */
+/** @typedef {{type: "ArgumentPlaceholder", start: number, end: number}} ArgumentPlaceholder `?` as an argument */
+/** @typedef {{type: "NamedFunctionRef", name: QName, arity: number, start: number, end: number}} NamedFunctionRef `name#arity` */
+/** @typedef {{type: "Param", name: QName, sequenceType: import("./typeAst.js").SequenceType|null, start: number, end: number}} Param */
+/** @typedef {{type: "InlineFunctionExpr", params: Param[], returnType: import("./typeAst.js").SequenceType|null, body: Expr, start: number, end: number}} InlineFunctionExpr An empty body `{}` is an EmptySequence */
+/** @typedef {{type: "MapEntry", key: Expr, value: Expr, start: number, end: number}} MapEntry */
+/** @typedef {{type: "MapConstructor", entries: MapEntry[], start: number, end: number}} MapConstructor `map { k : v, ... }` */
+/** @typedef {{type: "SquareArrayConstructor", members: Expr[], start: number, end: number}} SquareArrayConstructor `[a, b]`: one member per expression */
+/** @typedef {{type: "CurlyArrayConstructor", expr: Expr, start: number, end: number}} CurlyArrayConstructor `array { E }`: one member per item of E */
+
+/**
+ * Creates a node with the fields in a stable order: type, fields, offsets.
+ *
+ * @template {object} F
+ * @param {string} type - Node type
+ * @param {F} fields - Node-specific fields
+ * @param {number} start - Offset of the first character
+ * @param {number} end - Offset after the last character
+ * @returns {{type: string, start: number, end: number} & F} The node
+ */
+export function makeNode(type, fields, start, end) {
+  // Object.assign: several times faster than a spread in a literal here
+  const node = Object.assign({ type }, fields);
+  node.start = start;
+  node.end = end;
+  return node;
+}

package/src/xpath/syntax/chars.js

@@ -0,0 +1,58 @@
+/**
+ * Character classes of the XPath 3.1 lexical structure (Appendix A.2).
+ *
+ * Names use the XML 1.0 (fifth edition) name characters, which are also
+ * those of XML 1.1, so the xml-version constraint (A.1.2) needs no switch.
+ *
+ * @module @tradik/xslt3/xpath/syntax/chars
+ */
+
+const NAME_START =
+  "A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D" +
+  "\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF" +
+  "\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD\\u{10000}-\\u{EFFFF}";
+const NAME_CHAR = `${NAME_START}\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040`;
+
+/** NCName (sticky). */
+// The combining marks U+0300-U+036F are NameChars on their own, as XML says.
+// eslint-disable-next-line no-misleading-character-class
+export const NCNAME = new RegExp(`[${NAME_START}][${NAME_CHAR}]*`, "uy");
+/** One NameStartChar without ":" (sticky). */
+export const NAME_START_CHAR = new RegExp(`[${NAME_START}]`, "uy");
+/** IntegerLiteral, DecimalLiteral or DoubleLiteral (sticky). */
+export const NUMBER = /(?:\.[0-9]+|[0-9]+(?:\.[0-9]*)?)(?:[eE][+-]?[0-9]+)?/y;
+/** XML whitespace (sticky). */
+export const WHITESPACE = /[ \t\r\n]+/y;
+
+/**
+ * Returns the match of a sticky regular expression at an offset.
+ *
+ * @param {RegExp} pattern - Sticky (`y`) pattern
+ * @param {string} text - Source
+ * @param {number} offset - Where the match must start
+ * @returns {string|null} The matched text, or null
+ */
+export function matchAt(pattern, text, offset) {
+  pattern.lastIndex = offset;
+  const match = pattern.exec(text);
+  return match ? match[0] : null;
+}
+
+/**
+ * @param {string} text - Candidate name
+ * @returns {boolean} Whether the whole text is an NCName
+ */
+export function isNCName(text) {
+  return matchAt(NCNAME, text, 0) === text;
+}
+
+/**
+ * Whitespace normalization of xs:anyURI and normalize-space(): runs of
+ * whitespace become one space, leading and trailing ones are removed.
+ *
+ * @param {string} text - Text
+ * @returns {string} Normalized text
+ */
+export function normalizeSpace(text) {
+  return text.replace(/[ \t\r\n]+/g, " ").trim();
+}

package/src/xpath/syntax/constructors.js

@@ -0,0 +1,144 @@
+/**
+ * Parser of the XPath 3.1 constructors: inline function expressions
+ * (productions [69] InlineFunctionExpr, [10] ParamList, [11] Param), maps
+ * ([69] MapConstructor to [72] MapValueExpr) and arrays ([73]
+ * ArrayConstructor to [75] CurlyArrayConstructor) of Appendix A.1.
+ *
+ * @module @tradik/xslt3/xpath/syntax/constructors
+ */
+
+import { makeNode } from "./ast.js";
+import { parseExpr, parseExprSingle } from "./expressions.js";
+import { qName } from "./tokenStream.js";
+import { parseSequenceType } from "./types.js";
+
+/** @typedef {import("./tokenStream.js").TokenStream} TokenStream */
+/** @typedef {import("./ast.js").Expr} Expr */
+
+/**
+ * EnclosedExpr ::= "{" Expr? "}"; an empty one gives an EmptySequence.
+ *
+ * @param {TokenStream} p - Tokens, at "{"
+ * @returns {{expr: Expr, end: number}} The content and the offset after "}"
+ */
+function parseEnclosedExpr(p) {
+  const open = p.expectSymbol("{");
+  const close = p.acceptSymbol("}");
+  if (close) {
+    return {
+      expr: makeNode("EmptySequence", {}, open.start, close.end),
+      end: close.end,
+    };
+  }
+  const expr = parseExpr(p);
+  return { expr, end: p.expectSymbol("}").end };
+}
+
+/**
+ * Reads `item ("," item)*` up to a closing symbol, which is consumed.
+ *
+ * @template T
+ * @param {TokenStream} p - Tokens, after the opening symbol
+ * @param {string} close - Closing symbol
+ * @param {(p: TokenStream) => T} parseItem - Parser of one item
+ * @returns {{items: T[], end: number}} The items and the offset after close
+ */
+function parseList(p, close, parseItem) {
+  const items = [];
+  if (!p.isSymbol(close)) {
+    do items.push(parseItem(p));
+    while (p.acceptSymbol(","));
+  }
+  return { items, end: p.expectSymbol(close).end };
+}
+
+/**
+ * InlineFunctionExpr ::= "function" "(" ParamList? ")" ("as" SequenceType)?
+ * FunctionBody
+ *
+ * @param {TokenStream} p - Tokens, at "function"
+ * @returns {import("./ast.js").InlineFunctionExpr} The function
+ */
+export function parseInlineFunctionExpr(p) {
+  const start = p.next().start;
+  p.expectSymbol("(");
+  const { items: params } = parseList(p, ")", parseParam);
+  const returnType = p.acceptKeyword("as") ? parseSequenceType(p) : null;
+  const { expr: body, end } = parseEnclosedExpr(p);
+  return makeNode(
+    "InlineFunctionExpr",
+    { params, returnType, body },
+    start,
+    end,
+  );
+}
+
+/**
+ * Param ::= "$" EQName TypeDeclaration?
+ *
+ * @param {TokenStream} p - Tokens
+ * @returns {import("./ast.js").Param} The parameter
+ */
+function parseParam(p) {
+  const dollar = p.expectSymbol("$");
+  const name = p.expectName("a parameter name");
+  const sequenceType = p.acceptKeyword("as") ? parseSequenceType(p) : null;
+  const end = sequenceType ? sequenceType.end : name.end;
+  return makeNode(
+    "Param",
+    { name: qName(name), sequenceType },
+    dollar.start,
+    end,
+  );
+}
+
+/**
+ * MapConstructor ::= "map" "{" (MapConstructorEntry ("," ...)*)? "}"
+ *
+ * @param {TokenStream} p - Tokens, at "map"
+ * @returns {import("./ast.js").MapConstructor} The constructor
+ */
+export function parseMapConstructor(p) {
+  const start = p.next().start;
+  p.expectSymbol("{");
+  const { items: entries, end } = parseList(p, "}", parseMapEntry);
+  return makeNode("MapConstructor", { entries }, start, end);
+}
+
+/**
+ * MapConstructorEntry ::= ExprSingle ":" ExprSingle. Note that `map{a:b}`
+ * reads the QName `a:b`; a key that is a name needs a space: `map{a :b}`.
+ *
+ * @param {TokenStream} p - Tokens
+ * @returns {import("./ast.js").MapEntry} The entry
+ */
+function parseMapEntry(p) {
+  const key = parseExprSingle(p);
+  p.expectSymbol(":");
+  const value = parseExprSingle(p);
+  return makeNode("MapEntry", { key, value }, key.start, value.end);
+}
+
+/**
+ * SquareArrayConstructor ::= "[" (ExprSingle ("," ExprSingle)*)? "]"
+ *
+ * @param {TokenStream} p - Tokens, at "["
+ * @returns {import("./ast.js").SquareArrayConstructor} The constructor
+ */
+export function parseSquareArrayConstructor(p) {
+  const start = p.next().start;
+  const { items: members, end } = parseList(p, "]", parseExprSingle);
+  return makeNode("SquareArrayConstructor", { members }, start, end);
+}
+
+/**
+ * CurlyArrayConstructor ::= "array" EnclosedExpr
+ *
+ * @param {TokenStream} p - Tokens, at "array"
+ * @returns {import("./ast.js").CurlyArrayConstructor} The constructor
+ */
+export function parseCurlyArrayConstructor(p) {
+  const start = p.next().start;
+  const { expr, end } = parseEnclosedExpr(p);
+  return makeNode("CurlyArrayConstructor", { expr }, start, end);
+}

package/src/xpath/syntax/expressions.js

@@ -0,0 +1,107 @@
+/**
+ * Parser of the top of the XPath 3.1 grammar: Expr (the comma operator),
+ * ExprSingle and the expressions introduced by a keyword (for, let, some,
+ * every, if). Productions [6] to [15] of XPath 3.1 Appendix A.1.
+ *
+ * Each function takes the {@link TokenStream} and returns an AST node.
+ *
+ * @module @tradik/xslt3/xpath/syntax/expressions
+ */
+
+import { makeNode } from "./ast.js";
+import { parseOrExpr } from "./operators.js";
+import { qName } from "./tokenStream.js";
+
+/** @typedef {import("./tokenStream.js").TokenStream} TokenStream */
+/** @typedef {import("./ast.js").Expr} Expr */
+
+/**
+ * Expr ::= ExprSingle ("," ExprSingle)*
+ *
+ * @param {TokenStream} p - Tokens
+ * @returns {Expr} A SequenceExpr for two or more items, else the item
+ */
+export function parseExpr(p) {
+  const first = parseExprSingle(p);
+  if (!p.isSymbol(",")) return first;
+  const items = [first];
+  while (p.acceptSymbol(",")) items.push(parseExprSingle(p));
+  return makeNode("SequenceExpr", { items }, first.start, items.at(-1).end);
+}
+
+/**
+ * ExprSingle ::= ForExpr | LetExpr | QuantifiedExpr | IfExpr | OrExpr.
+ * A keyword starts its expression only when followed by "$" (or "(" for
+ * `if`); otherwise it is an ordinary name, e.g. the element `for`.
+ *
+ * @param {TokenStream} p - Tokens
+ * @returns {Expr} The expression
+ */
+export function parseExprSingle(p) {
+  if (p.isSymbol("$", 1)) {
+    if (p.isKeyword("for")) {
+      return parseBindingExpr(p, "ForExpr", "in", "return");
+    }
+    if (p.isKeyword("let")) {
+      return parseBindingExpr(p, "LetExpr", ":=", "return");
+    }
+    if (p.isKeyword("some") || p.isKeyword("every")) {
+      return parseBindingExpr(p, "QuantifiedExpr", "in", "satisfies");
+    }
+  }
+  if (p.isKeyword("if") && p.isSymbol("(", 1)) return parseIfExpr(p);
+  return parseOrExpr(p);
+}
+
+/**
+ * ForExpr, LetExpr and QuantifiedExpr, which share their shape:
+ * keyword binding ("," binding)* final-keyword ExprSingle.
+ *
+ * @param {TokenStream} p - Tokens
+ * @param {"ForExpr"|"LetExpr"|"QuantifiedExpr"} type - Node type
+ * @param {"in"|":="} separator - Between variable and value
+ * @param {"return"|"satisfies"} finalKeyword - Before the result expression
+ * @returns {Expr} The node
+ */
+function parseBindingExpr(p, type, separator, finalKeyword) {
+  const keyword = p.next();
+  const bindings = [];
+  do {
+    const dollar = p.expectSymbol("$");
+    const name = qName(p.expectName("a variable name"));
+    if (separator === "in") p.expectKeyword("in");
+    else p.expectSymbol(":=");
+    const expr = parseExprSingle(p);
+    bindings.push(makeNode("Binding", { name, expr }, dollar.start, expr.end));
+  } while (p.acceptSymbol(","));
+  p.expectKeyword(finalKeyword);
+  const result = parseExprSingle(p);
+  const fields =
+    type === "QuantifiedExpr"
+      ? { quantifier: keyword.local, bindings, satisfies: result }
+      : { bindings, returnExpr: result };
+  return makeNode(type, fields, keyword.start, result.end);
+}
+
+/**
+ * IfExpr ::= "if" "(" Expr ")" "then" ExprSingle "else" ExprSingle
+ *
+ * @param {TokenStream} p - Tokens
+ * @returns {import("./ast.js").IfExpr} The node
+ */
+function parseIfExpr(p) {
+  const start = p.next().start;
+  p.expectSymbol("(");
+  const condition = parseExpr(p);
+  p.expectSymbol(")");
+  p.expectKeyword("then");
+  const thenExpr = parseExprSingle(p);
+  p.expectKeyword("else");
+  const elseExpr = parseExprSingle(p);
+  return makeNode(
+    "IfExpr",
+    { condition, thenExpr, elseExpr },
+    start,
+    elseExpr.end,
+  );
+}