simple-graph-query 3.0.1 → 3.2.0

package/LANGUAGE.md

@@ -0,0 +1,317 @@
+<!-- GENERATED FILE — DO NOT EDIT.
+     Built from src/forge-antlr/ForgeLexer.g4, src/forge-antlr/Forge.g4, and
+     the evaluator's builtin tables by scripts/generate-lang-ref.mjs.
+     Regenerate with: npm run docs:lang -->
+
+# The Expression Language
+
+This library evaluates a single **expression** (the `parseExpr` grammar entry
+point) against a data instance. The language is the expression fragment of
+[Forge](https://forge-fm.org) (itself a dialect of Alloy), with a few
+extensions (string literals, label access) and deliberate omissions.
+
+**Everything is a set of tuples.** A sig name denotes the set of its atoms, a
+relation name the set of its tuples, and a scalar (one atom, one number, one
+string) is a singleton set. Boolean formulas evaluate to `true`/`false`.
+
+**There is no temporal fragment.** The temporal operators (`always`,
+`eventually`, `after`, `before`, `once`, `historically`, `until`,
+`release`, `since`, `triggered`) and primed expressions (`e'`) were
+removed from the grammar; their syntax is a parse error, and the former
+keywords are ordinary identifiers.
+
+## Lexical structure
+
+- **STRING_TOK** — A double-quoted string literal: `"dark blue"`. Escapes: `\"`, `\\`, `\n`, `\t`, `\r`, `\0`; any other escaped character stands for itself.
+- **NUM_CONST_TOK** — An integer or decimal literal: `42`, `3.5`. Negate with a leading `-`.
+- **QUOTED_IDENTIFIER_TOK** — A backquoted name: `` `n0 ``. Names an atom by id, and escapes reserved words.
+- **IDENTIFIER_TOK** — A name: letters, digits, `_`, `$`, `/` (not starting with a digit).
+
+Comments run from `//` or `--` to the end of the line, or between `/*`
+and `*/`. A `#lang` line is ignored.
+
+### Reserved words
+
+`Int`, `abstract`, `all`, `and`, `as`, `assert`, `bind`, `but`, `check`, `checked`, `consistent`, `disj`, `else`, `eval`, `exactly`, `example`, `expect`, `extends`, `for`, `forge_error`, `fun`, `func`, `iden`, `iff`, `implies`, `in`, `inconsistent`, `inst`, `is`, `let`, `lone`, `necessary`, `ni`, `no`, `none`, `not`, `one`, `open`, `option`, `or`, `pfunc`, `pred`, `run`, `sat`, `set`, `sexpr`, `sig`, `some`, `sufficient`, `suite`, `sum`, `test`, `theorem`, `this`, `two`, `univ`, `unsat`, `var`, `wheat`, `with`, `xor`
+
+A data-instance entity whose name collides with a reserved word is still
+reachable by backquoting: `` `set` `` names the *atom* with id `set`.
+
+### Names that must be backquoted
+
+`/` matches the identifier pattern but lexes as the qualified-name separator. A name that is exactly `/` can only be written backquoted (`` `/` ``); a name that merely contains it, like `foo/bar`, is an ordinary identifier and needs no quoting.
+
+### Machine-readable form
+
+Code that *generates* expressions needs this page's content as data rather than
+as prose. [`docs/sgq-language.json`](docs/sgq-language.json) carries it: the
+bare-identifier character classes, both quoting forms with their escape tables,
+every spelling a bare identifier cannot carry, and the whole cascade below —
+each construct with its spellings, its precedence, and the level each of its
+operands descends to. It is generated from this same grammar, ships in the npm
+package, and is checked against the real lexer and parser by a test.
+
+The parenthesisation rule is the one thing worth restating: a subexpression
+needs parentheses exactly when its own `precedence` is below the level of the
+slot it fills. Those levels are not always the neighbouring one — `+` takes
+its right operand two levels in, so `a + #b` is a parse error.
+
+## Operators and precedence
+
+Constructs are listed loosest-binding first; higher numbers bind tighter.
+"Evaluates ✗" marks syntax the grammar accepts but the evaluator rejects.
+
+| # | Construct | Example | Operators | Yields | Evaluates | Meaning |
+|---|-----------|---------|-----------|--------|:---------:|---------|
+| 1 | let binding | `let x = e \| body` | — | — | ✗ | Bind names to expression values inside a body. Parses, but evaluation is not implemented and fails. |
+| 1 | bind | `bind x = e \| body` | — | — | ✗ | Alloy `bind`. Parses, but evaluation is rejected. |
+| 1 | quantified formula | `all x: S \| body` | — | boolean (`sum` number) | ✓ | Quantifiers `all`, `no`, `some`, `lone`, `one`, `two`, and the aggregator `sum x: S \| intExpr`. `disj` requires the bound variables to take pairwise-distinct values. The body must use the bar form (`\| expr`). |
+| 2 | disjunction | `a or b` | `\|\|` / `or` | boolean | ✓ | Logical or (short-circuits). |
+| 3 | exclusive or | `a xor b` | `xor` | boolean | ✓ | Logical exclusive or. |
+| 4 | biconditional | `a iff b` | `<=>` / `iff` | boolean | ✓ | Logical if-and-only-if. |
+| 5 | implication | `a implies b else c` | `implies` / `=>`, `else` | boolean | ✓ | Implication, with an optional else branch (`a => b else c` means `(a and b) or ((not a) and c)`). |
+| 6 | conjunction | `a and b` | `&&` / `and` | boolean | ✓ | Logical and (short-circuits). |
+| 7 | negation | `not a` | `!` / `not` | boolean | ✓ | Logical negation of a boolean formula. |
+| 8 | comparison | `a in b` | `in`, `=`, `<`, `>`, `<=` / `=<`, `>=`, `ni`, `is` | boolean | ✓ | Subset (`in`), reverse containment (`ni`), set equality (`=`), and numeric comparisons. A scalar is a singleton set, so `in` doubles as membership. A leading `!`/`not` negates the comparison. `is` parses but its evaluation is rejected. |
+| 9 | multiplicity test | `some e` | `no`, `some`, `lone`, `one`, `two`, `set` | boolean (`set` operand) | ✓ | Cardinality predicates over a set: `no` (empty), `some` (non-empty), `lone` (at most one), `one` (exactly one), `two` (exactly two). `set e` is the identity. |
+| 10 | union / difference | `a + b` | `+`, `-` | relation | ✓ | Set union and set difference. (For integer arithmetic use the `add[...]`/`subtract[...]` builtins; `1 + 2` is the two-element set.) |
+| 11 | cardinality | `#e` | `#` | number | ✓ | Number of tuples in the set. |
+| 12 | override | `a ++ b` | `++` | relation | ✓ | Relational override: tuples of `b`, plus the tuples of `a` whose first atom is not a first atom of `b`. |
+| 13 | intersection | `a & b` | `&` | relation | ✓ | Set intersection. |
+| 14 | product | `a -> b` | `->` | relation | ✓ | Cartesian product. Multiplicity annotations (`a one -> lone b`) are declaration syntax and are rejected in expressions. |
+| 15 | restriction | `S <: r` | `<:`, `:>` | relation | ✓ | Domain restriction (`S <: r`: tuples of `r` starting in `S`) and range restriction (`r :> S`: tuples ending in `S`). |
+| 16 | box join / builtin call | `f[a, b]` | `[`, `]` | — | ✓ | `a[b]` is the box join `b.a`. When the callee names a builtin (see the builtin table) it is a function call instead: `add[1, 2]`. |
+| 17 | join | `a.f` | `.` | relation | ✓ | Relational join: match the last column of the left operand against the first column of the right. |
+| 17 | applied name (grammar corner) | `x.f[a]` | — | — | ✗ | A bracket application whose callee is parsed as a bare name inside a dot-chain. Redundant with box join; evaluation is not implemented. |
+| 18 | unary prefixes | `^r` | `~`, `^`, `*`, `@:`, `@str:`, `@bool:`, `@num:` | relation (`@:` string, `@str:` string, `@bool:` boolean, `@num:` number) | ✓ | `~r` transpose, `^r` transitive closure, `*r` reflexive-transitive closure. `@:`/`@str:` label of an atom as a string, `@bool:`/`@num:` label converted to boolean/number (extensions; not Forge). |
+| 19 | constant | `none` | — | — (`none` relation, `univ` relation, `iden` relation) | ✓ | `none` (empty set), `univ` (all atoms), `iden` (identity relation), integer literals (incl. negative), and `"..."` string literals. |
+| 19 | name | `Person` | — | relation | ✓ | A type, relation, atom, or bound variable. An unresolved name evaluates to the empty set and raises an `unresolved-name` diagnostic. |
+| 19 | @name | `@x` | — | — | ✗ | Alloy-specific; evaluation is rejected. |
+| 19 | atom literal | <code>&#96;n0</code> | — | relation | ✓ | The atom with exactly this id, bypassing type/relation/variable lookup. |
+| 19 | this | `this` | — | — | ✗ | Alloy-specific; evaluation is rejected. |
+| 19 | set comprehension | `{x: S \| body}` | — | relation | ✓ | The set of bindings satisfying the body. Multiple binders build a relation: `{x: A, y: B \| body}` is a set of pairs. |
+| 19 | parentheses | `(e)` | — | operand | ✓ | Grouping. |
+| 19 | block | `{ e1 e2 }` | — | boolean | ✓ | A conjunction of boolean expressions, separated by whitespace (there is no `;` in the language). |
+| 19 | s-expression | `sexpr` | — | — | ✗ | Reserved for internal use; evaluation is rejected. |
+
+## Builtin functions
+
+Called with square brackets, e.g. `add[1, 2]`.
+
+| Builtins | Arity | Notes |
+|----------|-------|-------|
+| `add`, `subtract`, `multiply`, `divide`, `remainder` | 2 | Integer/real arithmetic. `divide` is real division. |
+| `abs`, `sign`, `floor`, `ceil` | 1 | |
+| `min`, `max`, `sum` | set | Aggregate over a set; numeric strings resolve to numbers. `sum` also has a quantifier form `sum x: S \| intExpr`. |
+
+Builtin names are **not** reserved words: a data instance that names an
+entity `add` shadows the builtin (see issue #59).
+
+## Grammar
+
+The expression grammar, with token literals substituted in. Pattern tokens
+(see [Lexical structure](#lexical-structure)) keep their names.
+
+```
+parseExpr
+    : expr EOF
+    ;
+
+expr
+    : expr1
+    | 'let' letDeclList blockOrBar
+    | 'bind' letDeclList blockOrBar
+    | quant 'disj'? quantDeclList blockOrBar
+    ;
+
+expr1
+    : expr1_5
+    | expr1 ('||' | 'or') expr1_5
+    ;
+
+letDeclList
+    : letDecl
+    | letDecl ',' letDeclList
+    ;
+
+blockOrBar
+    : block
+    | '|' expr
+    ;
+
+quant
+    : 'all'
+    | 'no'
+    | 'sum'
+    | mult
+    ;
+
+quantDeclList
+    : quantDecl
+    | quantDecl ',' quantDeclList
+    ;
+
+expr1_5
+    : expr2
+    | expr1_5 'xor' expr2
+    ;
+
+letDecl
+    : name '=' expr
+    ;
+
+block
+    : '{' expr* '}'
+    ;
+
+mult
+    : 'lone'
+    | 'some'
+    | 'one'
+    | 'two'
+    ;
+
+quantDecl
+    : 'disj'? nameList ':' 'set'? expr
+    ;
+
+expr2
+    : expr3
+    | expr2 ('<=>' | 'iff') expr3
+    ;
+
+name
+    : IDENTIFIER_TOK
+    | QUOTED_IDENTIFIER_TOK
+    ;
+
+nameList
+    : name
+    | name ',' nameList
+    ;
+
+expr3
+    : expr4
+    | expr4 ('implies' | '=>') expr3 ('else' expr3)?
+    ;
+
+expr4
+    : expr5
+    | expr4 ('&&' | 'and') expr5
+    ;
+
+expr5
+    : expr6
+    | ('!' | 'not') expr5
+    ;
+
+expr6
+    : expr7
+    | expr6 ('!' | 'not')? compareOp expr7
+    ;
+
+expr7
+    : expr8
+    | ('no' | 'some' | 'lone' | 'one' | 'two' | 'set') expr8
+    ;
+
+compareOp
+    : 'in'
+    | '='
+    | '<'
+    | '>'
+    | ('<=' | '=<')
+    | '>='
+    | 'is'
+    | 'ni'
+    ;
+
+expr8
+    : expr9
+    | expr8 ('+' | '-') expr10
+    ;
+
+expr9
+    : expr10
+    | '#' expr9
+    ;
+
+expr10
+    : expr11
+    | expr10 '++' expr11
+    ;
+
+expr11
+    : expr12
+    | expr11 '&' expr12
+    ;
+
+expr12
+    : expr13
+    | expr12 arrowOp expr13
+    ;
+
+expr13
+    : expr14
+    | expr13 ('<:' | ':>') expr14
+    ;
+
+arrowOp
+    : (mult | 'set')? '->' (mult | 'set')?
+    ;
+
+expr14
+    : expr15
+    | expr14 '[' exprList ']'
+    ;
+
+expr15
+    : expr17
+    | expr15 '.' expr17
+    | name '[' exprList ']'
+    ;
+
+exprList
+    : expr
+    | expr ',' exprList
+    ;
+
+expr17
+    : expr18
+    | ('~' | '^' | '*' | '@:' | '@str:' | '@bool:' | '@num:') expr17
+    ;
+
+expr18
+    : const
+    | qualName
+    | '@' name
+    | '`' name
+    | 'this'
+    | '{' quantDeclList blockOrBar '}'
+    | '(' expr ')'
+    | block
+    | sexpr
+    ;
+
+const
+    : 'none'
+    | 'univ'
+    | 'iden'
+    | '-'? number
+    | STRING_TOK
+    ;
+
+qualName
+    : ('this' '/')? (name '/')* name
+    | 'Int'
+    | 'sum'
+    ;
+
+sexpr
+    : 'sexpr'
+    ;
+
+number
+    : NUM_CONST_TOK
+    ;
+```

package/README.md

@@ -2,6 +2,23 @@
 
 A TypeScript library for evaluating relational + some more expressions with a browser-compatible UMD bundle.
 
+The full language — operators, precedence, reserved words, builtins, and the
+grammar itself — is documented in [LANGUAGE.md](LANGUAGE.md), which is
+**generated from the ANTLR grammars** (`npm run docs`) and kept fresh by
+a test. Note that the language has no temporal fragment: the temporal
+operators (`always`, `until`, ...) and primed expressions (`e'`) were removed
+from the grammar, and their former keywords are ordinary identifiers.
+
+Tools that *generate* expressions should read
+[`docs/sgq-language.json`](docs/sgq-language.json) instead of copying the rules
+into their own source. It is generated from the same grammar, ships in the
+package, and states the bare-identifier character classes, the reserved
+spellings, the escape tables for both quoting forms, the builtins, and the
+precedence cascade — each construct with its operator spellings and the level
+each operand descends to, which is what decides parentheses.
+`test/language-manifest.test.ts` checks it by building expressions from the
+manifest alone and running them through the lexer and parser.
+
 ## License
 
 MIT

package/dist/ForgeExprEvaluator.d.ts

@@ -1,12 +1,25 @@
 import { AbstractParseTreeVisitor } from "antlr4ts/tree/AbstractParseTreeVisitor";
 import { ForgeVisitor } from "./forge-antlr/ForgeVisitor";
-import { ExprContext, Expr1Context, Expr1_5Context, Expr2Context, Expr3Context, Expr4Context, Expr4_5Context, Expr5Context, Expr6Context, Expr7Context, Expr8Context, Expr9Context, Expr10Context, Expr11Context, Expr12Context, Expr13Context, Expr14Context, Expr15Context, Expr16Context, Expr17Context, Expr18Context, ExprListContext, NameContext, PredDeclContext, BlockContext, QualNameContext, QuantDeclListContext, NameListContext, QuantDeclContext } from "./forge-antlr/ForgeParser";
+import { ExprContext, Expr1Context, Expr1_5Context, Expr2Context, Expr3Context, Expr4Context, Expr5Context, Expr6Context, Expr7Context, Expr8Context, Expr9Context, Expr10Context, Expr11Context, Expr12Context, Expr13Context, Expr14Context, Expr15Context, Expr17Context, Expr18Context, ExprListContext, NameContext, PredDeclContext, BlockContext, QualNameContext, QuantDeclListContext, NameListContext, QuantDeclContext, CompareOpContext } from "./forge-antlr/ForgeParser";
 import { IDataInstance } from "./types";
 export type SingleValue = string | number | boolean;
 export type Tuple = SingleValue[];
 export type EvalResult = SingleValue | Tuple[];
 export declare function areTupleArraysEqual(a: Tuple[], b: Tuple[]): boolean;
 export declare const SUPPORTED_BUILTINS: string[];
+/**
+ * The canonical spelling of a comparison operator.
+ *
+ * Some operators have two spellings that the lexer folds into a single token —
+ * `<=` and `=<` are both `LEQ_TOK`. Reading `compareOp().text` gives back
+ * whichever one the author typed, so any dispatch on that text has to enumerate
+ * both, and every new dispatch site has to rediscover the fact. Every OTHER
+ * multi-spelling operator in the grammar (`||`/`or`, `!`/`not`, `=>`/`implies`)
+ * is dispatched on token presence and so never had the problem; this brings
+ * `compareOp` in line, and makes the alias unrepresentable rather than merely
+ * handled.
+ */
+export declare function compareOpKind(op: CompareOpContext): string;
 /**
  * A non-fatal condition noticed while evaluating an expression.
  *
@@ -71,6 +84,7 @@ export declare class ForgeExprEvaluator extends AbstractParseTreeVisitor<EvalRes
     private isConvertibleToNumber;
     private isConvertibleToBoolean;
     private convertToBoolean;
+    private atomValue;
     private dotJoin;
     private cacheResult;
     private getIden;
@@ -84,7 +98,6 @@ export declare class ForgeExprEvaluator extends AbstractParseTreeVisitor<EvalRes
     visitExpr2(ctx: Expr2Context): EvalResult;
     visitExpr3(ctx: Expr3Context): EvalResult;
     visitExpr4(ctx: Expr4Context): EvalResult;
-    visitExpr4_5(ctx: Expr4_5Context): EvalResult;
     visitExpr5(ctx: Expr5Context): EvalResult;
     visitExpr6(ctx: Expr6Context): EvalResult;
     visitExpr7(ctx: Expr7Context): EvalResult;
@@ -96,7 +109,6 @@ export declare class ForgeExprEvaluator extends AbstractParseTreeVisitor<EvalRes
     visitExpr13(ctx: Expr13Context): EvalResult;
     visitExpr14(ctx: Expr14Context): EvalResult;
     visitExpr15(ctx: Expr15Context): EvalResult;
-    visitExpr16(ctx: Expr16Context): EvalResult;
     visitExpr17(ctx: Expr17Context): EvalResult;
     getNameListValues(ctx: NameListContext): string[];
     getQuantDeclValues(ctx: QuantDeclContext): Record<string, Tuple[]>;
@@ -107,6 +119,7 @@ export declare class ForgeExprEvaluator extends AbstractParseTreeVisitor<EvalRes
     visitQualName(ctx: QualNameContext): EvalResult;
     private evaluateBinaryOperation;
     private evaluateUnaryOperation;
+    private setOperandAsNumber;
     private evaluateSetOperation;
 }
 export declare class NameNotFoundError extends Error {

package/dist/ForgeExprFreeVariableFinder.d.ts

@@ -2,7 +2,7 @@ import { AbstractParseTreeVisitor } from "antlr4ts/tree/AbstractParseTreeVisitor
 import { ParseTree } from "antlr4ts/tree/ParseTree";
 import { ForgeVisitor } from "./forge-antlr/ForgeVisitor";
 import { IDataInstance } from "./types";
-import { BlockContext, Expr10Context, Expr11Context, Expr12Context, Expr13Context, Expr14Context, Expr15Context, Expr16Context, Expr17Context, Expr18Context, Expr1Context, Expr1_5Context, Expr2Context, Expr3Context, Expr4Context, Expr4_5Context, Expr5Context, Expr6Context, Expr7Context, Expr8Context, Expr9Context, ExprContext, ExprListContext, NameContext, NameListContext, PredDeclContext, QuantDeclContext, QuantDeclListContext } from "./forge-antlr/ForgeParser";
+import { BlockContext, Expr10Context, Expr11Context, Expr12Context, Expr13Context, Expr14Context, Expr15Context, Expr17Context, Expr18Context, Expr1Context, Expr1_5Context, Expr2Context, Expr3Context, Expr4Context, Expr5Context, Expr6Context, Expr7Context, Expr8Context, Expr9Context, ExprContext, ExprListContext, NameContext, NameListContext, PredDeclContext, QuantDeclContext, QuantDeclListContext } from "./forge-antlr/ForgeParser";
 export type FreeVariables = Map<ParseTree, Set<string>>;
 /**
  * A recursive visitor to find all the free variables referenced in a forge
@@ -25,7 +25,6 @@ export declare class ForgeExprFreeVariableFinder extends AbstractParseTreeVisito
     visitExpr2(ctx: Expr2Context): FreeVariables;
     visitExpr3(ctx: Expr3Context): FreeVariables;
     visitExpr4(ctx: Expr4Context): FreeVariables;
-    visitExpr4_5(ctx: Expr4_5Context): FreeVariables;
     visitExpr5(ctx: Expr5Context): FreeVariables;
     visitExpr6(ctx: Expr6Context): FreeVariables;
     visitExpr7(ctx: Expr7Context): FreeVariables;
@@ -37,7 +36,6 @@ export declare class ForgeExprFreeVariableFinder extends AbstractParseTreeVisito
     visitExpr13(ctx: Expr13Context): FreeVariables;
     visitExpr14(ctx: Expr14Context): FreeVariables;
     visitExpr15(ctx: Expr15Context): FreeVariables;
-    visitExpr16(ctx: Expr16Context): FreeVariables;
     visitExpr17(ctx: Expr17Context): FreeVariables;
     visitExpr18(ctx: Expr18Context): FreeVariables;
     visitExprList(ctx: ExprListContext): FreeVariables;

package/dist/ForgeExprStaticAnalyzer.d.ts

@@ -1,7 +1,7 @@
 import { AbstractParseTreeVisitor } from "antlr4ts/tree/AbstractParseTreeVisitor";
 import { ParseTree } from "antlr4ts/tree/ParseTree";
 import { ForgeVisitor } from "./forge-antlr/ForgeVisitor";
-import { Expr1Context, Expr1_5Context, Expr2Context, Expr3Context, Expr4Context, Expr5Context, Expr6Context, Expr7Context, Expr8Context, Expr9Context, Expr11Context, Expr12Context, Expr14Context, Expr15Context, Expr17Context, Expr18Context, ExprContext, NameContext, BlockContext } from "./forge-antlr/ForgeParser";
+import { Expr1Context, Expr1_5Context, Expr2Context, Expr3Context, Expr4Context, Expr5Context, Expr6Context, Expr7Context, Expr8Context, Expr9Context, Expr10Context, Expr11Context, Expr12Context, Expr13Context, Expr14Context, Expr15Context, Expr17Context, Expr18Context, ExprContext, NameContext, BlockContext } from "./forge-antlr/ForgeParser";
 import { IForgeSchema } from "./types";
 type Abstract = {
     kind: "bool";
@@ -15,6 +15,7 @@ type Abstract = {
     kind: "typed";
     arity: number;
     columnTypes?: readonly string[];
+    exact?: boolean;
 } | {
     kind: "ill-typed";
     reason: string;
@@ -79,7 +80,9 @@ export declare class ForgeExprStaticAnalyzer extends AbstractParseTreeVisitor<Ab
     visitExpr7(ctx: Expr7Context): Abstract;
     visitExpr8(ctx: Expr8Context): Abstract;
     visitExpr9(ctx: Expr9Context): Abstract;
+    visitExpr10(ctx: Expr10Context): Abstract;
     visitExpr12(ctx: Expr12Context): Abstract;
+    visitExpr13(ctx: Expr13Context): Abstract;
     visitExpr11(ctx: Expr11Context): Abstract;
     visitExpr14(ctx: Expr14Context): Abstract;
     visitExpr15(ctx: Expr15Context): Abstract;

package/dist/forge-antlr/ForgeLexer.d.ts

@@ -65,58 +65,47 @@ export declare class ForgeLexer extends Lexer {
     static readonly IMP_TOK = 60;
     static readonly ELSE_TOK = 61;
     static readonly AND_TOK = 62;
-    static readonly UNTIL_TOK = 63;
-    static readonly RELEASE_TOK = 64;
-    static readonly SINCE_TOK = 65;
-    static readonly TRIGGERED_TOK = 66;
-    static readonly NEG_TOK = 67;
-    static readonly ALWAYS_TOK = 68;
-    static readonly EVENTUALLY_TOK = 69;
-    static readonly AFTER_TOK = 70;
-    static readonly BEFORE_TOK = 71;
-    static readonly ONCE_TOK = 72;
-    static readonly HISTORICALLY_TOK = 73;
-    static readonly CARD_TOK = 74;
-    static readonly PPLUS_TOK = 75;
-    static readonly AMP_TOK = 76;
-    static readonly SUBT_TOK = 77;
-    static readonly SUPT_TOK = 78;
-    static readonly PRIME_TOK = 79;
-    static readonly TILDE_TOK = 80;
-    static readonly EXP_TOK = 81;
-    static readonly STAR_TOK = 82;
-    static readonly AT_TOK = 83;
-    static readonly BACKQUOTE_TOK = 84;
-    static readonly THIS_TOK = 85;
-    static readonly SEXPR_TOK = 86;
-    static readonly INST_TOK = 87;
-    static readonly EVAL_TOK = 88;
-    static readonly EXAMPLE_TOK = 89;
-    static readonly ARROW_TOK = 90;
-    static readonly GET_LABEL_TOK = 91;
-    static readonly GET_LABEL_STR_TOK = 92;
-    static readonly GET_LABEL_BOOL_TOK = 93;
-    static readonly GET_LABEL_NUM_TOK = 94;
-    static readonly EQ_TOK = 95;
-    static readonly LT_TOK = 96;
-    static readonly GT_TOK = 97;
-    static readonly LEQ_TOK = 98;
-    static readonly GEQ_TOK = 99;
-    static readonly NI_TOK = 100;
-    static readonly NO_TOK = 101;
-    static readonly SUM_TOK = 102;
-    static readonly INT_TOK = 103;
-    static readonly OPTION_TOK = 104;
-    static readonly COMMA_TOK = 105;
-    static readonly SLASH_TOK = 106;
-    static readonly NUM_CONST_TOK = 107;
-    static readonly QUOTED_IDENTIFIER_TOK = 108;
-    static readonly IDENTIFIER_TOK = 109;
-    static readonly WS = 110;
-    static readonly CCOMMENT = 111;
-    static readonly COMMENT = 112;
-    static readonly MULTCOMMENT = 113;
-    static readonly LANG_DECL = 114;
+    static readonly NEG_TOK = 63;
+    static readonly CARD_TOK = 64;
+    static readonly PPLUS_TOK = 65;
+    static readonly AMP_TOK = 66;
+    static readonly SUBT_TOK = 67;
+    static readonly SUPT_TOK = 68;
+    static readonly TILDE_TOK = 69;
+    static readonly EXP_TOK = 70;
+    static readonly STAR_TOK = 71;
+    static readonly AT_TOK = 72;
+    static readonly BACKQUOTE_TOK = 73;
+    static readonly THIS_TOK = 74;
+    static readonly SEXPR_TOK = 75;
+    static readonly INST_TOK = 76;
+    static readonly EVAL_TOK = 77;
+    static readonly EXAMPLE_TOK = 78;
+    static readonly ARROW_TOK = 79;
+    static readonly GET_LABEL_TOK = 80;
+    static readonly GET_LABEL_STR_TOK = 81;
+    static readonly GET_LABEL_BOOL_TOK = 82;
+    static readonly GET_LABEL_NUM_TOK = 83;
+    static readonly EQ_TOK = 84;
+    static readonly LT_TOK = 85;
+    static readonly GT_TOK = 86;
+    static readonly LEQ_TOK = 87;
+    static readonly GEQ_TOK = 88;
+    static readonly NI_TOK = 89;
+    static readonly NO_TOK = 90;
+    static readonly SUM_TOK = 91;
+    static readonly INT_TOK = 92;
+    static readonly OPTION_TOK = 93;
+    static readonly COMMA_TOK = 94;
+    static readonly SLASH_TOK = 95;
+    static readonly NUM_CONST_TOK = 96;
+    static readonly QUOTED_IDENTIFIER_TOK = 97;
+    static readonly IDENTIFIER_TOK = 98;
+    static readonly WS = 99;
+    static readonly CCOMMENT = 100;
+    static readonly COMMENT = 101;
+    static readonly MULTCOMMENT = 102;
+    static readonly LANG_DECL = 103;
     static readonly channelNames: string[];
     static readonly modeNames: string[];
     static readonly ruleNames: string[];

package/dist/forge-antlr/ForgeListener.d.ts

@@ -52,7 +52,6 @@ import { Expr1_5Context } from "./ForgeParser";
 import { Expr2Context } from "./ForgeParser";
 import { Expr3Context } from "./ForgeParser";
 import { Expr4Context } from "./ForgeParser";
-import { Expr4_5Context } from "./ForgeParser";
 import { Expr5Context } from "./ForgeParser";
 import { Expr6Context } from "./ForgeParser";
 import { Expr7Context } from "./ForgeParser";
@@ -64,7 +63,6 @@ import { Expr12Context } from "./ForgeParser";
 import { Expr13Context } from "./ForgeParser";
 import { Expr14Context } from "./ForgeParser";
 import { Expr15Context } from "./ForgeParser";
-import { Expr16Context } from "./ForgeParser";
 import { Expr17Context } from "./ForgeParser";
 import { Expr18Context } from "./ForgeParser";
 import { ArrowExprContext } from "./ForgeParser";
@@ -619,16 +617,6 @@ export interface ForgeListener extends ParseTreeListener {
      * @param ctx the parse tree
      */
     exitExpr4?: (ctx: Expr4Context) => void;
-    /**
-     * Enter a parse tree produced by `ForgeParser.expr4_5`.
-     * @param ctx the parse tree
-     */
-    enterExpr4_5?: (ctx: Expr4_5Context) => void;
-    /**
-     * Exit a parse tree produced by `ForgeParser.expr4_5`.
-     * @param ctx the parse tree
-     */
-    exitExpr4_5?: (ctx: Expr4_5Context) => void;
     /**
      * Enter a parse tree produced by `ForgeParser.expr5`.
      * @param ctx the parse tree
@@ -739,16 +727,6 @@ export interface ForgeListener extends ParseTreeListener {
      * @param ctx the parse tree
      */
     exitExpr15?: (ctx: Expr15Context) => void;
-    /**
-     * Enter a parse tree produced by `ForgeParser.expr16`.
-     * @param ctx the parse tree
-     */
-    enterExpr16?: (ctx: Expr16Context) => void;
-    /**
-     * Exit a parse tree produced by `ForgeParser.expr16`.
-     * @param ctx the parse tree
-     */
-    exitExpr16?: (ctx: Expr16Context) => void;
     /**
      * Enter a parse tree produced by `ForgeParser.expr17`.
      * @param ctx the parse tree