@matdata/sparql-formatter 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Matdata
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,245 @@
+# SPARQL Formatter
+
+### A SPARQL 1.2 formatter that keeps your comments where you put them
+
+[![Test](https://github.com/Matdata-eu/sparql-formatter/actions/workflows/test.yml/badge.svg)](https://github.com/Matdata-eu/sparql-formatter/actions/workflows/test.yml)
+[![npm version](https://img.shields.io/npm/v/@matdata/sparql-formatter)](https://www.npmjs.com/package/@matdata/sparql-formatter)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+`@matdata/sparql-formatter` pretty-prints SPARQL queries and updates. It is the formatter of
+[MatGUI](https://github.com/Matdata-eu/MatGUI) and a drop-in replacement for
+[sparql-formatter](https://github.com/sparqling/sparql-formatter) (`spfmt`), with:
+
+- **SPARQL 1.2** — `VERSION`, triple terms `<<( s p o )>>`, reified triples `<< s p o ~ r >>`, reifiers and
+  annotations `{| ... |}`, base direction `"x"@ar--rtl`, and the new functions (`LANGDIR`, `STRLANGDIR`,
+  `hasLANG`, `hasLANGDIR`, `isTRIPLE`, `TRIPLE`, `SUBJECT`, `PREDICATE`, `OBJECT`). SPARQL 1.0 and 1.1 are
+  fully supported too.
+- **Comments that stay in place** — every comment is kept next to the code it belongs to, including comments
+  inside empty groups, between predicates, in expressions and at the end of the query
+  ([sparqling/sparql-formatter#30](https://github.com/sparqling/sparql-formatter/issues/30)).
+- **Safe output** — formatting never changes the meaning of a query and running it twice gives the same
+  result. This is tested on the complete W3C SPARQL 1.0, 1.1 and 1.2 test suites, also with comments inserted
+  between every pair of tokens.
+- **Zero dependencies**, ESM + CommonJS + a browser bundle, TypeScript types and a CLI.
+
+🌐 **Try it**: [playground](https://matdata-eu.github.io/sparql-formatter/)
+
+## Example
+
+```sparql
+#comment 1
+PREFIX :   <http://example.org/>
+select * where { :alice :knows :bob ~:claim1 {| :source ?doc ; :certainty 0.9 |} .
+graph ?g {
+#comment 2
+}
+?city :type :City; # a city
+      :country :Belgium ; :population ?pop
+optional { ?city :name ?name } filter(?pop > 10000) } order by desc(?pop) limit 10
+```
+
+becomes
+
+```sparql
+#comment 1
+PREFIX : <http://example.org/>
+
+SELECT *
+WHERE {
+  :alice :knows :bob ~ :claim1 {| :source ?doc ; :certainty 0.9 |} .
+  GRAPH ?g {
+    #comment 2
+  }
+  ?city :type :City ; # a city
+        :country :Belgium ;
+        :population ?pop .
+  OPTIONAL {
+    ?city :name ?name .
+  }
+  FILTER (?pop > 10000)
+}
+ORDER BY DESC(?pop)
+LIMIT 10
+```
+
+## Installation
+
+```bash
+npm install @matdata/sparql-formatter
+```
+
+## Usage
+
+### JavaScript / TypeScript
+
+```js
+import { format } from "@matdata/sparql-formatter";
+
+const pretty = format("select * where {?s ?p ?o}");
+// SELECT *
+// WHERE {
+//   ?s ?p ?o .
+// }
+
+format(query, { indent: 4, compact: true });
+```
+
+CommonJS works too: `const { format } = require("@matdata/sparql-formatter");`
+
+`format` throws a `SparqlSyntaxError` (with `line`, `column` and `offset`) when the input is not valid SPARQL:
+
+```js
+import { format, isValid, SparqlSyntaxError } from "@matdata/sparql-formatter";
+
+try {
+  format("SELECT * WHERE { ?s ?p }");
+} catch (e) {
+  if (e instanceof SparqlSyntaxError) console.log(e.line, e.column, e.message);
+  // 1 24 "Expected an RDF term or a variable but found '}' (line 1, column 24)"
+}
+
+isValid("SELECT * {}"); // true
+```
+
+### Drop-in replacement for `sparql-formatter`
+
+The package exports an `spfmt` object with the same `format(query, formattingMode, indentDepth)` signature as
+[sparql-formatter](https://github.com/sparqling/sparql-formatter), so switching is a one-line change:
+
+```diff
+- import { spfmt } from "sparql-formatter";
++ import { spfmt } from "@matdata/sparql-formatter";
+
+  spfmt.format(query);              // formattingMode "default"
+  spfmt.format(query, "compact");
+  spfmt.format(query, "default", 4);
+```
+
+The `turtle` and `jsonld` modes of sparql-formatter are not supported; use `parse()` to get the syntax tree.
+
+### In the browser
+
+```html
+<script src="https://cdn.jsdelivr.net/npm/@matdata/sparql-formatter/dist/spfmt.min.js"></script>
+<script>
+  spfmt.format("select * where {?s ?p ?o}");
+  sparqlFormatter.format("select * where {?s ?p ?o}", { indent: 4 }); // full API
+</script>
+```
+
+Or as an ES module: `import { format } from "https://cdn.jsdelivr.net/npm/@matdata/sparql-formatter/+esm";`
+
+### Command line
+
+```bash
+npx @matdata/sparql-formatter query.rq          # print the formatted query
+cat query.rq | npx @matdata/sparql-formatter    # read from stdin
+npx @matdata/sparql-formatter --write *.rq *.ru # format files in place
+npx @matdata/sparql-formatter --check *.rq      # exit code 1 if a file isn't formatted (for CI)
+```
+
+Run `sparql-formatter --help` for all options (`--indent`, `--keyword-case`, `--function-case`, `--no-align`,
+`--no-blank-lines`, `--compact`, `--line-width`).
+
+## Options
+
+| Option               | Default      | Description                                                                                      |
+| -------------------- | ------------ | ------------------------------------------------------------------------------------------------ |
+| `indent`             | `2`          | Number of spaces, or the indent string itself (e.g. `"\t"`).                                     |
+| `keywordCase`        | `"upper"`    | Case of keywords (`SELECT`, `WHERE`, `OPTIONAL`, ...): `"upper"`, `"lower"` or `"preserve"`.     |
+| `functionCase`       | `"preserve"` | Case of built-in function names (`regex`, `STR`, `COUNT`, ...): `"upper"`, `"lower"`, `"preserve"`. |
+| `alignPredicates`    | `true`       | Align the predicates of a subject under its first predicate. When `false`, indent them instead.  |
+| `preserveBlankLines` | `true`       | Keep (at most one) blank line where the query has blank lines between statements.                |
+| `compact`            | `false`      | Put group patterns with a single triple on one line: `OPTIONAL { ?s :p ?o }`.                     |
+| `lineWidth`          | `100`        | Line width used by `compact` and to wrap long object and `VALUES` lists.                          |
+| `insertWhere`        | `true`       | Write the optional `WHERE` keyword of `SELECT`, `CONSTRUCT` and `DESCRIBE` queries.               |
+
+## Formatting style
+
+- Keywords are upper case; prefixed names, IRIs, variables and literals are written exactly as in the input.
+- The prologue (`BASE`, `PREFIX`, `VERSION`) is followed by a blank line.
+- Each clause (`SELECT`, `FROM`, `WHERE`, `GROUP BY`, `HAVING`, `ORDER BY`, `LIMIT`, `OFFSET`, `VALUES`) starts
+  on a new line; every pattern in a group gets its own line.
+- Triple patterns end with ` .`, predicate lists with ` ;` are aligned, and objects are separated by `, `.
+- The optional `.` after `OPTIONAL { }`, `FILTER`, ... and superfluous `;` are removed; their comments are kept.
+- Long object lists and `VALUES` lists are wrapped, one item per line.
+
+### Comments
+
+Comments are attached to the code around them:
+
+- a comment at the end of a line stays at the end of that line;
+- a comment on its own line stays on its own line, before the code that follows it, at that code's indentation;
+- comments before a closing `}` stay inside the block;
+- blank lines before comments are kept.
+
+If a comment ends up in the middle of an expression, the formatter continues the expression on the next line
+rather than moving the comment. The formatter never drops a comment: if it can't place one, it throws an error
+instead of returning a query without it.
+
+## What is checked
+
+The parser implements the complete [SPARQL 1.2 grammar](https://www.w3.org/TR/sparql12-query/#sparqlGrammar)
+for queries and updates, including the grammar notes (no variables in `INSERT DATA`, no blank nodes in
+`DELETE`, the number of values in `VALUES` rows, no reifiers after property paths, ...). It does not check
+rules that go beyond the grammar, such as variable scoping in `SELECT` and `BIND`, grouping rules of
+aggregates, or blank node label reuse across basic graph patterns: formatting such a query works.
+
+## API
+
+| Export                       | Description                                                            |
+| ---------------------------- | ---------------------------------------------------------------------- |
+| `format(query, options?)`    | Format a query or update. Also the default export.                     |
+| `isValid(query)`             | `true` when the query is syntactically valid SPARQL 1.2.               |
+| `parse(query)`               | Parse into a concrete syntax tree (`Query` or `Update`).               |
+| `formatAst(ast, options?)`   | Format a tree returned by `parse`.                                     |
+| `tokenize(query)`            | The tokens of a query, with the comments attached to them.             |
+| `spfmt`                      | `{ format, parse, tokenize }`, compatible with `sparql-formatter`.      |
+| `SparqlSyntaxError`          | Error thrown for invalid input (`line`, `column`, `offset`, `expected`). |
+
+## Development
+
+```bash
+npm install
+npm test            # unit tests + W3C test suites (Node 22+, runs the TypeScript sources directly)
+npm run typecheck
+npm run lint        # prettier --check
+npm run build       # dist/: ESM, CommonJS, browser bundle, CLI and type declarations
+npm run test:dist   # smoke test of the built package
+```
+
+The source is in `src/`: `lexer.ts` (tokens and comments), `parser.ts` (recursive-descent parser),
+`printer.ts` (layout) and `writer.ts` (output buffer that places the comments).
+
+The W3C test queries in `test/w3c` are imported from [w3c/rdf-tests](https://github.com/w3c/rdf-tests) with:
+
+```bash
+git clone --depth 1 https://github.com/w3c/rdf-tests
+node scripts/import-w3c-tests.mjs rdf-tests
+```
+
+## Releasing
+
+Releases are published to npm by the [publish workflow](.github/workflows/publish.yml) when a GitHub release is
+published. The version is taken from the release tag (`v1.2.3` → `1.2.3`; a pre-release such as `v1.3.0-beta.1`
+is published with the `next` dist-tag).
+
+The workflow uses [npm trusted publishing](https://docs.npmjs.com/trusted-publishers): there is no npm token in
+the repository. One-time setup on [npmjs.com](https://www.npmjs.com/package/@matdata/sparql-formatter) →
+**Settings** → **Trusted Publisher** → **GitHub Actions**:
+
+- Organization or user: `Matdata-eu`
+- Repository: `sparql-formatter`
+- Workflow filename: `publish.yml`
+
+npm only lets you add a trusted publisher to a package that already exists, so the very first version has to be
+published once by hand (`npm run build && npm publish --access public`) by a member of the `@matdata` npm
+organization.
+
+The [playground](https://matdata-eu.github.io/sparql-formatter/) is deployed to GitHub Pages on every push to
+`main` (repository **Settings** → **Pages** → Source: **GitHub Actions**).
+
+## License
+
+[MIT](LICENSE). The test queries in `test/w3c` come from the W3C test suites and are distributed under the
+[W3C test suite licenses](https://www.w3.org/Consortium/Legal/2008/04-testsuite-copyright.html).

package/dist/ast.d.ts

@@ -0,0 +1,447 @@
+/**
+ * Concrete syntax tree for SPARQL 1.2 queries and updates.
+ *
+ * The tree keeps a reference to every source token (keywords, punctuation,
+ * terms) so the printer can re-emit the comments attached to them and keep
+ * the original spelling of terms.
+ */
+import type { Token } from "./lexer.js";
+/**
+ * A term printed as the concatenation of its tokens: an IRI, a variable, a
+ * literal (`"x"@en`, `"1"^^xsd:int`), a signed number (`-1`), a blank node,
+ * `a`, `true`, `NIL` (`()`), `ANON` (`[]`), `UNDEF`.
+ */
+export interface Term {
+    type: "Term";
+    tokens: Token[];
+}
+/** `<<( s p o )>>` */
+export interface TripleTerm {
+    type: "TripleTerm";
+    open: Token;
+    subject: Node;
+    predicate: Term;
+    object: Node;
+    close: Token;
+}
+/** `<< s p o ~ r >>` */
+export interface ReifiedTriple {
+    type: "ReifiedTriple";
+    open: Token;
+    subject: Node;
+    predicate: Term;
+    object: Node;
+    reifier: Reifier | null;
+    close: Token;
+}
+/** `~ id` */
+export interface Reifier {
+    type: "Reifier";
+    tilde: Token;
+    id: Term | null;
+}
+/** `{| p o ; ... |}` */
+export interface AnnotationBlock {
+    type: "AnnotationBlock";
+    open: Token;
+    properties: PropertyList;
+    close: Token;
+}
+/** `( a b c )` */
+export interface Collection {
+    type: "Collection";
+    open: Token;
+    items: Node[];
+    close: Token;
+}
+/** `[ p o ; ... ]` */
+export interface BlankNodePropertyList {
+    type: "BlankNodePropertyList";
+    open: Token;
+    properties: PropertyList;
+    close: Token;
+}
+export interface ObjectEntry {
+    node: Node;
+    annotations: (Reifier | AnnotationBlock)[];
+    /** The `,` that follows this object, if any. */
+    comma: Token | null;
+}
+export interface PropertyEntry {
+    verb: Node;
+    objects: ObjectEntry[];
+    /** The `;` tokens that follow this entry (`; ;` is legal). */
+    semicolons: Token[];
+}
+export interface PropertyList {
+    type: "PropertyList";
+    /** `;` tokens that appear before the first entry are not legal; entries only. */
+    entries: PropertyEntry[];
+}
+/** A subject with its property list: `?s :p ?o ; :q ?r` */
+export interface Triples {
+    type: "Triples";
+    subject: Node;
+    properties: PropertyList | null;
+}
+export interface PathAlternative {
+    type: "PathAlternative";
+    items: Node[];
+    separators: Token[];
+}
+export interface PathSequence {
+    type: "PathSequence";
+    items: Node[];
+    separators: Token[];
+}
+export interface PathInverse {
+    type: "PathInverse";
+    caret: Token;
+    item: Node;
+}
+export interface PathModified {
+    type: "PathModified";
+    item: Node;
+    modifier: Token;
+}
+export interface PathNegated {
+    type: "PathNegated";
+    bang: Token;
+    item: Node;
+}
+/** `( path )` in a property path, also `!( a | ^b )` */
+export interface PathGroup {
+    type: "PathGroup";
+    open: Token;
+    path: Node | null;
+    close: Token;
+}
+export interface Binary {
+    type: "Binary";
+    left: Node;
+    operator: Token;
+    right: Node;
+}
+/** `x IN (...)` / `x NOT IN (...)` */
+export interface InExpression {
+    type: "In";
+    expression: Node;
+    not: Token | null;
+    in: Token;
+    list: ExpressionList;
+}
+export interface Unary {
+    type: "Unary";
+    operator: Token;
+    expression: Node;
+}
+export interface Bracketed {
+    type: "Bracketed";
+    open: Token;
+    expression: Node;
+    close: Token;
+}
+/** `( e1, e2 )` or `()` */
+export interface ExpressionList {
+    type: "ExpressionList";
+    open: Token;
+    items: Node[];
+    commas: Token[];
+    close: Token;
+}
+/** A built-in call, aggregate or function call. */
+export interface Call {
+    type: "Call";
+    /** A NAME token for built-ins, a Term for IRI function calls. */
+    name: Token | Term;
+    builtin: boolean;
+    /** The opening parenthesis; a call written as `NOW()` has no args. */
+    open: Token;
+    distinct: Token | null;
+    args: Node[];
+    commas: Token[];
+    /** GROUP_CONCAT separator: `; SEPARATOR = "x"` */
+    separator: {
+        semicolon: Token;
+        keyword: Token;
+        equals: Token;
+        value: Term;
+    } | null;
+    close: Token;
+}
+/** `EXISTS { }` / `NOT EXISTS { }` */
+export interface Exists {
+    type: "Exists";
+    not: Token | null;
+    keyword: Token;
+    group: GroupGraphPattern;
+}
+export interface GroupGraphPattern {
+    type: "GroupGraphPattern";
+    open: Token;
+    subSelect: SubSelect | null;
+    items: PatternItem[];
+    close: Token;
+}
+export interface PatternItem {
+    node: Node;
+    /** The `.` that follows the item, if any. */
+    dot: Token | null;
+}
+export interface Union {
+    type: "Union";
+    groups: GroupGraphPattern[];
+    keywords: Token[];
+}
+export interface Optional {
+    type: "Optional";
+    keyword: Token;
+    group: GroupGraphPattern;
+}
+export interface Minus {
+    type: "Minus";
+    keyword: Token;
+    group: GroupGraphPattern;
+}
+export interface GraphPattern {
+    type: "Graph";
+    keyword: Token;
+    name: Term;
+    group: GroupGraphPattern;
+}
+export interface Service {
+    type: "Service";
+    keyword: Token;
+    silent: Token | null;
+    name: Term;
+    group: GroupGraphPattern;
+}
+export interface Filter {
+    type: "Filter";
+    keyword: Token;
+    constraint: Node;
+}
+export interface Bind {
+    type: "Bind";
+    keyword: Token;
+    open: Token;
+    expression: Node;
+    as: Token;
+    variable: Term;
+    close: Token;
+}
+export interface Values {
+    type: "Values";
+    keyword: Token;
+    block: DataBlock;
+}
+export interface DataBlockRow {
+    /** `( v1 v2 )`; for NIL rows `open`/`close` are the `(` `)` tokens and values is empty. */
+    open: Token;
+    values: Node[];
+    close: Token;
+}
+export interface DataBlock {
+    type: "DataBlock";
+    /** Single variable form: `?x { ... }` */
+    variable: Term | null;
+    /** Multi-variable form: `( ?a ?b ) { ... }` */
+    variables: {
+        open: Token;
+        vars: Term[];
+        close: Token;
+    } | null;
+    open: Token;
+    /** Values of the single-variable form. */
+    values: Node[];
+    /** Rows of the multi-variable form. */
+    rows: DataBlockRow[];
+    close: Token;
+}
+export interface PrologueDecl {
+    type: "Base" | "Prefix" | "Version";
+    keyword: Token;
+    /** PREFIX only */
+    prefix: Token | null;
+    value: Token;
+}
+export interface Projection {
+    type: "Projection";
+    open: Token;
+    expression: Node;
+    as: Token | null;
+    variable: Term | null;
+    close: Token;
+}
+export interface SelectClause {
+    type: "SelectClause";
+    keyword: Token;
+    modifier: Token | null;
+    star: Token | null;
+    items: (Term | Projection)[];
+}
+export interface DatasetClause {
+    type: "DatasetClause";
+    from: Token;
+    named: Token | null;
+    iri: Term;
+}
+export interface WhereClause {
+    keyword: Token | null;
+    group: GroupGraphPattern;
+}
+export interface OrderCondition {
+    type: "OrderCondition";
+    direction: Token | null;
+    expression: Node;
+}
+export interface SolutionModifier {
+    groupBy: {
+        group: Token;
+        by: Token;
+        conditions: Node[];
+    } | null;
+    having: {
+        keyword: Token;
+        conditions: Node[];
+    } | null;
+    orderBy: {
+        order: Token;
+        by: Token;
+        conditions: Node[];
+    } | null;
+    /** LIMIT and OFFSET in source order */
+    limitOffset: {
+        keyword: Token;
+        value: Token;
+    }[];
+}
+export interface SelectQuery {
+    type: "Select";
+    select: SelectClause;
+    datasets: DatasetClause[];
+    where: WhereClause;
+    modifiers: SolutionModifier;
+}
+export interface SubSelect extends Omit<SelectQuery, "type"> {
+    type: "SubSelect";
+    values: Values | null;
+}
+/** Triples inside `{ }` of a CONSTRUCT template or quad data */
+export interface TriplesTemplate {
+    type: "TriplesTemplate";
+    open: Token;
+    items: PatternItem[];
+    close: Token;
+}
+export interface ConstructQuery {
+    type: "Construct";
+    keyword: Token;
+    template: TriplesTemplate | null;
+    datasets: DatasetClause[];
+    /** Full form: WHERE clause. Short form (`CONSTRUCT WHERE { triples }`): `where.keyword` + `shortTemplate` */
+    where: WhereClause | null;
+    shortForm: {
+        keyword: Token;
+        template: TriplesTemplate;
+    } | null;
+    modifiers: SolutionModifier;
+}
+export interface DescribeQuery {
+    type: "Describe";
+    keyword: Token;
+    star: Token | null;
+    items: Term[];
+    datasets: DatasetClause[];
+    where: WhereClause | null;
+    modifiers: SolutionModifier;
+}
+export interface AskQuery {
+    type: "Ask";
+    keyword: Token;
+    datasets: DatasetClause[];
+    where: WhereClause;
+    modifiers: SolutionModifier;
+}
+export type QueryForm = SelectQuery | ConstructQuery | DescribeQuery | AskQuery;
+export interface Query {
+    type: "Query";
+    prologue: PrologueDecl[];
+    form: QueryForm;
+    values: Values | null;
+    eof: Token;
+}
+/** Keyword/IRI sequences such as `GRAPH <g>`, `DEFAULT`, `SILENT` */
+export interface Words {
+    type: "Words";
+    tokens: (Token | Term)[];
+}
+export interface QuadsGraph {
+    type: "QuadsGraph";
+    keyword: Token;
+    name: Term;
+    template: TriplesTemplate;
+}
+export interface Load {
+    type: "Load";
+    keyword: Token;
+    silent: Token | null;
+    iri: Term;
+    into: Words | null;
+}
+/** CLEAR, DROP, CREATE */
+export interface GraphManagement {
+    type: "GraphManagement";
+    keyword: Token;
+    silent: Token | null;
+    target: Words;
+}
+/** ADD, MOVE, COPY */
+export interface GraphTransfer {
+    type: "GraphTransfer";
+    keyword: Token;
+    silent: Token | null;
+    from: Words;
+    to: Token;
+    target: Words;
+}
+/** INSERT DATA, DELETE DATA, DELETE WHERE */
+export interface QuadDataOperation {
+    type: "QuadData";
+    keywords: [Token, Token];
+    quads: TriplesTemplate;
+}
+export interface Modify {
+    type: "Modify";
+    with: {
+        keyword: Token;
+        iri: Term;
+    } | null;
+    delete: {
+        keyword: Token;
+        quads: TriplesTemplate;
+    } | null;
+    insert: {
+        keyword: Token;
+        quads: TriplesTemplate;
+    } | null;
+    using: {
+        keyword: Token;
+        named: Token | null;
+        iri: Term;
+    }[];
+    where: WhereClause;
+}
+export type UpdateOperation = Load | GraphManagement | GraphTransfer | QuadDataOperation | Modify;
+export interface UpdatePart {
+    prologue: PrologueDecl[];
+    operation: UpdateOperation | null;
+    semicolon: Token | null;
+}
+export interface Update {
+    type: "Update";
+    parts: UpdatePart[];
+    eof: Token;
+}
+export type Node = Term | TripleTerm | ReifiedTriple | Reifier | AnnotationBlock | Collection | BlankNodePropertyList | PropertyList | Triples | PathAlternative | PathSequence | PathInverse | PathModified | PathNegated | PathGroup | Binary | InExpression | Unary | Bracketed | ExpressionList | Call | Exists | GroupGraphPattern | Union | Optional | Minus | GraphPattern | Service | Filter | Bind | Values | DataBlock | Projection | OrderCondition | SubSelect | TriplesTemplate | QuadsGraph;
+export type Ast = Query | Update;