@matdata/sparql-formatter 1.0.0

package/dist/cli.js

@@ -0,0 +1,2621 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { readFileSync, writeFileSync } from "node:fs";
+import { parseArgs } from "node:util";
+
+// src/errors.ts
+var SparqlSyntaxError = class extends Error {
+  constructor(message, offset, line, column, expected = []) {
+    super(`${message} (line ${line}, column ${column})`);
+    this.name = "SparqlSyntaxError";
+    this.offset = offset;
+    this.line = line;
+    this.column = column;
+    this.expected = expected;
+  }
+};
+
+// src/lexer.ts
+var PN_CHARS_BASE = "A-Za-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}";
+var PN_CHARS_U = PN_CHARS_BASE + "_";
+var PN_CHARS = PN_CHARS_U + "\\-0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040";
+var PLX = "%[0-9A-Fa-f]{2}|\\\\[_~.\\-!$&'()*+,;=/?#@%]";
+var PN_PREFIX = `[${PN_CHARS_BASE}](?:[${PN_CHARS}.]*[${PN_CHARS}])?`;
+var PN_LOCAL = `(?:[${PN_CHARS_U}:0-9]|${PLX})(?:(?:[${PN_CHARS}.:]|${PLX})*(?:[${PN_CHARS}:]|${PLX}))?`;
+var RE_PNAME = new RegExp(`(?:${PN_PREFIX})?:(?:${PN_LOCAL})?`, "uy");
+var RE_VAR = new RegExp(`[?$][${PN_CHARS_U}0-9][${PN_CHARS_U}0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040]*`, "uy");
+var RE_BNODE = new RegExp(`_:[${PN_CHARS_U}0-9](?:[${PN_CHARS}.]*[${PN_CHARS}])?`, "uy");
+var RE_IRIREF = /<(?:[^<>"{}|^`\\\u0000- ]|\\u[0-9A-Fa-f]{4}|\\U[0-9A-Fa-f]{8})*>/y;
+var RE_LANG_DIR = /@[a-zA-Z]+(?:-[a-zA-Z0-9]+)*(?:--[a-zA-Z]+)?/y;
+var RE_DOUBLE = /(?:[0-9]+(?:\.[0-9]*)?|\.[0-9]+)[eE][+-]?[0-9]+/y;
+var RE_DECIMAL = /[0-9]*\.[0-9]+/y;
+var RE_INTEGER = /[0-9]+/y;
+var RE_NAME = /[A-Za-z_][A-Za-z0-9_]*/y;
+var ECHAR_UCHAR = String.raw`\\[tbnrf\\"']|\\u[0-9A-Fa-f]{4}|\\U[0-9A-Fa-f]{8}`;
+var RE_STRING_LONG1 = new RegExp(String.raw`'''(?:(?:'|'')?(?:[^'\\]|${ECHAR_UCHAR}))*'''`, "y");
+var RE_STRING_LONG2 = new RegExp(String.raw`"""(?:(?:"|"")?(?:[^"\\]|${ECHAR_UCHAR}))*"""`, "y");
+var RE_STRING1 = new RegExp(String.raw`'(?:[^'\\\n\r]|${ECHAR_UCHAR})*'`, "y");
+var RE_STRING2 = new RegExp(String.raw`"(?:[^"\\\n\r]|${ECHAR_UCHAR})*"`, "y");
+var RE_SURROGATE_ESCAPE = /\\(?:u|U0000)[dD][89a-fA-F][0-9a-fA-F]{2}/;
+var PUNCTUATION = [
+  "<<(",
+  ")>>",
+  "<<",
+  ">>",
+  "{|",
+  "|}",
+  "^^",
+  "&&",
+  "||",
+  "!=",
+  "<=",
+  ">=",
+  "{",
+  "}",
+  "(",
+  ")",
+  "[",
+  "]",
+  ".",
+  ",",
+  ";",
+  "*",
+  "/",
+  "|",
+  "^",
+  "?",
+  "+",
+  "-",
+  "!",
+  "=",
+  "<",
+  ">",
+  "~"
+];
+function match(re, input, pos) {
+  re.lastIndex = pos;
+  const m = re.exec(input);
+  return m ? m[0] : null;
+}
+function tokenize(input) {
+  const tokens = [];
+  let pos = 0;
+  let line = 1;
+  let lineStart = 0;
+  let pendingComments = [];
+  let newlinesSinceLast = 0;
+  let sawSpace = false;
+  let prevToken = null;
+  let prevTokenLine = -1;
+  const advanceLines = (from, to) => {
+    for (let i = from; i < to; i++) {
+      const c = input.charCodeAt(i);
+      if (c === 10 || c === 13 && input.charCodeAt(i + 1) !== 10) {
+        line++;
+        lineStart = i + 1;
+      }
+    }
+  };
+  const error = (message) => {
+    throw new SparqlSyntaxError(message, pos, line, pos - lineStart + 1);
+  };
+  while (pos < input.length) {
+    const ch = input[pos];
+    if (ch === " " || ch === "	" || ch === "\r" || ch === "\n") {
+      if (ch === "\n" || ch === "\r" && input[pos + 1] !== "\n") {
+        newlinesSinceLast++;
+        line++;
+        lineStart = pos + 1;
+      }
+      sawSpace = true;
+      pos++;
+      continue;
+    }
+    if (ch === "#") {
+      let end = pos;
+      while (end < input.length && input[end] !== "\n" && input[end] !== "\r") end++;
+      const comment = {
+        text: input.slice(pos, end).replace(/\s+$/, ""),
+        offset: pos,
+        line,
+        column: pos - lineStart + 1,
+        blankLinesBefore: Math.max(0, newlinesSinceLast - 1)
+      };
+      if (prevToken && prevTokenLine === line && pendingComments.length === 0 && !prevToken.trailing) {
+        prevToken.trailing = comment;
+      } else {
+        pendingComments.push(comment);
+      }
+      newlinesSinceLast = 0;
+      sawSpace = true;
+      pos = end;
+      continue;
+    }
+    const startLine = line;
+    const startColumn = pos - lineStart + 1;
+    let type;
+    let value = null;
+    if (ch === "<") {
+      if (input.startsWith("<<(", pos)) {
+        type = "PUNCT";
+        value = "<<(";
+      } else if (input.startsWith("<<", pos)) {
+        type = "PUNCT";
+        value = "<<";
+      } else if (value = match(RE_IRIREF, input, pos)) {
+        type = "IRIREF";
+      } else {
+        type = "PUNCT";
+        value = input.startsWith("<=", pos) ? "<=" : "<";
+      }
+    } else if (ch === "?" || ch === "$") {
+      value = match(RE_VAR, input, pos);
+      if (value) {
+        type = "VAR";
+      } else if (ch === "?") {
+        type = "PUNCT";
+        value = "?";
+      } else {
+        return error("Invalid variable name");
+      }
+    } else if (ch === '"' || ch === "'") {
+      value = ch === '"' ? match(RE_STRING_LONG2, input, pos) ?? match(RE_STRING2, input, pos) : match(RE_STRING_LONG1, input, pos) ?? match(RE_STRING1, input, pos);
+      if (!value) return error("Unterminated or invalid string literal");
+      type = "STRING";
+    } else if (ch === "@") {
+      value = match(RE_LANG_DIR, input, pos);
+      if (!value) return error("Invalid language tag");
+      type = "LANG_DIR";
+    } else if (ch === "_" && input[pos + 1] === ":") {
+      value = match(RE_BNODE, input, pos);
+      if (!value) return error("Invalid blank node label");
+      type = "BLANK_NODE_LABEL";
+    } else if (ch >= "0" && ch <= "9" || ch === "." && /[0-9]/.test(input[pos + 1] ?? "")) {
+      if (value = match(RE_DOUBLE, input, pos)) type = "DOUBLE";
+      else if (value = match(RE_DECIMAL, input, pos)) type = "DECIMAL";
+      else {
+        value = match(RE_INTEGER, input, pos);
+        type = "INTEGER";
+      }
+    } else {
+      const pname = match(RE_PNAME, input, pos);
+      if (pname) {
+        value = pname;
+        type = pname.endsWith(":") && pname.indexOf(":") === pname.length - 1 ? "PNAME_NS" : "PNAME_LN";
+      } else if (value = match(RE_NAME, input, pos)) {
+        type = "NAME";
+      } else {
+        value = PUNCTUATION.find((p) => input.startsWith(p, pos)) ?? null;
+        if (!value) return error(`Unexpected character '${String.fromCodePoint(input.codePointAt(pos))}'`);
+        type = "PUNCT";
+      }
+    }
+    if ((type === "STRING" || type === "IRIREF") && RE_SURROGATE_ESCAPE.test(value)) {
+      return error("Escape sequences for surrogate code points (U+D800 to U+DFFF) are not allowed");
+    }
+    const token = {
+      type,
+      value,
+      offset: pos,
+      end: pos + value.length,
+      line: startLine,
+      column: startColumn,
+      index: tokens.length,
+      leading: pendingComments,
+      trailing: null,
+      blankLinesBefore: Math.max(0, newlinesSinceLast - 1),
+      spaceBefore: sawSpace
+    };
+    tokens.push(token);
+    advanceLines(pos, token.end);
+    pos = token.end;
+    prevToken = token;
+    prevTokenLine = line;
+    pendingComments = [];
+    newlinesSinceLast = 0;
+    sawSpace = false;
+  }
+  tokens.push({
+    type: "EOF",
+    value: "",
+    offset: input.length,
+    end: input.length,
+    line,
+    column: input.length - lineStart + 1,
+    index: tokens.length,
+    leading: pendingComments,
+    trailing: null,
+    blankLinesBefore: Math.max(0, newlinesSinceLast - 1),
+    spaceBefore: sawSpace
+  });
+  return tokens;
+}
+
+// src/parser.ts
+var BUILTINS = /* @__PURE__ */ new Set([
+  "COUNT",
+  "SUM",
+  "MIN",
+  "MAX",
+  "AVG",
+  "SAMPLE",
+  "GROUP_CONCAT",
+  "STR",
+  "LANG",
+  "LANGMATCHES",
+  "LANGDIR",
+  "DATATYPE",
+  "BOUND",
+  "IRI",
+  "URI",
+  "BNODE",
+  "RAND",
+  "ABS",
+  "CEIL",
+  "FLOOR",
+  "ROUND",
+  "CONCAT",
+  "SUBSTR",
+  "STRLEN",
+  "REPLACE",
+  "UCASE",
+  "LCASE",
+  "ENCODE_FOR_URI",
+  "CONTAINS",
+  "STRSTARTS",
+  "STRENDS",
+  "STRBEFORE",
+  "STRAFTER",
+  "YEAR",
+  "MONTH",
+  "DAY",
+  "HOURS",
+  "MINUTES",
+  "SECONDS",
+  "TIMEZONE",
+  "TZ",
+  "NOW",
+  "UUID",
+  "STRUUID",
+  "MD5",
+  "SHA1",
+  "SHA256",
+  "SHA384",
+  "SHA512",
+  "COALESCE",
+  "IF",
+  "STRLANG",
+  "STRLANGDIR",
+  "STRDT",
+  "SAMETERM",
+  "ISIRI",
+  "ISURI",
+  "ISBLANK",
+  "ISLITERAL",
+  "ISNUMERIC",
+  "HASLANG",
+  "HASLANGDIR",
+  "REGEX",
+  "ISTRIPLE",
+  "TRIPLE",
+  "SUBJECT",
+  "PREDICATE",
+  "OBJECT"
+]);
+var AGGREGATES = /* @__PURE__ */ new Set(["COUNT", "SUM", "MIN", "MAX", "AVG", "SAMPLE", "GROUP_CONCAT"]);
+var NO_ARGS = /* @__PURE__ */ new Set(["RAND", "NOW", "UUID", "STRUUID"]);
+var ARITY = {
+  LANGMATCHES: [2, 2],
+  CONTAINS: [2, 2],
+  STRSTARTS: [2, 2],
+  STRENDS: [2, 2],
+  STRBEFORE: [2, 2],
+  STRAFTER: [2, 2],
+  STRLANG: [2, 2],
+  STRDT: [2, 2],
+  SAMETERM: [2, 2],
+  IF: [3, 3],
+  STRLANGDIR: [3, 3],
+  TRIPLE: [3, 3],
+  REGEX: [2, 3],
+  SUBSTR: [2, 3],
+  REPLACE: [3, 4],
+  CONCAT: [0, Infinity],
+  COALESCE: [0, Infinity],
+  BNODE: [0, 1]
+};
+var QUERY_FORMS = /* @__PURE__ */ new Set(["SELECT", "CONSTRUCT", "DESCRIBE", "ASK"]);
+var UPDATE_KEYWORDS = /* @__PURE__ */ new Set(["LOAD", "CLEAR", "DROP", "CREATE", "ADD", "MOVE", "COPY", "INSERT", "DELETE", "WITH"]);
+function parse(input) {
+  return new Parser(tokenize(input)).parseUnit();
+}
+var Parser = class {
+  constructor(tokens) {
+    this.pos = 0;
+    this.tokens = tokens;
+  }
+  // -------------------------------------------------------------------------
+  // Token helpers
+  // -------------------------------------------------------------------------
+  peek(offset = 0) {
+    return this.tokens[Math.min(this.pos + offset, this.tokens.length - 1)];
+  }
+  next() {
+    const t = this.tokens[this.pos];
+    if (t.type !== "EOF") this.pos++;
+    return t;
+  }
+  /** Is the token the given keyword (case-insensitive)? */
+  isKw(t, ...keywords) {
+    return t.type === "NAME" && keywords.includes(t.value.toUpperCase());
+  }
+  isPunct(t, ...values) {
+    return t.type === "PUNCT" && values.includes(t.value);
+  }
+  fail(t, expected) {
+    const found = t.type === "EOF" ? "end of input" : `'${t.value}'`;
+    throw new SparqlSyntaxError(`Expected ${expected} but found ${found}`, t.offset, t.line, t.column, [expected]);
+  }
+  expectKw(keyword) {
+    const t = this.peek();
+    if (!this.isKw(t, keyword)) this.fail(t, keyword);
+    return this.next();
+  }
+  expectPunct(value) {
+    const t = this.peek();
+    if (!this.isPunct(t, value)) this.fail(t, `'${value}'`);
+    return this.next();
+  }
+  optKw(...keywords) {
+    return this.isKw(this.peek(), ...keywords) ? this.next() : null;
+  }
+  optPunct(value) {
+    return this.isPunct(this.peek(), value) ? this.next() : null;
+  }
+  term(...tokens) {
+    return { type: "Term", tokens };
+  }
+  /** `(` directly followed by `)` (NIL) or `[` followed by `]` (ANON). */
+  isEmptyPair(open, close) {
+    return this.isPunct(this.peek(), open) && this.isPunct(this.peek(1), close);
+  }
+  // -------------------------------------------------------------------------
+  // Units
+  // -------------------------------------------------------------------------
+  parseUnit() {
+    const start = this.pos;
+    const prologue = this.parsePrologue();
+    if (QUERY_FORMS.has(this.peek().type === "NAME" ? this.peek().value.toUpperCase() : "")) {
+      const form = this.parseQueryForm();
+      const values = this.isKw(this.peek(), "VALUES") ? this.parseValues() : null;
+      const eof = this.peek();
+      if (eof.type !== "EOF") this.fail(eof, "end of query");
+      return { type: "Query", prologue, form, values, eof };
+    }
+    this.pos = start;
+    return this.parseUpdate();
+  }
+  parsePrologue() {
+    const decls = [];
+    for (; ; ) {
+      const t = this.peek();
+      if (this.isKw(t, "BASE")) {
+        const keyword = this.next();
+        const value = this.next();
+        if (value.type !== "IRIREF") this.fail(value, "an IRI");
+        decls.push({ type: "Base", keyword, prefix: null, value });
+      } else if (this.isKw(t, "PREFIX")) {
+        const keyword = this.next();
+        const prefix = this.next();
+        if (prefix.type !== "PNAME_NS") this.fail(prefix, "a prefix name such as 'ex:'");
+        const value = this.next();
+        if (value.type !== "IRIREF") this.fail(value, "an IRI");
+        decls.push({ type: "Prefix", keyword, prefix, value });
+      } else if (this.isKw(t, "VERSION")) {
+        const keyword = this.next();
+        const value = this.next();
+        if (value.type !== "STRING" || value.value.startsWith("'''") || value.value.startsWith('"""')) {
+          this.fail(value, "a version string");
+        }
+        decls.push({ type: "Version", keyword, prefix: null, value });
+      } else {
+        return decls;
+      }
+    }
+  }
+  parseQueryForm() {
+    const t = this.peek();
+    switch (t.value.toUpperCase()) {
+      case "SELECT":
+        return this.parseSelect();
+      case "CONSTRUCT":
+        return this.parseConstruct();
+      case "DESCRIBE":
+        return this.parseDescribe();
+      default:
+        return this.parseAsk();
+    }
+  }
+  parseSelectClause() {
+    const keyword = this.expectKw("SELECT");
+    const modifier = this.optKw("DISTINCT", "REDUCED");
+    const star = this.optPunct("*");
+    const items = [];
+    if (!star) {
+      for (; ; ) {
+        const t = this.peek();
+        if (t.type === "VAR") {
+          items.push(this.term(this.next()));
+        } else if (this.isPunct(t, "(")) {
+          const open = this.next();
+          const expression = this.parseExpression();
+          const as = this.expectKw("AS");
+          const variable = this.parseVar();
+          const close = this.expectPunct(")");
+          items.push({ type: "Projection", open, expression, as, variable, close });
+        } else {
+          break;
+        }
+      }
+      if (items.length === 0) this.fail(this.peek(), "'*', a variable or '(' after SELECT");
+    }
+    return { type: "SelectClause", keyword, modifier, star, items };
+  }
+  parseSelect() {
+    const select = this.parseSelectClause();
+    const datasets = this.parseDatasets();
+    const where = this.parseWhereClause(true);
+    const modifiers = this.parseSolutionModifier();
+    return { type: "Select", select, datasets, where, modifiers };
+  }
+  parseSubSelect() {
+    const select = this.parseSelectClause();
+    const where = this.parseWhereClause(true);
+    const modifiers = this.parseSolutionModifier();
+    const values = this.isKw(this.peek(), "VALUES") ? this.parseValues() : null;
+    return { type: "SubSelect", select, datasets: [], where, modifiers, values };
+  }
+  parseConstruct() {
+    const keyword = this.expectKw("CONSTRUCT");
+    if (this.isPunct(this.peek(), "{")) {
+      const template2 = this.parseTriplesTemplate(false);
+      const datasets2 = this.parseDatasets();
+      const where = this.parseWhereClause(true);
+      const modifiers2 = this.parseSolutionModifier();
+      return { type: "Construct", keyword, template: template2, datasets: datasets2, where, shortForm: null, modifiers: modifiers2 };
+    }
+    const datasets = this.parseDatasets();
+    const whereKw = this.expectKw("WHERE");
+    const template = this.parseTriplesTemplate(false);
+    const modifiers = this.parseSolutionModifier();
+    return {
+      type: "Construct",
+      keyword,
+      template: null,
+      datasets,
+      where: null,
+      shortForm: { keyword: whereKw, template },
+      modifiers
+    };
+  }
+  parseDescribe() {
+    const keyword = this.expectKw("DESCRIBE");
+    const star = this.optPunct("*");
+    const items = [];
+    if (!star) {
+      while (this.isVarOrIri(this.peek())) items.push(this.term(this.next()));
+      if (items.length === 0) this.fail(this.peek(), "'*', a variable or an IRI after DESCRIBE");
+    }
+    const datasets = this.parseDatasets();
+    const where = this.isKw(this.peek(), "WHERE") || this.isPunct(this.peek(), "{") ? this.parseWhereClause(true) : null;
+    const modifiers = this.parseSolutionModifier();
+    return { type: "Describe", keyword, star, items, datasets, where, modifiers };
+  }
+  parseAsk() {
+    const keyword = this.expectKw("ASK");
+    const datasets = this.parseDatasets();
+    const where = this.parseWhereClause(true);
+    const modifiers = this.parseSolutionModifier();
+    return { type: "Ask", keyword, datasets, where, modifiers };
+  }
+  parseDatasets() {
+    const datasets = [];
+    while (this.isKw(this.peek(), "FROM")) {
+      const from = this.next();
+      const named = this.optKw("NAMED");
+      datasets.push({ type: "DatasetClause", from, named, iri: this.parseIri() });
+    }
+    return datasets;
+  }
+  parseWhereClause(optionalKeyword) {
+    const keyword = optionalKeyword ? this.optKw("WHERE") : this.expectKw("WHERE");
+    return { keyword, group: this.parseGroupGraphPattern() };
+  }
+  parseSolutionModifier() {
+    const modifiers = { groupBy: null, having: null, orderBy: null, limitOffset: [] };
+    if (this.isKw(this.peek(), "GROUP")) {
+      const group = this.next();
+      const by = this.expectKw("BY");
+      const conditions = [];
+      while (this.startsCondition(this.peek())) {
+        if (this.isPunct(this.peek(), "(")) {
+          const open = this.next();
+          const expression = this.parseExpression();
+          const as = this.optKw("AS");
+          const variable = as ? this.parseVar() : null;
+          const close = this.expectPunct(")");
+          conditions.push({ type: "Projection", open, expression, as, variable, close });
+        } else if (this.peek().type === "VAR") {
+          conditions.push(this.term(this.next()));
+        } else {
+          conditions.push(this.parseConstraint());
+        }
+      }
+      if (conditions.length === 0) this.fail(this.peek(), "a GROUP BY condition");
+      modifiers.groupBy = { group, by, conditions };
+    }
+    if (this.isKw(this.peek(), "HAVING")) {
+      const keyword = this.next();
+      const conditions = [];
+      while (this.startsCondition(this.peek()) && this.peek().type !== "VAR") {
+        conditions.push(this.parseConstraint());
+      }
+      if (conditions.length === 0) this.fail(this.peek(), "a HAVING condition");
+      modifiers.having = { keyword, conditions };
+    }
+    if (this.isKw(this.peek(), "ORDER")) {
+      const order = this.next();
+      const by = this.expectKw("BY");
+      const conditions = [];
+      for (; ; ) {
+        const t = this.peek();
+        if (this.isKw(t, "ASC", "DESC")) {
+          const direction = this.next();
+          conditions.push({ type: "OrderCondition", direction, expression: this.parseBracketed() });
+        } else if (t.type === "VAR") {
+          conditions.push(this.term(this.next()));
+        } else if (this.startsCondition(t)) {
+          conditions.push(this.parseConstraint());
+        } else {
+          break;
+        }
+      }
+      if (conditions.length === 0) this.fail(this.peek(), "an ORDER BY condition");
+      modifiers.orderBy = { order, by, conditions };
+    }
+    const first = this.optKw("LIMIT", "OFFSET");
+    if (first) {
+      modifiers.limitOffset.push({ keyword: first, value: this.parseInteger() });
+      const second = this.optKw(this.isKw(first, "LIMIT") ? "OFFSET" : "LIMIT");
+      if (second) modifiers.limitOffset.push({ keyword: second, value: this.parseInteger() });
+    }
+    return modifiers;
+  }
+  parseInteger() {
+    const t = this.peek();
+    if (t.type !== "INTEGER") this.fail(t, "an integer");
+    return this.next();
+  }
+  /** Can this token start a GROUP BY / HAVING / ORDER BY condition? */
+  startsCondition(t) {
+    return t.type === "VAR" || this.isPunct(t, "(") || t.type === "IRIREF" || t.type === "PNAME_LN" || t.type === "PNAME_NS" || t.type === "NAME" && (BUILTINS.has(t.value.toUpperCase()) || this.isKw(t, "EXISTS", "NOT"));
+  }
+  /** Constraint: BrackettedExpression | BuiltInCall | FunctionCall */
+  parseConstraint() {
+    const t = this.peek();
+    if (this.isPunct(t, "(")) return this.parseBracketed();
+    if (t.type === "NAME") return this.parseBuiltInCall();
+    if (t.type === "IRIREF" || t.type === "PNAME_LN" || t.type === "PNAME_NS") {
+      const iri = this.parseIri();
+      if (!this.isPunct(this.peek(), "(")) this.fail(this.peek(), "'(' of a function call");
+      return this.parseArgList(iri, false);
+    }
+    return this.fail(t, "'(', a built-in call or a function call");
+  }
+  // -------------------------------------------------------------------------
+  // Updates
+  // -------------------------------------------------------------------------
+  parseUpdate() {
+    const parts = [];
+    for (; ; ) {
+      const prologue = this.parsePrologue();
+      const t = this.peek();
+      let operation = null;
+      if (t.type === "NAME" && UPDATE_KEYWORDS.has(t.value.toUpperCase())) {
+        operation = this.parseUpdateOperation();
+      } else if (t.type !== "EOF") {
+        this.fail(t, parts.length === 0 && prologue.length === 0 ? "a query or update" : "an update operation");
+      }
+      const semicolon = operation ? this.optPunct(";") : null;
+      parts.push({ prologue, operation, semicolon });
+      if (!semicolon) break;
+    }
+    const eof = this.peek();
+    if (eof.type !== "EOF") this.fail(eof, "';' or end of update");
+    return { type: "Update", parts, eof };
+  }
+  parseUpdateOperation() {
+    const t = this.peek();
+    const kw = t.value.toUpperCase();
+    switch (kw) {
+      case "LOAD": {
+        const keyword = this.next();
+        const silent = this.optKw("SILENT");
+        const iri = this.parseIri();
+        let into = null;
+        if (this.isKw(this.peek(), "INTO")) {
+          const intoKw = this.next();
+          const graph = this.expectKw("GRAPH");
+          into = { type: "Words", tokens: [intoKw, graph, this.parseIri()] };
+        }
+        return { type: "Load", keyword, silent, iri, into };
+      }
+      case "CLEAR":
+      case "DROP":
+      case "CREATE": {
+        const keyword = this.next();
+        const silent = this.optKw("SILENT");
+        let target;
+        if (kw !== "CREATE" && this.isKw(this.peek(), "DEFAULT", "NAMED", "ALL")) {
+          target = { type: "Words", tokens: [this.next()] };
+        } else {
+          const graph = this.expectKw("GRAPH");
+          target = { type: "Words", tokens: [graph, this.parseIri()] };
+        }
+        return { type: "GraphManagement", keyword, silent, target };
+      }
+      case "ADD":
+      case "MOVE":
+      case "COPY": {
+        const keyword = this.next();
+        const silent = this.optKw("SILENT");
+        const from = this.parseGraphOrDefault();
+        const to = this.expectKw("TO");
+        const target = this.parseGraphOrDefault();
+        return { type: "GraphTransfer", keyword, silent, from, to, target };
+      }
+      case "INSERT": {
+        if (this.isKw(this.peek(1), "DATA")) {
+          const keywords = [this.next(), this.next()];
+          return { type: "QuadData", keywords, quads: this.checkQuads(this.parseQuads(), true, false) };
+        }
+        return this.parseModify();
+      }
+      case "DELETE": {
+        if (this.isKw(this.peek(1), "DATA", "WHERE")) {
+          const keywords = [this.next(), this.next()];
+          const noVars = this.isKw(keywords[1], "DATA");
+          return { type: "QuadData", keywords, quads: this.checkQuads(this.parseQuads(), noVars, true) };
+        }
+        return this.parseModify();
+      }
+      default:
+        return this.parseModify();
+    }
+  }
+  parseGraphOrDefault() {
+    if (this.isKw(this.peek(), "DEFAULT")) return { type: "Words", tokens: [this.next()] };
+    const graph = this.optKw("GRAPH");
+    const iri = this.parseIri();
+    return { type: "Words", tokens: graph ? [graph, iri] : [iri] };
+  }
+  parseModify() {
+    let withClause = null;
+    if (this.isKw(this.peek(), "WITH")) {
+      const keyword = this.next();
+      withClause = { keyword, iri: this.parseIri() };
+    }
+    let del = null;
+    let ins = null;
+    if (this.isKw(this.peek(), "DELETE")) {
+      const keyword = this.next();
+      del = { keyword, quads: this.checkQuads(this.parseQuads(), false, true) };
+    }
+    if (this.isKw(this.peek(), "INSERT")) {
+      const keyword = this.next();
+      ins = { keyword, quads: this.parseQuads() };
+    }
+    if (!del && !ins) this.fail(this.peek(), "DELETE or INSERT");
+    const using = [];
+    while (this.isKw(this.peek(), "USING")) {
+      const keyword = this.next();
+      const named = this.optKw("NAMED");
+      using.push({ keyword, named, iri: this.parseIri() });
+    }
+    const where = this.parseWhereClause(false);
+    return { type: "Modify", with: withClause, delete: del, insert: ins, using, where };
+  }
+  /** `{ TriplesTemplate? }` of CONSTRUCT and of `GRAPH x { }` in quads */
+  parseTriplesTemplate(path) {
+    const open = this.expectPunct("{");
+    const items = [];
+    while (!this.isPunct(this.peek(), "}")) {
+      if (!this.startsTriples(this.peek())) this.fail(this.peek(), "a triple pattern or '}'");
+      const node = this.parseTriplesSameSubject(path);
+      const dot = this.optPunct(".");
+      items.push({ node, dot });
+      if (!dot && !this.isPunct(this.peek(), "}")) this.fail(this.peek(), "'.' or '}'");
+    }
+    const close = this.next();
+    return { type: "TriplesTemplate", open, items, close };
+  }
+  /**
+   * Notes 8 and 9 of the grammar: no variables in INSERT DATA / DELETE DATA,
+   * no blank nodes in DELETE DATA, DELETE WHERE and DELETE templates.
+   */
+  checkQuads(quads, noVars, noBlankNodes) {
+    const reject = (t, what) => {
+      throw new SparqlSyntaxError(`${what} are not allowed here`, t.offset, t.line, t.column);
+    };
+    const visit = (value) => {
+      if (value === null || typeof value !== "object") return;
+      if (Array.isArray(value)) {
+        value.forEach((v, i) => {
+          if (noBlankNodes && v?.type === "AnnotationBlock" && (i === 0 || value[i - 1].type !== "Reifier")) {
+            reject(v.open, "Blank nodes");
+          }
+          visit(v);
+        });
+        return;
+      }
+      const node = value;
+      if (typeof node.offset === "number" && typeof node.value === "string") {
+        const t = node;
+        if (noVars && t.type === "VAR") reject(t, "Variables");
+        if (noBlankNodes && (t.type === "BLANK_NODE_LABEL" || this.isPunct(t, "["))) reject(t, "Blank nodes");
+        return;
+      }
+      if (noBlankNodes && node.type === "Reifier" && !node.id) reject(node.tilde, "Blank nodes");
+      if (noBlankNodes && node.type === "ReifiedTriple" && !node.reifier) reject(node.open, "Blank nodes");
+      for (const child of Object.values(node)) visit(child);
+    };
+    visit(quads.items);
+    return quads;
+  }
+  /** `{ Quads }`: triples and `GRAPH x { triples }` blocks */
+  parseQuads() {
+    const open = this.expectPunct("{");
+    const items = [];
+    while (!this.isPunct(this.peek(), "}")) {
+      if (this.isKw(this.peek(), "GRAPH")) {
+        const keyword = this.next();
+        const name = this.parseVarOrIri();
+        const template = this.parseTriplesTemplate(false);
+        items.push({ node: { type: "QuadsGraph", keyword, name, template }, dot: this.optPunct(".") });
+      } else if (this.startsTriples(this.peek())) {
+        const node = this.parseTriplesSameSubject(false);
+        const dot = this.optPunct(".");
+        items.push({ node, dot });
+        if (!dot && !this.isPunct(this.peek(), "}") && !this.isKw(this.peek(), "GRAPH")) {
+          this.fail(this.peek(), "'.' or '}'");
+        }
+      } else {
+        this.fail(this.peek(), "a triple pattern, GRAPH or '}'");
+      }
+    }
+    const close = this.next();
+    return { type: "TriplesTemplate", open, items, close };
+  }
+  // -------------------------------------------------------------------------
+  // Graph patterns
+  // -------------------------------------------------------------------------
+  parseGroupGraphPattern() {
+    const open = this.expectPunct("{");
+    if (this.isKw(this.peek(), "SELECT")) {
+      const subSelect = this.parseSubSelect();
+      const close2 = this.expectPunct("}");
+      return { type: "GroupGraphPattern", open, subSelect, items: [], close: close2 };
+    }
+    const items = [];
+    let needsDot = false;
+    for (; ; ) {
+      const t = this.peek();
+      if (this.isPunct(t, "}")) break;
+      if (this.startsTriples(t)) {
+        if (needsDot) this.fail(t, "'.' before the next triple pattern");
+        const node = this.parseTriplesSameSubject(true);
+        const dot = this.optPunct(".");
+        items.push({ node, dot });
+        needsDot = !dot;
+      } else {
+        const node = this.parseGraphPatternNotTriples();
+        items.push({ node, dot: this.optPunct(".") });
+        needsDot = false;
+      }
+    }
+    const close = this.next();
+    return { type: "GroupGraphPattern", open, subSelect: null, items, close };
+  }
+  parseGraphPatternNotTriples() {
+    const t = this.peek();
+    if (this.isPunct(t, "{")) {
+      const groups = [this.parseGroupGraphPattern()];
+      const keywords = [];
+      while (this.isKw(this.peek(), "UNION")) {
+        keywords.push(this.next());
+        groups.push(this.parseGroupGraphPattern());
+      }
+      return groups.length === 1 ? groups[0] : { type: "Union", groups, keywords };
+    }
+    if (t.type === "NAME") {
+      switch (t.value.toUpperCase()) {
+        case "OPTIONAL": {
+          const keyword = this.next();
+          return { type: "Optional", keyword, group: this.parseGroupGraphPattern() };
+        }
+        case "MINUS": {
+          const keyword = this.next();
+          return { type: "Minus", keyword, group: this.parseGroupGraphPattern() };
+        }
+        case "GRAPH": {
+          const keyword = this.next();
+          const name = this.parseVarOrIri();
+          return { type: "Graph", keyword, name, group: this.parseGroupGraphPattern() };
+        }
+        case "SERVICE": {
+          const keyword = this.next();
+          const silent = this.optKw("SILENT");
+          const name = this.parseVarOrIri();
+          return { type: "Service", keyword, silent, name, group: this.parseGroupGraphPattern() };
+        }
+        case "FILTER": {
+          const keyword = this.next();
+          return { type: "Filter", keyword, constraint: this.parseConstraint() };
+        }
+        case "BIND": {
+          const keyword = this.next();
+          const open = this.expectPunct("(");
+          const expression = this.parseExpression();
+          const as = this.expectKw("AS");
+          const variable = this.parseVar();
+          const close = this.expectPunct(")");
+          return { type: "Bind", keyword, open, expression, as, variable, close };
+        }
+        case "VALUES":
+          return this.parseValues();
+      }
+    }
+    return this.fail(t, "a triple pattern, a graph pattern or '}'");
+  }
+  parseValues() {
+    const keyword = this.expectKw("VALUES");
+    return { type: "Values", keyword, block: this.parseDataBlock() };
+  }
+  parseDataBlock() {
+    const t = this.peek();
+    if (t.type === "VAR") {
+      const variable = this.term(this.next());
+      const open2 = this.expectPunct("{");
+      const values = [];
+      while (!this.isPunct(this.peek(), "}")) values.push(this.parseDataBlockValue());
+      const close2 = this.next();
+      return { type: "DataBlock", variable, variables: null, open: open2, values, rows: [], close: close2 };
+    }
+    const varsOpen = this.expectPunct("(");
+    const vars = [];
+    while (this.peek().type === "VAR") vars.push(this.term(this.next()));
+    const varsClose = this.expectPunct(")");
+    const open = this.expectPunct("{");
+    const rows = [];
+    while (!this.isPunct(this.peek(), "}")) {
+      const rowOpen = this.expectPunct("(");
+      const values = [];
+      while (!this.isPunct(this.peek(), ")")) values.push(this.parseDataBlockValue());
+      if (values.length !== vars.length) {
+        throw new SparqlSyntaxError(
+          `Expected ${vars.length} value(s) in this VALUES row, found ${values.length}`,
+          rowOpen.offset,
+          rowOpen.line,
+          rowOpen.column
+        );
+      }
+      rows.push({ open: rowOpen, values, close: this.next() });
+    }
+    const close = this.next();
+    return {
+      type: "DataBlock",
+      variable: null,
+      variables: { open: varsOpen, vars, close: varsClose },
+      open,
+      values: [],
+      rows,
+      close
+    };
+  }
+  parseDataBlockValue() {
+    const t = this.peek();
+    if (this.isKw(t, "UNDEF")) return this.term(this.next());
+    if (this.isPunct(t, "<<(")) return this.parseTripleTerm("data");
+    if (t.type === "IRIREF" || t.type === "PNAME_LN" || t.type === "PNAME_NS") return this.parseIri();
+    const literal = this.tryParseLiteral();
+    if (literal) return literal;
+    return this.fail(t, "a data value (IRI, literal, UNDEF or triple term)");
+  }
+  // -------------------------------------------------------------------------
+  // Triples
+  // -------------------------------------------------------------------------
+  startsTriples(t) {
+    switch (t.type) {
+      case "VAR":
+      case "IRIREF":
+      case "PNAME_LN":
+      case "PNAME_NS":
+      case "BLANK_NODE_LABEL":
+      case "STRING":
+      case "INTEGER":
+      case "DECIMAL":
+      case "DOUBLE":
+        return true;
+      case "NAME":
+        return this.isKw(t, "TRUE", "FALSE");
+      case "PUNCT":
+        return ["(", "[", "<<", "<<(", "+", "-"].includes(t.value);
+      default:
+        return false;
+    }
+  }
+  /** TriplesSameSubject(Path) */
+  parseTriplesSameSubject(path) {
+    const t = this.peek();
+    let subject;
+    let required = true;
+    if (this.isPunct(t, "[") && !this.isEmptyPair("[", "]")) {
+      subject = this.parseBlankNodePropertyList(path);
+      required = false;
+    } else if (this.isPunct(t, "(") && !this.isEmptyPair("(", ")")) {
+      subject = this.parseCollection(path);
+      required = false;
+    } else if (this.isPunct(t, "<<")) {
+      subject = this.parseReifiedTriple();
+      required = false;
+    } else {
+      subject = this.parseVarOrTerm();
+    }
+    const properties = required || this.startsVerb(this.peek(), path) ? this.parsePropertyListNotEmpty(path) : null;
+    return { type: "Triples", subject, properties };
+  }
+  startsVerb(t, path) {
+    if (t.type === "VAR" || t.type === "IRIREF" || t.type === "PNAME_LN" || t.type === "PNAME_NS") return true;
+    if (t.type === "NAME" && t.value === "a") return true;
+    return path && this.isPunct(t, "^", "!", "(");
+  }
+  parsePropertyListNotEmpty(path) {
+    const entries = [];
+    for (; ; ) {
+      const verb = this.parseVerb(path);
+      const objects = [];
+      for (; ; ) {
+        const node = this.parseGraphNode(path);
+        const annotations = this.parseAnnotations(path);
+        if (annotations.length > 0 && verb.type !== "Term") {
+          const t = annotations[0].type === "Reifier" ? annotations[0].tilde : annotations[0].open;
+          throw new SparqlSyntaxError(
+            "A reifier or annotation can only follow a simple predicate, not a property path",
+            t.offset,
+            t.line,
+            t.column
+          );
+        }
+        const entry = { node, annotations, comma: this.optPunct(",") };
+        objects.push(entry);
+        if (!entry.comma) break;
+      }
+      const semicolons = [];
+      while (this.isPunct(this.peek(), ";")) semicolons.push(this.next());
+      entries.push({ verb, objects, semicolons });
+      if (semicolons.length === 0 || !this.startsVerb(this.peek(), path)) break;
+    }
+    return { type: "PropertyList", entries };
+  }
+  parseVerb(path) {
+    const t = this.peek();
+    if (t.type === "VAR") return this.term(this.next());
+    if (!path) {
+      if (t.type === "NAME" && t.value === "a") return this.term(this.next());
+      return this.parseIri("a predicate");
+    }
+    return this.parsePath();
+  }
+  /** Verb of a reified triple or triple term: Var | iri | 'a' */
+  parseSimpleVerb(allowVar) {
+    const t = this.peek();
+    if (t.type === "VAR" && allowVar) return this.term(this.next());
+    if (t.type === "NAME" && t.value === "a") return this.term(this.next());
+    return this.parseIri("a predicate");
+  }
+  parseAnnotations(path) {
+    const annotations = [];
+    for (; ; ) {
+      const t = this.peek();
+      if (this.isPunct(t, "~")) {
+        annotations.push(this.parseReifier());
+      } else if (this.isPunct(t, "{|")) {
+        const open = this.next();
+        const properties = this.parsePropertyListNotEmpty(path);
+        const close = this.expectPunct("|}");
+        annotations.push({ type: "AnnotationBlock", open, properties, close });
+      } else {
+        return annotations;
+      }
+    }
+  }
+  parseReifier() {
+    const tilde = this.expectPunct("~");
+    const t = this.peek();
+    let id = null;
+    if (t.type === "VAR" || t.type === "IRIREF" || t.type === "PNAME_LN" || t.type === "PNAME_NS") {
+      id = this.term(this.next());
+    } else if (t.type === "BLANK_NODE_LABEL") {
+      id = this.term(this.next());
+    } else if (this.isEmptyPair("[", "]")) {
+      id = this.term(this.next(), this.next());
+    }
+    return { type: "Reifier", tilde, id };
+  }
+  parseGraphNode(path) {
+    const t = this.peek();
+    if (this.isPunct(t, "[") && !this.isEmptyPair("[", "]")) return this.parseBlankNodePropertyList(path);
+    if (this.isPunct(t, "(") && !this.isEmptyPair("(", ")")) return this.parseCollection(path);
+    if (this.isPunct(t, "<<")) return this.parseReifiedTriple();
+    return this.parseVarOrTerm();
+  }
+  parseBlankNodePropertyList(path) {
+    const open = this.expectPunct("[");
+    const properties = this.parsePropertyListNotEmpty(path);
+    const close = this.expectPunct("]");
+    return { type: "BlankNodePropertyList", open, properties, close };
+  }
+  parseCollection(path) {
+    const open = this.expectPunct("(");
+    const items = [];
+    while (!this.isPunct(this.peek(), ")")) items.push(this.parseGraphNode(path));
+    const close = this.next();
+    return { type: "Collection", open, items, close };
+  }
+  parseReifiedTriple() {
+    const open = this.expectPunct("<<");
+    const subject = this.parseReifiedTripleTerm();
+    const predicate = this.parseSimpleVerb(true);
+    const object = this.parseReifiedTripleTerm();
+    const reifier = this.isPunct(this.peek(), "~") ? this.parseReifier() : null;
+    const close = this.expectPunct(">>");
+    return { type: "ReifiedTriple", open, subject, predicate, object, reifier, close };
+  }
+  /** ReifiedTripleSubject / ReifiedTripleObject */
+  parseReifiedTripleTerm() {
+    const t = this.peek();
+    if (this.isPunct(t, "<<")) return this.parseReifiedTriple();
+    if (this.isPunct(t, "<<(")) return this.parseTripleTerm("pattern");
+    if (this.isPunct(t, "(")) this.fail(t, "a variable, IRI, literal, blank node or triple");
+    if (this.isPunct(t, "[") && !this.isEmptyPair("[", "]")) {
+      this.fail(t, "a variable, IRI, literal, blank node or triple");
+    }
+    return this.parseVarOrTerm();
+  }
+  /**
+   * `<<( s p o )>>`
+   * - pattern: TripleTerm (subject/object: var, iri, literal, bnode, triple term)
+   * - expression: ExprTripleTerm (subject: iri | var; object: iri, literal, var, triple term)
+   * - data: TripleTermData (subject: iri; object: iri, literal, triple term)
+   */
+  parseTripleTerm(kind) {
+    const open = this.expectPunct("<<(");
+    const part = (isSubject) => {
+      const t = this.peek();
+      if (this.isPunct(t, "<<(")) {
+        if (isSubject && kind !== "pattern") this.fail(t, "an IRI or variable");
+        return this.parseTripleTerm(kind);
+      }
+      if (t.type === "VAR") {
+        if (kind === "data") this.fail(t, "an IRI or literal (variables are not allowed in VALUES)");
+        return this.term(this.next());
+      }
+      if (t.type === "IRIREF" || t.type === "PNAME_LN" || t.type === "PNAME_NS") return this.parseIri();
+      if (t.type === "BLANK_NODE_LABEL" || this.isEmptyPair("[", "]")) {
+        if (kind !== "pattern") this.fail(t, "an IRI, literal or variable");
+        return t.type === "BLANK_NODE_LABEL" ? this.term(this.next()) : this.term(this.next(), this.next());
+      }
+      if (isSubject && kind !== "pattern") this.fail(t, kind === "data" ? "an IRI" : "an IRI or variable");
+      const literal = this.tryParseLiteral();
+      if (literal) return literal;
+      return this.fail(t, "an RDF term");
+    };
+    const subject = part(true);
+    const predicate = this.parseSimpleVerb(kind !== "data");
+    const object = part(false);
+    const close = this.expectPunct(")>>");
+    return { type: "TripleTerm", open, subject, predicate, object, close };
+  }
+  // -------------------------------------------------------------------------
+  // Terms
+  // -------------------------------------------------------------------------
+  isVarOrIri(t) {
+    return t.type === "VAR" || t.type === "IRIREF" || t.type === "PNAME_LN" || t.type === "PNAME_NS";
+  }
+  parseVar() {
+    const t = this.peek();
+    if (t.type !== "VAR") this.fail(t, "a variable");
+    return this.term(this.next());
+  }
+  parseIri(expected = "an IRI") {
+    const t = this.peek();
+    if (t.type !== "IRIREF" && t.type !== "PNAME_LN" && t.type !== "PNAME_NS") this.fail(t, expected);
+    return this.term(this.next());
+  }
+  parseVarOrIri() {
+    const t = this.peek();
+    if (!this.isVarOrIri(t)) this.fail(t, "a variable or an IRI");
+    return this.term(this.next());
+  }
+  /** RDFLiteral | NumericLiteral | BooleanLiteral, or null */
+  tryParseLiteral() {
+    const t = this.peek();
+    if (t.type === "STRING") {
+      const tokens = [this.next()];
+      const n = this.peek();
+      if (n.type === "LANG_DIR") {
+        tokens.push(this.next());
+      } else if (this.isPunct(n, "^^")) {
+        tokens.push(this.next());
+        tokens.push(...this.parseIri().tokens);
+      }
+      return this.term(...tokens);
+    }
+    if (t.type === "INTEGER" || t.type === "DECIMAL" || t.type === "DOUBLE") return this.term(this.next());
+    if (this.isPunct(t, "+", "-")) {
+      const n = this.peek(1);
+      if ((n.type === "INTEGER" || n.type === "DECIMAL" || n.type === "DOUBLE") && !n.spaceBefore) {
+        return this.term(this.next(), this.next());
+      }
+      return null;
+    }
+    if (t.type === "NAME" && this.isKw(t, "TRUE", "FALSE")) return this.term(this.next());
+    return null;
+  }
+  /** VarOrTerm: Var | iri | RDFLiteral | NumericLiteral | BooleanLiteral | BlankNode | NIL | TripleTerm */
+  parseVarOrTerm() {
+    const t = this.peek();
+    switch (t.type) {
+      case "VAR":
+      case "IRIREF":
+      case "PNAME_LN":
+      case "PNAME_NS":
+      case "BLANK_NODE_LABEL":
+        return this.term(this.next());
+    }
+    if (this.isEmptyPair("(", ")") || this.isEmptyPair("[", "]")) return this.term(this.next(), this.next());
+    if (this.isPunct(t, "<<(")) return this.parseTripleTerm("pattern");
+    const literal = this.tryParseLiteral();
+    if (literal) return literal;
+    return this.fail(t, "an RDF term or a variable");
+  }
+  // -------------------------------------------------------------------------
+  // Property paths
+  // -------------------------------------------------------------------------
+  parsePath() {
+    const items = [this.parsePathSequence()];
+    const separators = [];
+    while (this.isPunct(this.peek(), "|")) {
+      separators.push(this.next());
+      items.push(this.parsePathSequence());
+    }
+    return items.length === 1 ? items[0] : { type: "PathAlternative", items, separators };
+  }
+  parsePathSequence() {
+    const items = [this.parsePathEltOrInverse()];
+    const separators = [];
+    while (this.isPunct(this.peek(), "/")) {
+      separators.push(this.next());
+      items.push(this.parsePathEltOrInverse());
+    }
+    return items.length === 1 ? items[0] : { type: "PathSequence", items, separators };
+  }
+  parsePathEltOrInverse() {
+    if (this.isPunct(this.peek(), "^")) {
+      const caret = this.next();
+      return { type: "PathInverse", caret, item: this.parsePathElt() };
+    }
+    return this.parsePathElt();
+  }
+  parsePathElt() {
+    const primary = this.parsePathPrimary();
+    const t = this.peek();
+    if (this.isPunct(t, "?", "*", "+") && !this.isPathModAmbiguous(t)) {
+      return { type: "PathModified", item: primary, modifier: this.next() };
+    }
+    return primary;
+  }
+  /** `:p ?x` must not read `?` as a modifier: the lexer makes `?x` a VAR, so only a bare `?` is a modifier. */
+  isPathModAmbiguous(t) {
+    if (this.isPunct(t, "+", "-")) {
+      const n = this.peek(1);
+      return (n.type === "INTEGER" || n.type === "DECIMAL" || n.type === "DOUBLE") && !n.spaceBefore;
+    }
+    return false;
+  }
+  parsePathPrimary() {
+    const t = this.peek();
+    if (t.type === "NAME" && t.value === "a") return this.term(this.next());
+    if (this.isPunct(t, "!")) {
+      const bang = this.next();
+      return { type: "PathNegated", bang, item: this.parsePathNegatedPropertySet() };
+    }
+    if (this.isPunct(t, "(")) {
+      const open = this.next();
+      const path = this.parsePath();
+      const close = this.expectPunct(")");
+      return { type: "PathGroup", open, path, close };
+    }
+    return this.parseIri("a predicate or property path");
+  }
+  parsePathNegatedPropertySet() {
+    if (this.isPunct(this.peek(), "(")) {
+      const open = this.next();
+      if (this.isPunct(this.peek(), ")")) return { type: "PathGroup", open, path: null, close: this.next() };
+      const items = [this.parsePathOneInPropertySet()];
+      const separators = [];
+      while (this.isPunct(this.peek(), "|")) {
+        separators.push(this.next());
+        items.push(this.parsePathOneInPropertySet());
+      }
+      const close = this.expectPunct(")");
+      const path = items.length === 1 ? items[0] : { type: "PathAlternative", items, separators };
+      return { type: "PathGroup", open, path, close };
+    }
+    return this.parsePathOneInPropertySet();
+  }
+  parsePathOneInPropertySet() {
+    const t = this.peek();
+    if (this.isPunct(t, "^")) {
+      const caret = this.next();
+      const n = this.peek();
+      const item = n.type === "NAME" && n.value === "a" ? this.term(this.next()) : this.parseIri();
+      return { type: "PathInverse", caret, item };
+    }
+    if (t.type === "NAME" && t.value === "a") return this.term(this.next());
+    return this.parseIri();
+  }
+  // -------------------------------------------------------------------------
+  // Expressions
+  // -------------------------------------------------------------------------
+  parseExpression() {
+    let left = this.parseAnd();
+    while (this.isPunct(this.peek(), "||")) {
+      const operator = this.next();
+      left = { type: "Binary", left, operator, right: this.parseAnd() };
+    }
+    return left;
+  }
+  parseAnd() {
+    let left = this.parseRelational();
+    while (this.isPunct(this.peek(), "&&")) {
+      const operator = this.next();
+      left = { type: "Binary", left, operator, right: this.parseRelational() };
+    }
+    return left;
+  }
+  parseRelational() {
+    const left = this.parseAdditive();
+    const t = this.peek();
+    if (this.isPunct(t, "=", "!=", "<", ">", "<=", ">=")) {
+      const operator = this.next();
+      return { type: "Binary", left, operator, right: this.parseAdditive() };
+    }
+    if (this.isKw(t, "IN")) {
+      const inKw = this.next();
+      return { type: "In", expression: left, not: null, in: inKw, list: this.parseExpressionList() };
+    }
+    if (this.isKw(t, "NOT") && this.isKw(this.peek(1), "IN")) {
+      const not = this.next();
+      const inKw = this.next();
+      return { type: "In", expression: left, not, in: inKw, list: this.parseExpressionList() };
+    }
+    return left;
+  }
+  parseAdditive() {
+    let left = this.parseMultiplicative();
+    while (this.isPunct(this.peek(), "+", "-")) {
+      const operator = this.next();
+      left = { type: "Binary", left, operator, right: this.parseMultiplicative() };
+    }
+    return left;
+  }
+  parseMultiplicative() {
+    let left = this.parseUnary();
+    while (this.isPunct(this.peek(), "*", "/")) {
+      const operator = this.next();
+      left = { type: "Binary", left, operator, right: this.parseUnary() };
+    }
+    return left;
+  }
+  parseUnary() {
+    const t = this.peek();
+    if (this.isPunct(t, "!")) {
+      const operator = this.next();
+      return { type: "Unary", operator, expression: this.parseUnary() };
+    }
+    if (this.isPunct(t, "+", "-")) {
+      const n = this.peek(1);
+      if ((n.type === "INTEGER" || n.type === "DECIMAL" || n.type === "DOUBLE") && !n.spaceBefore) {
+        return this.term(this.next(), this.next());
+      }
+      const operator = this.next();
+      return { type: "Unary", operator, expression: this.parsePrimary() };
+    }
+    return this.parsePrimary();
+  }
+  parsePrimary() {
+    const t = this.peek();
+    if (this.isPunct(t, "(")) return this.parseBracketed();
+    if (this.isPunct(t, "<<(")) return this.parseTripleTerm("expression");
+    if (t.type === "VAR") return this.term(this.next());
+    if (t.type === "IRIREF" || t.type === "PNAME_LN" || t.type === "PNAME_NS") {
+      const iri = this.parseIri();
+      return this.isPunct(this.peek(), "(") ? this.parseArgList(iri, false) : iri;
+    }
+    if (t.type === "NAME" && !this.isKw(t, "TRUE", "FALSE")) return this.parseBuiltInCall();
+    const literal = this.tryParseLiteral();
+    if (literal) return literal;
+    return this.fail(t, "an expression");
+  }
+  parseBracketed() {
+    const open = this.expectPunct("(");
+    const expression = this.parseExpression();
+    const close = this.expectPunct(")");
+    return { type: "Bracketed", open, expression, close };
+  }
+  parseExpressionList() {
+    const open = this.expectPunct("(");
+    const items = [];
+    const commas = [];
+    if (!this.isPunct(this.peek(), ")")) {
+      items.push(this.parseExpression());
+      while (this.isPunct(this.peek(), ",")) {
+        commas.push(this.next());
+        items.push(this.parseExpression());
+      }
+    }
+    const close = this.expectPunct(")");
+    return { type: "ExpressionList", open, items, commas, close };
+  }
+  parseBuiltInCall() {
+    const t = this.peek();
+    const name = t.value.toUpperCase();
+    if (name === "EXISTS") {
+      const keyword = this.next();
+      return { type: "Exists", not: null, keyword, group: this.parseGroupGraphPattern() };
+    }
+    if (name === "NOT" && this.isKw(this.peek(1), "EXISTS")) {
+      const not = this.next();
+      const keyword = this.next();
+      return { type: "Exists", not, keyword, group: this.parseGroupGraphPattern() };
+    }
+    if (t.type !== "NAME" || !BUILTINS.has(name)) return this.fail(t, "an expression");
+    const nameToken = this.next();
+    if (!this.isPunct(this.peek(), "(")) this.fail(this.peek(), `'(' after ${nameToken.value}`);
+    const call = this.parseArgList(nameToken, true);
+    const n = call.args.length;
+    if (NO_ARGS.has(name)) {
+      if (n > 0) this.fail(call.args.length ? this.tokenOf(call.args[0]) : call.close, "')'");
+    } else if (ARITY[name]) {
+      const [min, max] = ARITY[name];
+      if (n < min || n > max) {
+        throw new SparqlSyntaxError(
+          `${nameToken.value} expects ${min === max ? min : `${min} to ${max}`} argument(s), found ${n}`,
+          nameToken.offset,
+          nameToken.line,
+          nameToken.column
+        );
+      }
+    } else if (n !== 1) {
+      throw new SparqlSyntaxError(
+        `${nameToken.value} expects 1 argument, found ${n}`,
+        nameToken.offset,
+        nameToken.line,
+        nameToken.column
+      );
+    }
+    if (call.distinct && !AGGREGATES.has(name)) this.fail(call.distinct, "an expression");
+    if (call.separator && name !== "GROUP_CONCAT") this.fail(call.separator.semicolon, "')'");
+    if (name === "BOUND" && (call.args[0].type !== "Term" || call.args[0].tokens[0].type !== "VAR")) {
+      this.fail(this.tokenOf(call.args[0]), "a variable");
+    }
+    return call;
+  }
+  /** First token of a node, used for error positions. */
+  tokenOf(node) {
+    switch (node.type) {
+      case "Term":
+        return node.tokens[0];
+      case "Binary":
+        return this.tokenOf(node.left);
+      case "In":
+        return this.tokenOf(node.expression);
+      case "Call":
+        return node.name.type === "Term" ? node.name.tokens[0] : node.name;
+      default:
+        return "open" in node ? node.open : this.peek();
+    }
+  }
+  /** `name( [DISTINCT] args [; SEPARATOR = "x"] )` */
+  parseArgList(name, builtin) {
+    const open = this.expectPunct("(");
+    const upper = name.type === "Term" ? "" : name.value.toUpperCase();
+    const distinct = this.optKw("DISTINCT");
+    const args = [];
+    const commas = [];
+    let separator = null;
+    if (!this.isPunct(this.peek(), ")")) {
+      if (upper === "COUNT" && this.isPunct(this.peek(), "*")) {
+        args.push(this.term(this.next()));
+      } else {
+        args.push(this.parseExpression());
+      }
+      while (this.isPunct(this.peek(), ",")) {
+        commas.push(this.next());
+        args.push(this.parseExpression());
+      }
+      if (this.isPunct(this.peek(), ";")) {
+        const semicolon = this.next();
+        const keyword = this.expectKw("SEPARATOR");
+        const equals = this.expectPunct("=");
+        const value = this.peek();
+        if (value.type !== "STRING") this.fail(value, "a string");
+        separator = { semicolon, keyword, equals, value: this.term(this.next()) };
+      }
+    } else if (distinct) {
+      this.fail(this.peek(), "an expression");
+    }
+    const close = this.expectPunct(")");
+    return {
+      type: "Call",
+      name,
+      builtin,
+      open,
+      distinct,
+      args,
+      commas,
+      separator,
+      close
+    };
+  }
+};
+
+// src/writer.ts
+var ATTACHABLE = /* @__PURE__ */ new Set([".", ",", ";"]);
+var Writer = class {
+  constructor(options) {
+    this.lines = [];
+    this.current = "";
+    this.currentIndent = "";
+    this.level = 0;
+    /** Indent to use for the next line instead of the structural indent (alignment). */
+    this.nextIndent = null;
+    this.pendingSpace = false;
+    this.pendingTrailing = [];
+    this.leadingDone = /* @__PURE__ */ new Set();
+    /** Leading comments of dropped tokens, written before the next output. */
+    this.deferred = [];
+    /** Number of comments written; used to check that no comment was lost. */
+    this.commentCount = 0;
+    this.options = options;
+  }
+  // -------------------------------------------------------------------------
+  // Layout
+  // -------------------------------------------------------------------------
+  get atLineStart() {
+    return this.current === "";
+  }
+  indent() {
+    this.level++;
+  }
+  dedent() {
+    this.level--;
+  }
+  structuralIndent() {
+    return this.options.indent.repeat(this.level);
+  }
+  /** Column (0-based) at which the next text will be written. */
+  column() {
+    if (this.atLineStart) return (this.nextIndent ?? this.structuralIndent()).length;
+    return this.currentIndent.length + this.current.length + (this.pendingSpace ? 1 : 0);
+  }
+  space() {
+    if (!this.atLineStart) this.pendingSpace = true;
+  }
+  /** End the current line. Does nothing on an empty line unless comments are pending. */
+  newline() {
+    if (this.atLineStart && this.pendingTrailing.length === 0) {
+      this.nextIndent = null;
+      return;
+    }
+    const [first, ...rest] = this.pendingTrailing;
+    let line = this.current;
+    if (first !== void 0) {
+      line = line === "" ? first.text : `${line} ${first.text}`;
+      this.commentCount++;
+    }
+    this.lines.push((this.currentIndent + line).replace(/\s+$/, ""));
+    this.current = "";
+    this.pendingSpace = false;
+    this.pendingTrailing = [];
+    this.deferred.push(...rest);
+  }
+  /** Indentation of the current line (or of the next line when nothing was written yet). */
+  lineIndent() {
+    return this.atLineStart ? this.nextIndent ?? this.structuralIndent() : this.currentIndent;
+  }
+  /** Indent string that aligns a new line with the current column. */
+  alignment() {
+    const base = this.lineIndent();
+    return base + " ".repeat(Math.max(0, this.column() - base.length));
+  }
+  /** Indent string one level deeper than the current line. */
+  continuation() {
+    return this.lineIndent() + this.options.indent;
+  }
+  /** Start a new line with the given indent string (from `alignment()` or `continuation()`). */
+  newlineWith(indent) {
+    this.newline();
+    this.nextIndent = indent;
+  }
+  /** Make sure the output ends with exactly one empty line (unless at the very start or after an opening brace). */
+  blankLine() {
+    this.newline();
+    const last = this.lines[this.lines.length - 1];
+    if (last === void 0 || last === "" || /[{(\[]$/.test(last)) return;
+    this.lines.push("");
+  }
+  /** Continue the current statement on a new line (used when a comment forces a break). */
+  breakLine() {
+    if (this.atLineStart) return;
+    this.newline();
+    this.nextIndent = this.structuralIndent() + this.options.indent;
+  }
+  write(text) {
+    if (text === "") return;
+    if (this.atLineStart) {
+      this.currentIndent = this.nextIndent ?? this.structuralIndent();
+      this.nextIndent = null;
+      this.current = text;
+    } else {
+      this.current += (this.pendingSpace ? " " : "") + text;
+    }
+    this.pendingSpace = false;
+  }
+  // -------------------------------------------------------------------------
+  // Content
+  // -------------------------------------------------------------------------
+  leadingComments(t, blank) {
+    if (this.options.ignoreComments) return;
+    const comments = [...this.deferred];
+    this.deferred = [];
+    if (t && t.leading.length > 0 && !this.leadingDone.has(t)) {
+      this.leadingDone.add(t);
+      comments.push(...t.leading);
+    }
+    if (comments.length > 0) {
+      this.breakLine();
+      const indent = this.nextIndent;
+      for (const comment of comments) {
+        if (comment.blankLinesBefore > 0 && this.options.preserveBlankLines) this.blankLine();
+        this.nextIndent = indent;
+        this.write(comment.text);
+        this.commentCount++;
+        this.newline();
+      }
+      this.nextIndent = indent;
+    }
+    if (t && blank && t.blankLinesBefore > 0 && this.options.preserveBlankLines && this.atLineStart) {
+      this.blankLine();
+    }
+  }
+  trailingComment(t) {
+    if (this.options.ignoreComments) return;
+    if (t.trailing) {
+      this.pendingTrailing.push(t.trailing);
+    }
+  }
+  /**
+   * Write a source token (optionally spelled differently, e.g. upper-cased).
+   * `blank`: keep a blank line that precedes the token in the source.
+   */
+  token(t, text = t.value, blank = false) {
+    if (this.pendingTrailing.length > 0 && !ATTACHABLE.has(text)) this.breakLine();
+    this.leadingComments(t, blank);
+    this.write(text);
+    this.trailingComment(t);
+  }
+  /** Write only the comments of a token that is not printed. */
+  drop(t) {
+    if (this.options.ignoreComments) return;
+    if (!this.leadingDone.has(t)) {
+      this.leadingDone.add(t);
+      this.deferred.push(...t.leading);
+    }
+    if (this.deferred.length > 0 && t.trailing) this.deferred.push(t.trailing);
+    else this.trailingComment(t);
+  }
+  /** Write only the leading comments of a token (used before closing brackets at the inner indent). */
+  commentsBefore(t) {
+    this.leadingComments(t, false);
+  }
+  /** Write text that doesn't come from a source token. */
+  text(text) {
+    if (this.pendingTrailing.length > 0 && !ATTACHABLE.has(text)) this.breakLine();
+    if (this.deferred.length > 0) this.leadingComments(null, false);
+    this.write(text);
+  }
+  /** Has anything been written to the current line or earlier? */
+  get isEmpty() {
+    return this.lines.length === 0 && this.atLineStart;
+  }
+  /** The text written so far, if it fits on a single line without comments. */
+  singleLine() {
+    if (this.lines.length > 0 || this.pendingTrailing.length > 0 || this.deferred.length > 0 || this.commentCount > 0) {
+      return null;
+    }
+    return this.current;
+  }
+  toString() {
+    this.leadingComments(null, false);
+    this.newline();
+    while (this.lines.length > 0 && this.lines[this.lines.length - 1] === "") this.lines.pop();
+    return this.lines.join("\n");
+  }
+};
+
+// src/printer.ts
+function resolveOptions(options = {}) {
+  const indent = typeof options.indent === "string" ? options.indent : " ".repeat(Math.max(0, Math.floor(options.indent ?? 2)));
+  return {
+    indent,
+    keywordCase: options.keywordCase ?? "upper",
+    functionCase: options.functionCase ?? "preserve",
+    alignPredicates: options.alignPredicates ?? true,
+    preserveBlankLines: options.preserveBlankLines ?? true,
+    compact: options.compact ?? false,
+    lineWidth: options.lineWidth ?? 100,
+    insertWhere: options.insertWhere ?? true
+  };
+}
+function applyCase(text, c) {
+  return c === "upper" ? text.toUpperCase() : c === "lower" ? text.toLowerCase() : text;
+}
+var Printer = class {
+  constructor(options) {
+    this.options = options;
+    this.w = this.newWriter();
+  }
+  newWriter(ignoreComments = false) {
+    return new Writer({
+      indent: this.options.indent,
+      preserveBlankLines: this.options.preserveBlankLines,
+      ignoreComments
+    });
+  }
+  print(ast) {
+    if (ast.type === "Query") this.query(ast);
+    else this.update(ast);
+    return { text: this.w.toString(), comments: this.w.commentCount };
+  }
+  /**
+   * Render `fn` on a scratch writer and return the result if it fits on one
+   * line (no comments, no line breaks) within `width` characters.
+   */
+  measure(fn, width, ignoreComments = false) {
+    const saved = this.w;
+    this.w = this.newWriter(ignoreComments);
+    try {
+      fn();
+      const line = this.w.singleLine();
+      return line !== null && line.length <= width ? line : null;
+    } finally {
+      this.w = saved;
+    }
+  }
+  remainingWidth() {
+    return this.options.lineWidth - this.w.column();
+  }
+  // -------------------------------------------------------------------------
+  // Tokens
+  // -------------------------------------------------------------------------
+  kw(t, blank = false) {
+    this.w.token(t, applyCase(t.value, this.options.keywordCase), blank);
+  }
+  /** A keyword that was not in the source (e.g. an inserted WHERE). */
+  synthKw(text) {
+    this.w.text(applyCase(text, this.options.keywordCase));
+  }
+  tok(t, blank = false) {
+    this.w.token(t, t.value, blank);
+  }
+  sp() {
+    this.w.space();
+  }
+  nl() {
+    this.w.newline();
+  }
+  // -------------------------------------------------------------------------
+  // Units
+  // -------------------------------------------------------------------------
+  prologue(decls) {
+    for (const decl of decls) {
+      this.nl();
+      this.kw(decl.keyword, true);
+      this.sp();
+      if (decl.prefix) {
+        this.tok(decl.prefix);
+        this.sp();
+      }
+      this.tok(decl.value);
+    }
+    if (decls.length > 0) this.w.blankLine();
+  }
+  query(q) {
+    this.prologue(q.prologue);
+    const form = q.form;
+    switch (form.type) {
+      case "Select":
+        this.selectClause(form.select);
+        this.datasets(form.datasets);
+        this.whereClause(form.where, this.options.insertWhere);
+        this.solutionModifier(form.modifiers);
+        break;
+      case "Construct":
+        this.nl();
+        this.kw(form.keyword);
+        if (form.template) {
+          this.sp();
+          this.triplesTemplate(form.template);
+          this.datasets(form.datasets);
+          this.whereClause(form.where, this.options.insertWhere);
+        } else {
+          this.datasets(form.datasets);
+          this.nl();
+          this.kw(form.shortForm.keyword);
+          this.sp();
+          this.triplesTemplate(form.shortForm.template);
+        }
+        this.solutionModifier(form.modifiers);
+        break;
+      case "Describe":
+        this.nl();
+        this.kw(form.keyword);
+        if (form.star) {
+          this.sp();
+          this.tok(form.star);
+        }
+        for (const item of form.items) {
+          this.sp();
+          this.term(item);
+        }
+        this.datasets(form.datasets);
+        if (form.where) this.whereClause(form.where, this.options.insertWhere);
+        this.solutionModifier(form.modifiers);
+        break;
+      case "Ask":
+        this.nl();
+        this.kw(form.keyword);
+        if (form.datasets.length === 0 && !form.where.keyword) {
+          this.sp();
+          this.group(form.where.group);
+        } else {
+          this.datasets(form.datasets);
+          this.whereClause(form.where, true);
+        }
+        this.solutionModifier(form.modifiers);
+        break;
+    }
+    if (q.values) {
+      this.nl();
+      this.values(q.values);
+    }
+    this.nl();
+    this.w.drop(q.eof);
+  }
+  selectClause(s) {
+    this.nl();
+    this.kw(s.keyword);
+    if (s.modifier) {
+      this.sp();
+      this.kw(s.modifier);
+    }
+    if (s.star) {
+      this.sp();
+      this.tok(s.star);
+    }
+    for (const item of s.items) {
+      this.sp();
+      if (item.type === "Term") this.term(item);
+      else this.projection(item);
+    }
+  }
+  projection(p) {
+    this.tok(p.open);
+    this.expr(p.expression);
+    if (p.as && p.variable) {
+      this.sp();
+      this.kw(p.as);
+      this.sp();
+      this.term(p.variable);
+    }
+    this.tok(p.close);
+  }
+  datasets(datasets) {
+    for (const d of datasets) {
+      this.nl();
+      this.kw(d.from);
+      if (d.named) {
+        this.sp();
+        this.kw(d.named);
+      }
+      this.sp();
+      this.term(d.iri);
+    }
+  }
+  whereClause(where, insertWhere) {
+    this.nl();
+    if (where.keyword) {
+      this.kw(where.keyword);
+      this.sp();
+    } else if (insertWhere) {
+      this.synthKw("WHERE");
+      this.sp();
+    }
+    this.group(where.group);
+  }
+  solutionModifier(m) {
+    if (m.groupBy) {
+      this.nl();
+      this.kw(m.groupBy.group);
+      this.sp();
+      this.kw(m.groupBy.by);
+      for (const c of m.groupBy.conditions) {
+        this.sp();
+        this.condition(c);
+      }
+    }
+    if (m.having) {
+      this.nl();
+      this.kw(m.having.keyword);
+      for (const c of m.having.conditions) {
+        this.sp();
+        this.condition(c);
+      }
+    }
+    if (m.orderBy) {
+      this.nl();
+      this.kw(m.orderBy.order);
+      this.sp();
+      this.kw(m.orderBy.by);
+      for (const c of m.orderBy.conditions) {
+        this.sp();
+        this.condition(c);
+      }
+    }
+    for (const lo of m.limitOffset) {
+      this.nl();
+      this.kw(lo.keyword);
+      this.sp();
+      this.tok(lo.value);
+    }
+  }
+  condition(c) {
+    if (c.type === "Projection") this.projection(c);
+    else if (c.type === "OrderCondition") {
+      if (c.direction) this.kw(c.direction);
+      this.expr(c.expression);
+    } else this.expr(c);
+  }
+  update(u) {
+    let first = true;
+    for (const part of u.parts) {
+      if (!first && (part.prologue.length > 0 || part.operation)) this.w.blankLine();
+      this.prologue(part.prologue);
+      if (part.operation) {
+        this.updateOperation(part.operation);
+        first = false;
+      }
+      if (part.semicolon) {
+        this.sp();
+        this.tok(part.semicolon);
+      }
+    }
+    this.nl();
+    this.w.drop(u.eof);
+  }
+  words(words) {
+    words.tokens.forEach((t, i) => {
+      if (i > 0) this.sp();
+      if ("tokens" in t) this.term(t);
+      else this.kw(t);
+    });
+  }
+  updateOperation(op) {
+    this.nl();
+    switch (op.type) {
+      case "Load":
+        this.kw(op.keyword);
+        if (op.silent) {
+          this.sp();
+          this.kw(op.silent);
+        }
+        this.sp();
+        this.term(op.iri);
+        if (op.into) {
+          this.sp();
+          this.words(op.into);
+        }
+        break;
+      case "GraphManagement":
+        this.kw(op.keyword);
+        if (op.silent) {
+          this.sp();
+          this.kw(op.silent);
+        }
+        this.sp();
+        this.words(op.target);
+        break;
+      case "GraphTransfer":
+        this.kw(op.keyword);
+        if (op.silent) {
+          this.sp();
+          this.kw(op.silent);
+        }
+        this.sp();
+        this.words(op.from);
+        this.sp();
+        this.kw(op.to);
+        this.sp();
+        this.words(op.target);
+        break;
+      case "QuadData":
+        this.kw(op.keywords[0]);
+        this.sp();
+        this.kw(op.keywords[1]);
+        this.sp();
+        this.triplesTemplate(op.quads);
+        break;
+      case "Modify":
+        if (op.with) {
+          this.kw(op.with.keyword);
+          this.sp();
+          this.term(op.with.iri);
+          this.nl();
+        }
+        if (op.delete) {
+          this.kw(op.delete.keyword);
+          this.sp();
+          this.triplesTemplate(op.delete.quads);
+          this.nl();
+        }
+        if (op.insert) {
+          this.kw(op.insert.keyword);
+          this.sp();
+          this.triplesTemplate(op.insert.quads);
+          this.nl();
+        }
+        for (const using of op.using) {
+          this.kw(using.keyword);
+          if (using.named) {
+            this.sp();
+            this.kw(using.named);
+          }
+          this.sp();
+          this.term(using.iri);
+          this.nl();
+        }
+        this.whereClause(op.where, true);
+        break;
+    }
+  }
+  // -------------------------------------------------------------------------
+  // Blocks
+  // -------------------------------------------------------------------------
+  /**
+   * Print `open`, the items on their own lines one level deeper, and `close`.
+   * Comments before `close` stay inside the block.
+   */
+  block(open, close, isEmpty, body, openText = open.value) {
+    this.w.token(open, openText);
+    if (isEmpty && close.leading.length === 0 && !open.trailing) {
+      this.tok(close);
+      return;
+    }
+    this.w.indent();
+    body();
+    this.nl();
+    this.w.commentsBefore(close);
+    this.w.dedent();
+    this.nl();
+    this.tok(close);
+  }
+  /** Try to print a block on a single line (compact mode). */
+  inlineBlock(open, close, body) {
+    if (!this.options.compact) return false;
+    const line = this.measure(() => {
+      this.tok(open);
+      this.sp();
+      body();
+      this.sp();
+      this.tok(close);
+    }, this.remainingWidth());
+    if (line === null) return false;
+    this.tok(open);
+    this.sp();
+    body();
+    this.sp();
+    this.tok(close);
+    return true;
+  }
+  group(g) {
+    if (g.subSelect) {
+      const sub = g.subSelect;
+      this.block(g.open, g.close, false, () => {
+        this.selectClause(sub.select);
+        this.whereClause(sub.where, this.options.insertWhere);
+        this.solutionModifier(sub.modifiers);
+        if (sub.values) {
+          this.nl();
+          this.values(sub.values);
+        }
+      });
+      return;
+    }
+    if (g.items.length === 1 && g.items[0].node.type === "Triples" && this.inlineBlock(g.open, g.close, () => this.patternItem(g.items[0], true))) {
+      return;
+    }
+    this.block(g.open, g.close, g.items.length === 0, () => {
+      g.items.forEach((item) => {
+        this.nl();
+        this.patternItem(item, false);
+      });
+    });
+  }
+  triplesTemplate(t) {
+    if (t.items.length === 1 && t.items[0].node.type === "Triples" && this.inlineBlock(t.open, t.close, () => this.patternItem(t.items[0], true))) {
+      return;
+    }
+    this.block(t.open, t.close, t.items.length === 0, () => {
+      for (const item of t.items) {
+        this.nl();
+        this.patternItem(item, false);
+      }
+    });
+  }
+  /** An item of a group: triples end with ` .`, other patterns have no dot. */
+  patternItem(item, inline) {
+    const node = item.node;
+    if (node.type === "Triples") {
+      this.triples(node, true);
+      if (inline) {
+        if (item.dot) this.w.drop(item.dot);
+      } else {
+        this.sp();
+        if (item.dot) this.tok(item.dot);
+        else this.w.text(".");
+      }
+      return;
+    }
+    this.pattern(node, true);
+    if (item.dot) this.w.drop(item.dot);
+  }
+  pattern(node, first) {
+    switch (node.type) {
+      case "GroupGraphPattern":
+        this.markBlank(node.open, first);
+        this.group(node);
+        break;
+      case "Union":
+        node.groups.forEach((g, i) => {
+          if (i > 0) {
+            this.nl();
+            this.kw(node.keywords[i - 1]);
+            this.nl();
+            this.group(g);
+          } else {
+            this.markBlank(g.open, first);
+            this.group(g);
+          }
+        });
+        break;
+      case "Optional":
+      case "Minus":
+        this.kw(node.keyword, first);
+        this.sp();
+        this.group(node.group);
+        break;
+      case "Graph":
+        this.kw(node.keyword, first);
+        this.sp();
+        this.term(node.name);
+        this.sp();
+        this.group(node.group);
+        break;
+      case "Service":
+        this.kw(node.keyword, first);
+        if (node.silent) {
+          this.sp();
+          this.kw(node.silent);
+        }
+        this.sp();
+        this.term(node.name);
+        this.sp();
+        this.group(node.group);
+        break;
+      case "Filter":
+        this.kw(node.keyword, first);
+        this.sp();
+        this.expr(node.constraint);
+        break;
+      case "Bind":
+        this.kw(node.keyword, first);
+        this.sp();
+        this.tok(node.open);
+        this.expr(node.expression);
+        this.sp();
+        this.kw(node.as);
+        this.sp();
+        this.term(node.variable);
+        this.tok(node.close);
+        break;
+      case "Values":
+        this.markBlank(node.keyword, first);
+        this.values(node);
+        break;
+      case "QuadsGraph":
+        this.kw(node.keyword, first);
+        this.sp();
+        this.term(node.name);
+        this.sp();
+        this.triplesTemplate(node.template);
+        break;
+      default:
+        throw new Error(`Unexpected pattern ${node.type}`);
+    }
+  }
+  /** Honour a blank line before the first token of a statement. */
+  markBlank(t, blank) {
+    if (blank && t.blankLinesBefore > 0 && this.options.preserveBlankLines && this.w.atLineStart) {
+      this.w.commentsBefore(t);
+      this.w.blankLine();
+    }
+  }
+  values(v) {
+    this.kw(v.keyword, true);
+    this.sp();
+    const b = v.block;
+    if (b.variable) {
+      this.term(b.variable);
+      this.sp();
+      const values = b.values;
+      const inline = this.measure(() => this.valuesOneVar(b, true), this.remainingWidth());
+      if (inline !== null || values.length === 0) {
+        this.valuesOneVar(b, true);
+      } else {
+        this.valuesOneVar(b, false);
+      }
+      return;
+    }
+    const vars = b.variables;
+    this.tok(vars.open);
+    vars.vars.forEach((variable, i) => {
+      if (i > 0) this.sp();
+      this.term(variable);
+    });
+    this.tok(vars.close);
+    this.sp();
+    this.block(b.open, b.close, b.rows.length === 0, () => {
+      for (const row of b.rows) {
+        this.nl();
+        this.tok(row.open);
+        row.values.forEach((value, i) => {
+          if (i > 0) this.sp();
+          this.node(value);
+        });
+        this.tok(row.close);
+      }
+    });
+  }
+  valuesOneVar(b, inline) {
+    if (inline) {
+      this.tok(b.open);
+      for (const value of b.values) {
+        this.sp();
+        this.node(value);
+      }
+      if (b.values.length > 0) this.sp();
+      this.tok(b.close);
+      return;
+    }
+    this.block(b.open, b.close, false, () => {
+      for (const value of b.values) {
+        this.nl();
+        this.node(value);
+      }
+    });
+  }
+  // -------------------------------------------------------------------------
+  // Triples
+  // -------------------------------------------------------------------------
+  triples(t, blank) {
+    this.node(t.subject, blank);
+    if (t.properties) {
+      this.sp();
+      this.propertyList(t.properties);
+    }
+  }
+  propertyList(pl, inline = false) {
+    const indent = this.options.alignPredicates ? this.w.alignment() : this.w.continuation();
+    pl.entries.forEach((entry, i) => {
+      if (i > 0) {
+        if (inline) this.sp();
+        else this.w.newlineWith(indent);
+      }
+      this.node(entry.verb);
+      this.sp();
+      const object = (o) => {
+        this.node(o.node);
+        for (const a of o.annotations) {
+          this.sp();
+          this.node(a);
+        }
+        if (o.comma) this.tok(o.comma);
+      };
+      const wrap = !inline && entry.objects.length > 1 && this.measure(
+        () => entry.objects.forEach((o, j) => (j > 0 && this.sp(), object(o))),
+        this.remainingWidth() - 2,
+        true
+      ) === null;
+      const objectIndent = wrap ? this.w.alignment() : "";
+      entry.objects.forEach((o, j) => {
+        if (j > 0) {
+          if (wrap) this.w.newlineWith(objectIndent);
+          else this.sp();
+        }
+        object(o);
+      });
+      const last = i === pl.entries.length - 1;
+      entry.semicolons.forEach((semi, k) => {
+        if (!last && k === 0) {
+          this.sp();
+          this.tok(semi);
+        } else {
+          this.w.drop(semi);
+        }
+      });
+    });
+  }
+  // -------------------------------------------------------------------------
+  // Nodes (terms, paths, expressions)
+  // -------------------------------------------------------------------------
+  term(t, blank = false) {
+    t.tokens.forEach((token, i) => {
+      if (token.type === "NAME" && token.value !== "a" && !/^(true|false)$/i.test(token.value)) {
+        this.kw(token, blank && i === 0);
+      } else {
+        this.tok(token, blank && i === 0);
+      }
+    });
+  }
+  node(n, blank = false) {
+    switch (n.type) {
+      case "Term":
+        this.term(n, blank);
+        break;
+      case "TripleTerm":
+        this.tok(n.open, blank);
+        this.sp();
+        this.node(n.subject);
+        this.sp();
+        this.term(n.predicate);
+        this.sp();
+        this.node(n.object);
+        this.sp();
+        this.tok(n.close);
+        break;
+      case "ReifiedTriple":
+        this.tok(n.open, blank);
+        this.sp();
+        this.node(n.subject);
+        this.sp();
+        this.term(n.predicate);
+        this.sp();
+        this.node(n.object);
+        if (n.reifier) {
+          this.sp();
+          this.node(n.reifier);
+        }
+        this.sp();
+        this.tok(n.close);
+        break;
+      case "Reifier":
+        this.tok(n.tilde);
+        if (n.id) {
+          this.sp();
+          this.term(n.id);
+        }
+        break;
+      case "AnnotationBlock": {
+        const render = (inline) => {
+          this.tok(n.open);
+          this.sp();
+          this.propertyList(n.properties, inline);
+          this.sp();
+          this.tok(n.close);
+        };
+        render(this.measure(() => render(true), this.remainingWidth()) !== null);
+        break;
+      }
+      case "BlankNodePropertyList":
+        this.tok(n.open, blank);
+        this.sp();
+        this.propertyList(n.properties);
+        this.sp();
+        this.tok(n.close);
+        break;
+      case "Collection":
+        this.tok(n.open, blank);
+        for (const item of n.items) {
+          this.sp();
+          this.node(item);
+        }
+        this.sp();
+        this.tok(n.close);
+        break;
+      case "PathAlternative":
+      case "PathSequence":
+        n.items.forEach((item, i) => {
+          if (i > 0) this.tok(n.separators[i - 1]);
+          this.node(item);
+        });
+        break;
+      case "PathInverse":
+        this.tok(n.caret);
+        this.node(n.item);
+        break;
+      case "PathModified":
+        this.node(n.item);
+        this.tok(n.modifier);
+        break;
+      case "PathNegated":
+        this.tok(n.bang);
+        this.node(n.item);
+        break;
+      case "PathGroup":
+        this.tok(n.open);
+        if (n.path) this.node(n.path);
+        this.tok(n.close);
+        break;
+      default:
+        this.expr(n);
+    }
+  }
+  expr(n) {
+    switch (n.type) {
+      case "Binary":
+        this.expr(n.left);
+        this.sp();
+        this.tok(n.operator);
+        this.sp();
+        this.expr(n.right);
+        break;
+      case "In":
+        this.expr(n.expression);
+        this.sp();
+        if (n.not) {
+          this.kw(n.not);
+          this.sp();
+        }
+        this.kw(n.in);
+        this.sp();
+        this.expr(n.list);
+        break;
+      case "Unary":
+        this.tok(n.operator);
+        this.expr(n.expression);
+        break;
+      case "Bracketed":
+        this.tok(n.open);
+        this.expr(n.expression);
+        this.tok(n.close);
+        break;
+      case "ExpressionList":
+        this.tok(n.open);
+        n.items.forEach((item, i) => {
+          if (i > 0) {
+            this.tok(n.commas[i - 1]);
+            this.sp();
+          }
+          this.expr(item);
+        });
+        this.tok(n.close);
+        break;
+      case "Call":
+        if (n.name.type === "Term") this.term(n.name);
+        else this.w.token(n.name, applyCase(n.name.value, this.options.functionCase));
+        this.tok(n.open);
+        if (n.distinct) {
+          this.kw(n.distinct);
+          this.sp();
+        }
+        n.args.forEach((arg, i) => {
+          if (i > 0) {
+            this.tok(n.commas[i - 1]);
+            this.sp();
+          }
+          this.expr(arg);
+        });
+        if (n.separator) {
+          this.tok(n.separator.semicolon);
+          this.sp();
+          this.kw(n.separator.keyword);
+          this.sp();
+          this.tok(n.separator.equals);
+          this.sp();
+          this.term(n.separator.value);
+        }
+        this.tok(n.close);
+        break;
+      case "Exists":
+        if (n.not) {
+          this.kw(n.not);
+          this.sp();
+        }
+        this.kw(n.keyword);
+        this.sp();
+        this.group(n.group);
+        break;
+      case "OrderCondition":
+      case "Projection":
+        this.condition(n);
+        break;
+      case "TripleTerm":
+      case "Term":
+        this.node(n);
+        break;
+      default:
+        throw new Error(`Unexpected expression ${n.type}`);
+    }
+  }
+};
+
+// src/index.ts
+function countComments(ast) {
+  let count = 0;
+  const seen = /* @__PURE__ */ new Set();
+  const visit = (value) => {
+    if (value === null || typeof value !== "object" || seen.has(value)) return;
+    seen.add(value);
+    if (Array.isArray(value)) {
+      value.forEach(visit);
+      return;
+    }
+    const obj = value;
+    if (typeof obj.offset === "number" && Array.isArray(obj.leading)) {
+      count += obj.leading.length + (obj.trailing ? 1 : 0);
+      return;
+    }
+    Object.values(obj).forEach(visit);
+  };
+  visit(ast);
+  return count;
+}
+function formatAst(ast, options) {
+  const { text, comments } = new Printer(resolveOptions(options)).print(ast);
+  const expected = countComments(ast);
+  if (comments !== expected) {
+    throw new Error(`Internal formatter error: ${expected - comments} comment(s) could not be placed`);
+  }
+  return text;
+}
+function format(query, options) {
+  return formatAst(parse(query), options);
+}
+
+// src/cli.ts
+var HELP = `Usage: sparql-formatter [options] [file ...]
+
+Formats SPARQL 1.2 queries and updates. Reads from stdin when no file is given.
+
+Options:
+  -i, --indent <n|tab>        indentation: number of spaces or "tab" (default: 2)
+      --keyword-case <case>   upper | lower | preserve (default: upper)
+      --function-case <case>  upper | lower | preserve (default: preserve)
+      --no-align              don't align predicates under the first predicate
+      --no-blank-lines        remove blank lines instead of keeping them
+      --compact               put small group patterns on one line
+      --line-width <n>        maximum line width for --compact and VALUES (default: 100)
+  -w, --write                 rewrite the files in place
+  -c, --check                 exit with code 1 if a file is not formatted
+  -v, --version               print the version
+  -h, --help                  print this help
+`;
+function parseCase(value, name) {
+  if (value === void 0) return void 0;
+  if (value === "upper" || value === "lower" || value === "preserve") return value;
+  throw new Error(`--${name} must be one of upper, lower, preserve`);
+}
+function main(argv) {
+  const { values, positionals } = parseArgs({
+    args: argv,
+    allowPositionals: true,
+    options: {
+      indent: { type: "string", short: "i" },
+      "keyword-case": { type: "string" },
+      "function-case": { type: "string" },
+      "no-align": { type: "boolean" },
+      "no-blank-lines": { type: "boolean" },
+      compact: { type: "boolean" },
+      "line-width": { type: "string" },
+      write: { type: "boolean", short: "w" },
+      check: { type: "boolean", short: "c" },
+      version: { type: "boolean", short: "v" },
+      help: { type: "boolean", short: "h" }
+    }
+  });
+  if (values.help) {
+    process.stdout.write(HELP);
+    return 0;
+  }
+  if (values.version) {
+    process.stdout.write(`${"1.0.0"}
+`);
+    return 0;
+  }
+  const options = {
+    keywordCase: parseCase(values["keyword-case"], "keyword-case"),
+    functionCase: parseCase(values["function-case"], "function-case"),
+    alignPredicates: !values["no-align"],
+    preserveBlankLines: !values["no-blank-lines"],
+    compact: values.compact ?? false
+  };
+  if (values.indent !== void 0) {
+    if (values.indent === "tab") options.indent = "	";
+    else if (/^\d+$/.test(values.indent)) options.indent = Number(values.indent);
+    else throw new Error('--indent must be a number or "tab"');
+  }
+  if (values["line-width"] !== void 0) options.lineWidth = Number(values["line-width"]);
+  const inputs = positionals.length > 0 ? positionals : ["-"];
+  if (values.write && positionals.length === 0) throw new Error("--write needs at least one file");
+  let status = 0;
+  for (const file of inputs) {
+    const source = readFileSync(file === "-" ? 0 : file, "utf8");
+    let formatted;
+    try {
+      formatted = format(source, options);
+    } catch (e) {
+      if (e instanceof SparqlSyntaxError) {
+        process.stderr.write(`${file === "-" ? "<stdin>" : file}:${e.line}:${e.column}: ${e.message}
+`);
+        status = 2;
+        continue;
+      }
+      throw e;
+    }
+    const output = formatted === "" ? "" : `${formatted}
+`;
+    if (values.check) {
+      if (output !== source) {
+        process.stderr.write(`${file === "-" ? "<stdin>" : file}: not formatted
+`);
+        status = Math.max(status, 1);
+      }
+    } else if (values.write) {
+      if (output !== source) writeFileSync(file, output);
+    } else {
+      process.stdout.write(output);
+    }
+  }
+  return status;
+}
+try {
+  process.exitCode = main(process.argv.slice(2));
+} catch (e) {
+  process.stderr.write(`sparql-formatter: ${e.message}
+`);
+  process.exitCode = 2;
+}
+//# sourceMappingURL=cli.js.map