@tradik/xslt3 0.0.0-stage → 1.0.0

package/src/xpath/syntax/postfix.js

@@ -0,0 +1,91 @@
+/**
+ * Parser of XPath 3.1 postfix expressions: productions [49] PostfixExpr,
+ * [50] ArgumentList, [53] Lookup and [54] KeySpecifier of Appendix A.1
+ * (predicates, dynamic function calls and lookups after a primary).
+ *
+ * @module @tradik/xslt3/xpath/syntax/postfix
+ */
+
+import { makeNode } from "./ast.js";
+import { parseExprSingle } from "./expressions.js";
+import { parseParenthesizedExpr, parsePrimaryExpr } from "./primaries.js";
+import { parsePredicate } from "./steps.js";
+import { isPlainName } from "./tokenStream.js";
+
+/** @typedef {import("./tokenStream.js").TokenStream} TokenStream */
+/** @typedef {import("./ast.js").Expr} Expr */
+
+/**
+ * PostfixExpr ::= PrimaryExpr (Predicate | ArgumentList | Lookup)*
+ *
+ * @param {TokenStream} p - Tokens
+ * @returns {Expr} The expression
+ */
+export function parsePostfixExpr(p) {
+  let expr = parsePrimaryExpr(p);
+  for (;;) {
+    if (p.isSymbol("[")) {
+      const { predicate, end } = parsePredicate(p);
+      expr = makeNode("FilterExpr", { base: expr, predicate }, expr.start, end);
+    } else if (p.isSymbol("(")) {
+      const { arguments: args, end } = parseArgumentList(p);
+      expr = makeNode(
+        "DynamicFunctionCall",
+        { functionExpr: expr, arguments: args },
+        expr.start,
+        end,
+      );
+    } else if (p.acceptSymbol("?")) {
+      const { keyKind, key, end } = parseKeySpecifier(p);
+      expr = makeNode("Lookup", { base: expr, keyKind, key }, expr.start, end);
+    } else {
+      return expr;
+    }
+  }
+}
+
+/**
+ * ArgumentList ::= "(" (Argument ("," Argument)*)? ")", an Argument being
+ * an ExprSingle or the placeholder "?" (partial function application).
+ *
+ * @param {TokenStream} p - Tokens, at "("
+ * @returns {{arguments: Array<Expr|import("./ast.js").ArgumentPlaceholder>, end: number}}
+ *   The arguments and the offset after ")"
+ */
+export function parseArgumentList(p) {
+  p.expectSymbol("(");
+  const args = [];
+  if (!p.isSymbol(")")) {
+    do {
+      if (p.isSymbol("?") && (p.isSymbol(",", 1) || p.isSymbol(")", 1))) {
+        const { start, end } = p.next();
+        args.push(makeNode("ArgumentPlaceholder", {}, start, end));
+      } else {
+        args.push(parseExprSingle(p));
+      }
+    } while (p.acceptSymbol(","));
+  }
+  return { arguments: args, end: p.expectSymbol(")").end };
+}
+
+/**
+ * KeySpecifier ::= NCName | IntegerLiteral | ParenthesizedExpr | "*", after
+ * the "?" of a lookup.
+ *
+ * @param {TokenStream} p - Tokens
+ * @returns {{keyKind: string, key: string|Expr|null, end: number}} The key
+ */
+export function parseKeySpecifier(p) {
+  const token = p.peek();
+  if (isPlainName(token) || token.type === "integer") {
+    p.next();
+    const keyKind = token.type === "name" ? "name" : "integer";
+    return { keyKind, key: token.local ?? token.value, end: token.end };
+  }
+  if (p.acceptSymbol("*")) {
+    return { keyKind: "wildcard", key: null, end: token.end };
+  }
+  if (!p.isSymbol("(")) p.fail('Expected a key: NCName, integer, "(" or "*"');
+  const key = parseParenthesizedExpr(p);
+  return { keyKind: "expr", key, end: p.lastEnd };
+}

package/src/xpath/syntax/primaries.js

@@ -0,0 +1,149 @@
+/**
+ * Parser of XPath 3.1 primary expressions: productions [56] PrimaryExpr to
+ * [68] NamedFunctionRef and [76] UnaryLookup of Appendix A.1. Postfixes are
+ * in postfix.js; function, map and array constructors in constructors.js.
+ *
+ * Reserved-function-names constraint (A.3): an unprefixed name from
+ * {@link RESERVED_FUNCTION_NAMES} cannot be called or referenced as a
+ * function, so `if(1)` or `node#0` never are function calls.
+ *
+ * @module @tradik/xslt3/xpath/syntax/primaries
+ */
+
+import { makeNode } from "./ast.js";
+import {
+  parseCurlyArrayConstructor,
+  parseInlineFunctionExpr,
+  parseMapConstructor,
+  parseSquareArrayConstructor,
+} from "./constructors.js";
+import { parseExpr } from "./expressions.js";
+import { parseArgumentList, parseKeySpecifier } from "./postfix.js";
+import { isPlainName, qName } from "./tokenStream.js";
+
+/** @typedef {import("./tokenStream.js").TokenStream} TokenStream */
+/** @typedef {import("./ast.js").Expr} Expr */
+
+/** Unprefixed names that are not function names (XPath 3.1 A.3). */
+export const RESERVED_FUNCTION_NAMES = new Set(
+  (
+    "array attribute comment document-node element empty-sequence function " +
+    "if item map namespace-node node processing-instruction schema-attribute " +
+    "schema-element switch text typeswitch"
+  ).split(" "),
+);
+
+/**
+ * PrimaryExpr: literals, variable references, parenthesized expressions,
+ * `.`, function calls and references, constructors and `?key`.
+ *
+ * @param {TokenStream} p - Tokens
+ * @returns {Expr} The expression
+ */
+export function parsePrimaryExpr(p) {
+  const token = p.peek();
+  switch (token.type) {
+    case "integer":
+    case "decimal":
+    case "double":
+      p.next();
+      return makeNode(
+        "NumericLiteral",
+        { kind: token.type, value: token.value },
+        token.start,
+        token.end,
+      );
+    case "string":
+      p.next();
+      return makeNode(
+        "StringLiteral",
+        { value: token.value },
+        token.start,
+        token.end,
+      );
+    case "name":
+      return parseNamedPrimary(p);
+  }
+  if (p.isSymbol("$")) return parseVarRef(p);
+  if (p.isSymbol("(")) return parseParenthesizedExpr(p);
+  if (p.isSymbol("[")) return parseSquareArrayConstructor(p);
+  if (p.acceptSymbol(".")) {
+    return makeNode("ContextItemExpr", {}, token.start, token.end);
+  }
+  if (p.acceptSymbol("?")) {
+    const { keyKind, key, end } = parseKeySpecifier(p);
+    return makeNode("UnaryLookup", { keyKind, key }, token.start, end);
+  }
+  return p.fail("Expected an expression");
+}
+
+/**
+ * A primary expression that starts with a name: `f#2`, `function(...)`,
+ * `map {...}`, `array {...}` or a function call. Plain names never get
+ * here: the path parser makes name tests of them.
+ *
+ * @param {TokenStream} p - Tokens
+ * @returns {Expr} The expression
+ */
+function parseNamedPrimary(p) {
+  const token = p.peek();
+  if (p.isKeyword("function") && p.isSymbol("(", 1)) {
+    return parseInlineFunctionExpr(p);
+  }
+  if (p.isSymbol("{", 1)) {
+    if (p.isKeyword("map")) return parseMapConstructor(p);
+    if (p.isKeyword("array")) return parseCurlyArrayConstructor(p);
+  }
+  if (isPlainName(token) && RESERVED_FUNCTION_NAMES.has(token.local)) {
+    p.fail("Reserved name used as a function name");
+  }
+  p.next();
+  if (p.acceptSymbol("#")) {
+    const arity = p.peek();
+    if (arity.type !== "integer") {
+      p.fail("Expected the arity, an integer literal");
+    }
+    p.next();
+    return makeNode(
+      "NamedFunctionRef",
+      { name: qName(token), arity: Number(arity.value) },
+      token.start,
+      arity.end,
+    );
+  }
+  const { arguments: args, end } = parseArgumentList(p);
+  return makeNode(
+    "FunctionCall",
+    { name: qName(token), arguments: args },
+    token.start,
+    end,
+  );
+}
+
+/**
+ * ParenthesizedExpr ::= "(" Expr? ")"; `()` gives an EmptySequence, `(E)`
+ * the node of E.
+ *
+ * @param {TokenStream} p - Tokens, at "("
+ * @returns {Expr} The expression
+ */
+export function parseParenthesizedExpr(p) {
+  const open = p.expectSymbol("(");
+  const close = p.acceptSymbol(")");
+  if (close) return makeNode("EmptySequence", {}, open.start, close.end);
+  const expr = parseExpr(p);
+  p.expectSymbol(")");
+  return expr;
+}
+
+/**
+ * VarRef ::= "$" VarName
+ *
+ * @param {TokenStream} p - Tokens, at "$"
+ * @returns {import("./ast.js").VarRef} The reference
+ */
+export function parseVarRef(p) {
+  const dollar = p.expectSymbol("$");
+  const name = p.expectName("a variable name");
+  return makeNode("VarRef", { name: qName(name) }, dollar.start, name.end);
+}

package/src/xpath/syntax/steps.js

@@ -0,0 +1,146 @@
+/**
+ * Parser of XPath 3.1 steps: productions [38] StepExpr to [52]
+ * PredicateList of Appendix A.1 (axes, abbreviations, node tests,
+ * predicates).
+ *
+ * @module @tradik/xslt3/xpath/syntax/steps
+ */
+
+import { makeNode } from "./ast.js";
+import { parseExpr } from "./expressions.js";
+import { isKindTestName, parseKindTest } from "./kindTests.js";
+import { parsePostfixExpr } from "./postfix.js";
+import { isPlainName, qName } from "./tokenStream.js";
+
+/** @typedef {import("./tokenStream.js").TokenStream} TokenStream */
+/** @typedef {import("./ast.js").Expr} Expr */
+
+/** The 13 axes of XPath 3.1, namespace included. */
+const AXES = new Set(
+  (
+    "child descendant attribute self descendant-or-self following-sibling " +
+    "following namespace parent ancestor preceding-sibling preceding " +
+    "ancestor-or-self"
+  ).split(" "),
+);
+
+/**
+ * StepExpr ::= PostfixExpr | AxisStep
+ *
+ * @param {TokenStream} p - Tokens
+ * @returns {Expr} The step
+ */
+export function parseStepExpr(p) {
+  const token = p.peek();
+  if (p.isSymbol("..")) {
+    p.next();
+    const nodeTest = makeNode("AnyKindTest", {}, token.start, token.end);
+    return finishStep(p, "parent", nodeTest, token.start);
+  }
+  if (p.isSymbol("@")) {
+    p.next();
+    return finishStep(p, "attribute", parseNodeTest(p), token.start);
+  }
+  if (token.type === "name" && p.isSymbol("::", 1)) {
+    if (!isPlainName(token) || !AXES.has(token.local)) p.fail("Unknown axis");
+    p.next();
+    p.next();
+    return finishStep(p, token.local, parseNodeTest(p), token.start);
+  }
+  if (startsNodeTest(p)) {
+    const nodeTest = parseNodeTest(p);
+    return finishStep(p, defaultAxis(nodeTest), nodeTest, token.start);
+  }
+  return parsePostfixExpr(p);
+}
+
+/**
+ * Whether an abbreviated step (no axis) starts here, rather than a primary
+ * expression such as a function call, `f#1`, `map {}` or `array {}`.
+ *
+ * @param {TokenStream} p - Tokens
+ * @returns {boolean} True for a name test, wildcard or kind test
+ */
+function startsNodeTest(p) {
+  const token = p.peek();
+  if (token.type === "wildcard" || p.isSymbol("*")) return true;
+  if (token.type !== "name") return false;
+  if (p.isSymbol("(", 1)) return isKindTestName(token);
+  if (p.isSymbol("#", 1)) return false;
+  const constructor = p.isKeyword("map") || p.isKeyword("array");
+  return !(constructor && p.isSymbol("{", 1));
+}
+
+/**
+ * Default axis of an abbreviated step (XPath 3.1 section 3.3.5).
+ *
+ * @param {import("./typeAst.js").NodeTest} nodeTest - Test of the step
+ * @returns {string} "attribute", "namespace" or "child"
+ */
+function defaultAxis(nodeTest) {
+  switch (nodeTest.type) {
+    case "AttributeTest":
+    case "SchemaAttributeTest":
+      return "attribute";
+    case "NamespaceNodeTest":
+      return "namespace";
+    default:
+      return "child";
+  }
+}
+
+/**
+ * NodeTest ::= KindTest | NameTest, NameTest being an EQName or a Wildcard.
+ *
+ * @param {TokenStream} p - Tokens
+ * @returns {import("./typeAst.js").NodeTest} The test
+ */
+function parseNodeTest(p) {
+  const token = p.peek();
+  if (token.type === "name" && p.isSymbol("(", 1) && isKindTestName(token)) {
+    return parseKindTest(p);
+  }
+  if (token.type === "wildcard" || p.isSymbol("*")) {
+    p.next();
+    const fields =
+      token.type === "wildcard"
+        ? qName(token)
+        : { prefix: null, local: null, uri: null };
+    return makeNode("Wildcard", fields, token.start, token.end);
+  }
+  const name = p.expectName("a node test");
+  return makeNode("NameTest", { name: qName(name) }, name.start, name.end);
+}
+
+/**
+ * Reads the predicates of an axis step and builds the step.
+ *
+ * @param {TokenStream} p - Tokens
+ * @param {string} axis - Axis name
+ * @param {import("./typeAst.js").NodeTest} nodeTest - Node test
+ * @param {number} start - Offset of the step
+ * @returns {import("./ast.js").AxisStep} The step
+ */
+function finishStep(p, axis, nodeTest, start) {
+  const predicates = [];
+  let end = nodeTest.end;
+  while (p.isSymbol("[")) {
+    const { predicate, end: predicateEnd } = parsePredicate(p);
+    predicates.push(predicate);
+    end = predicateEnd;
+  }
+  return makeNode("AxisStep", { axis, nodeTest, predicates }, start, end);
+}
+
+/**
+ * Predicate ::= "[" Expr "]"
+ *
+ * @param {TokenStream} p - Tokens, at "["
+ * @returns {{predicate: Expr, end: number}} The expression and the offset
+ *   after "]"
+ */
+export function parsePredicate(p) {
+  p.expectSymbol("[");
+  const predicate = parseExpr(p);
+  return { predicate, end: p.expectSymbol("]").end };
+}

package/src/xpath/syntax/syntaxError.js

@@ -0,0 +1,31 @@
+/**
+ * Construction of XPath static errors that point into the source text.
+ *
+ * @module @tradik/xslt3/xpath/syntax/syntaxError
+ */
+
+import { XPathError } from "../../errors.js";
+
+/** Characters of context shown on each side of the error offset. */
+const EXCERPT_RADIUS = 20;
+
+/**
+ * Builds an error whose message names the offset and shows the source around
+ * it, with "^" marking the offset, e.g. `... at offset 4: "1 + ^)"`.
+ *
+ * @param {string} source - The whole expression
+ * @param {number} offset - Offset (UTF-16 code units) where the problem is
+ * @param {string} message - What is wrong
+ * @param {string} [code] - Error code, XPST0003 (syntax error) by default
+ * @returns {XPathError} The error, for the caller to throw
+ */
+export function syntaxError(source, offset, message, code = "XPST0003") {
+  const from = Math.max(0, offset - EXCERPT_RADIUS);
+  const to = Math.min(source.length, offset + EXCERPT_RADIUS);
+  const before = (from > 0 ? "..." : "") + source.slice(from, offset);
+  const after = source.slice(offset, to) + (to < source.length ? "..." : "");
+  return new XPathError(
+    code,
+    `${message} at offset ${offset}: ${JSON.stringify(before + "^" + after)}`,
+  );
+}

package/src/xpath/syntax/tokenStream.js

@@ -0,0 +1,163 @@
+/**
+ * Cursor over the tokens of one expression, shared by the parser modules.
+ *
+ * Keywords are recognised here by spelling only: a keyword is an unprefixed
+ * name token without a braced URI, so `fn:div` or `Q{}div` never are.
+ *
+ * @module @tradik/xslt3/xpath/syntax/tokenStream
+ */
+
+import { tokenize } from "./lexer.js";
+import { syntaxError } from "./syntaxError.js";
+
+/**
+ * Describes a token for error messages.
+ *
+ * @param {import("./lexer.js").Token} token - Token
+ * @param {string} source - The expression
+ * @returns {string} e.g. `")"` or "end of expression"
+ */
+function describe(token, source) {
+  if (token.type === "eof") return "end of expression";
+  return JSON.stringify(source.slice(token.start, token.end));
+}
+
+/** Tokens of an expression with a read position. */
+export class TokenStream {
+  /**
+   * @param {string} source - XPath expression
+   * @param {object} [options] - Parser options (see parseXPath)
+   */
+  constructor(source, options = {}) {
+    this.source = source;
+    this.options = options;
+    this.tokens = tokenize(source);
+    this.index = 0;
+    /** Offset after the last consumed token. */
+    this.lastEnd = 0;
+  }
+
+  /**
+   * @param {number} [ahead] - 0 for the current token, 1 for the next...
+   * @returns {import("./lexer.js").Token} The token (eof past the end)
+   */
+  peek(ahead = 0) {
+    const last = this.tokens.length - 1;
+    return this.tokens[Math.min(this.index + ahead, last)];
+  }
+
+  /** @returns {import("./lexer.js").Token} The current token, consumed. */
+  next() {
+    const token = this.peek();
+    if (token.type !== "eof") this.index++;
+    this.lastEnd = token.end;
+    return token;
+  }
+
+  /**
+   * @param {string} value - Symbol, e.g. "("
+   * @param {number} [ahead] - Lookahead distance
+   * @returns {boolean} Whether that token is the symbol
+   */
+  isSymbol(value, ahead = 0) {
+    const token = this.peek(ahead);
+    return token.type === "symbol" && token.value === value;
+  }
+
+  /**
+   * @param {string} word - Keyword, e.g. "div"
+   * @param {number} [ahead] - Lookahead distance
+   * @returns {boolean} Whether that token is the keyword
+   */
+  isKeyword(word, ahead = 0) {
+    const token = this.peek(ahead);
+    return isPlainName(token) && token.local === word;
+  }
+
+  /**
+   * Consumes the current token when it is the symbol.
+   *
+   * @param {string} value - Symbol
+   * @returns {import("./lexer.js").Token|null} The token, or null
+   */
+  acceptSymbol(value) {
+    return this.isSymbol(value) ? this.next() : null;
+  }
+
+  /**
+   * Consumes the current token when it is the keyword.
+   *
+   * @param {string} word - Keyword
+   * @returns {import("./lexer.js").Token|null} The token, or null
+   */
+  acceptKeyword(word) {
+    return this.isKeyword(word) ? this.next() : null;
+  }
+
+  /**
+   * Consumes the symbol or fails.
+   *
+   * @param {string} value - Expected symbol
+   * @returns {import("./lexer.js").Token} The token
+   */
+  expectSymbol(value) {
+    return this.acceptSymbol(value) ?? this.fail(`Expected "${value}"`);
+  }
+
+  /**
+   * Consumes the keyword or fails.
+   *
+   * @param {string} word - Expected keyword
+   * @returns {import("./lexer.js").Token} The token
+   */
+  expectKeyword(word) {
+    return this.acceptKeyword(word) ?? this.fail(`Expected "${word}"`);
+  }
+
+  /**
+   * Consumes a name token (NCName, QName or EQName) or fails.
+   *
+   * @param {string} [what] - What the name is, for the message
+   * @returns {import("./lexer.js").Token} The token
+   */
+  expectName(what = "a name") {
+    if (this.peek().type !== "name") this.fail(`Expected ${what}`);
+    return this.next();
+  }
+
+  /**
+   * Throws XPST0003 (or another code) at the current token.
+   *
+   * @param {string} message - What was expected
+   * @param {import("./lexer.js").Token} [token] - Offending token
+   * @param {string} [code] - Error code
+   * @returns {never}
+   */
+  fail(message, token = this.peek(), code = undefined) {
+    const found = describe(token, this.source);
+    throw syntaxError(
+      this.source,
+      token.start,
+      `${message}, found ${found}`,
+      code,
+    );
+  }
+}
+
+/**
+ * @param {import("./lexer.js").Token} token - Token
+ * @returns {boolean} Whether it is a name without prefix and braced URI
+ */
+export function isPlainName(token) {
+  return token.type === "name" && token.prefix === null && token.uri === null;
+}
+
+/**
+ * The QName fields of a name or wildcard token, as kept in the AST.
+ *
+ * @param {import("./lexer.js").Token} token - Name token
+ * @returns {import("./ast.js").QName} `{ prefix, local, uri }`
+ */
+export function qName(token) {
+  return { prefix: token.prefix, local: token.local, uri: token.uri };
+}

package/src/xpath/syntax/typeAst.js

@@ -0,0 +1,76 @@
+/**
+ * The XPath 3.1 abstract syntax tree: node tests, item types and sequence
+ * types. Same conventions as ast.js (`{ type, ...fields, start, end }`).
+ * This module holds type definitions only.
+ *
+ * @module @tradik/xslt3/xpath/syntax/typeAst
+ */
+
+/** @typedef {import("./ast.js").QName} QName */
+
+/**
+ * `ItemType occurrence`; `itemType` null means `empty-sequence()`.
+ * `occurrence` is "" (exactly one), "?", "*" or "+".
+ *
+ * @typedef {{type: "SequenceType", itemType: ItemType|null, occurrence: ""|"?"|"*"|"+", start: number, end: number}} SequenceType
+ */
+
+/**
+ * Any item type. A parenthesized item type `(T)` leaves no node.
+ *
+ * @typedef {KindTest|AnyItemTest|AtomicType|AnyFunctionTest|TypedFunctionTest|
+ *   AnyMapTest|TypedMapTest|AnyArrayTest|TypedArrayTest} ItemType
+ */
+
+/** @typedef {NameTest|Wildcard|KindTest} NodeTest Test of an axis step */
+
+/**
+ * @typedef {AnyKindTest|DocumentTest|ElementTest|AttributeTest|
+ *   SchemaElementTest|SchemaAttributeTest|PITest|CommentTest|TextTest|
+ *   NamespaceNodeTest} KindTest
+ */
+
+/** @typedef {{type: "NameTest", name: QName, start: number, end: number}} NameTest */
+
+/**
+ * Wildcard name test: `*` (all fields null), `prefix:*` (prefix set),
+ * `*:local` (local set) or `Q{uri}*` (uri set, possibly "").
+ *
+ * @typedef {{type: "Wildcard", prefix: string|null, local: string|null, uri: string|null, start: number, end: number}} Wildcard
+ */
+
+/** @typedef {{type: "AnyKindTest", start: number, end: number}} AnyKindTest `node()` */
+/** @typedef {{type: "DocumentTest", elementTest: ElementTest|SchemaElementTest|null, start: number, end: number}} DocumentTest `document-node(...)` */
+
+/**
+ * `element()`, `element(name)`, `element(*, type)`, `element(name, type?)`.
+ * `name` null stands for `*` (or no name), `typeName` null for no type;
+ * `nillable` is true for the trailing `?`.
+ *
+ * @typedef {{type: "ElementTest", name: QName|null, typeName: QName|null, nillable: boolean, start: number, end: number}} ElementTest
+ */
+
+/** @typedef {{type: "AttributeTest", name: QName|null, typeName: QName|null, start: number, end: number}} AttributeTest `attribute(name-or-*, type)` */
+/** @typedef {{type: "SchemaElementTest", name: QName, start: number, end: number}} SchemaElementTest */
+/** @typedef {{type: "SchemaAttributeTest", name: QName, start: number, end: number}} SchemaAttributeTest */
+
+/**
+ * `processing-instruction(target)`; a string literal target is stored
+ * whitespace-normalized; null when there is no target.
+ *
+ * @typedef {{type: "PITest", target: string|null, start: number, end: number}} PITest
+ */
+
+/** @typedef {{type: "CommentTest", start: number, end: number}} CommentTest `comment()` */
+/** @typedef {{type: "TextTest", start: number, end: number}} TextTest `text()` */
+/** @typedef {{type: "NamespaceNodeTest", start: number, end: number}} NamespaceNodeTest `namespace-node()` */
+/** @typedef {{type: "AnyItemTest", start: number, end: number}} AnyItemTest `item()` */
+/** @typedef {{type: "AtomicType", name: QName, start: number, end: number}} AtomicType AtomicOrUnionType, e.g. `xs:integer` */
+/** @typedef {{type: "AnyFunctionTest", start: number, end: number}} AnyFunctionTest `function(*)` */
+/** @typedef {{type: "TypedFunctionTest", paramTypes: SequenceType[], returnType: SequenceType, start: number, end: number}} TypedFunctionTest `function(T1, T2) as R` */
+/** @typedef {{type: "AnyMapTest", start: number, end: number}} AnyMapTest `map(*)` */
+/** @typedef {{type: "TypedMapTest", keyType: AtomicType, valueType: SequenceType, start: number, end: number}} TypedMapTest `map(K, V)` */
+/** @typedef {{type: "AnyArrayTest", start: number, end: number}} AnyArrayTest `array(*)` */
+/** @typedef {{type: "TypedArrayTest", memberType: SequenceType, start: number, end: number}} TypedArrayTest `array(T)` */
+
+export {};