@dbml/parse 5.4.1 → 5.5.0

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './src/index'
+export {}

package/dist/src/core/analyzer/binder/binder.d.ts

@@ -4,7 +4,8 @@ import { default as Report } from '../../report';
 import { default as SymbolFactory } from '../symbol/factory';
 export default class Binder {
     private ast;
-    private errors;
-    constructor(ast: ProgramNode);
-    resolve(symbolFactory: SymbolFactory): Report<ProgramNode, CompileError>;
+    private symbolFactory;
+    constructor(ast: ProgramNode, symbolFactory: SymbolFactory);
+    private resolvePartialInjections;
+    resolve(): Report<ProgramNode, CompileError>;
 }

package/dist/src/core/analyzer/binder/elementBinder/checks.d.ts

@@ -1,12 +1,13 @@
-import { default as ElementBinder } from './elementBinder';
-export default class ChecksBinder extends ElementBinder {
-    protected subfield: {
-        arg: {
-            argBinderRules: {
-                shouldBind: false;
-            }[];
-        };
-        settingList: {};
-    };
-    protected settingList: {};
+import { ElementDeclarationNode, ProgramNode, SyntaxToken } from '../../../..';
+import { CompileError } from '../../../errors';
+import { default as SymbolFactory } from '../../symbol/factory';
+import { ElementBinder } from '../types';
+export default class ChecksBinder implements ElementBinder {
+    private symbolFactory;
+    private declarationNode;
+    private ast;
+    constructor(declarationNode: ElementDeclarationNode & {
+        type: SyntaxToken;
+    }, ast: ProgramNode, symbolFactory: SymbolFactory);
+    bind(): CompileError[];
 }

package/dist/src/core/analyzer/binder/elementBinder/custom.d.ts

@@ -1,10 +1,16 @@
-import { default as ElementBinder } from './elementBinder';
-export default class CustomBinder extends ElementBinder {
-    protected subfield: {
-        arg: {
-            argBinderRules: never[];
-        };
-        settingList: {};
-    };
-    protected settingList: {};
+import { CompileError } from '../../../errors';
+import { ElementBinder } from '../types';
+import { ElementDeclarationNode, ProgramNode } from '../../../parser/nodes';
+import { SyntaxToken } from '../../../lexer/tokens';
+import { default as SymbolFactory } from '../../symbol/factory';
+export default class CustomBinder implements ElementBinder {
+    private symbolFactory;
+    private declarationNode;
+    private ast;
+    constructor(declarationNode: ElementDeclarationNode & {
+        type: SyntaxToken;
+    }, ast: ProgramNode, symbolFactory: SymbolFactory);
+    bind(): CompileError[];
+    private bindBody;
+    private bindSubElements;
 }

package/dist/src/core/analyzer/binder/elementBinder/enum.d.ts

@@ -1,12 +1,16 @@
-import { default as ElementBinder } from './elementBinder';
-export default class EnumBinder extends ElementBinder {
-    protected subfield: {
-        arg: {
-            argBinderRules: {
-                shouldBind: false;
-            }[];
-        };
-        settingList: {};
-    };
-    protected settingList: {};
+import { CompileError } from '../../../errors';
+import { ElementBinder } from '../types';
+import { ElementDeclarationNode, ProgramNode } from '../../../parser/nodes';
+import { SyntaxToken } from '../../../lexer/tokens';
+import { default as SymbolFactory } from '../../symbol/factory';
+export default class EnumBinder implements ElementBinder {
+    private symbolFactory;
+    private declarationNode;
+    private ast;
+    constructor(declarationNode: ElementDeclarationNode & {
+        type: SyntaxToken;
+    }, ast: ProgramNode, symbolFactory: SymbolFactory);
+    bind(): CompileError[];
+    private bindBody;
+    private bindSubElements;
 }

package/dist/src/core/analyzer/binder/elementBinder/indexes.d.ts

@@ -1,17 +1,17 @@
-import { SymbolKind } from '../../symbol/symbolIndex';
-import { default as ElementBinder } from './elementBinder';
-export default class IndexesBinder extends ElementBinder {
-    protected subfield: {
-        arg: {
-            argBinderRules: {
-                shouldBind: true;
-                topSubnamesSymbolKind: SymbolKind[];
-                remainingSubnamesSymbolKind: SymbolKind;
-                ignoreNameNotFound: boolean;
-                ignoreNameNotFoundForQuotedVariable: boolean;
-            }[];
-        };
-        settingList: {};
-    };
-    protected settingList: {};
+import { ElementDeclarationNode, ProgramNode } from '../../../parser/nodes';
+import { ElementBinder } from '../types';
+import { SyntaxToken } from '../../../lexer/tokens';
+import { CompileError } from '../../../errors';
+import { default as SymbolFactory } from '../../symbol/factory';
+export default class IndexesBinder implements ElementBinder {
+    private symbolFactory;
+    private declarationNode;
+    private ast;
+    constructor(declarationNode: ElementDeclarationNode & {
+        type: SyntaxToken;
+    }, ast: ProgramNode, symbolFactory: SymbolFactory);
+    bind(): CompileError[];
+    private bindBody;
+    private bindFields;
+    private bindSubElements;
 }

package/dist/src/core/analyzer/binder/elementBinder/note.d.ts

@@ -1,12 +1,16 @@
-import { default as ElementBinder } from './elementBinder';
-export default class NoteBinder extends ElementBinder {
-    protected subfield: {
-        arg: {
-            argBinderRules: {
-                shouldBind: false;
-            }[];
-        };
-        settingList: {};
-    };
-    protected settingList: {};
+import { CompileError } from '../../../errors';
+import { ElementBinder } from '../types';
+import { ElementDeclarationNode, ProgramNode } from '../../../parser/nodes';
+import { SyntaxToken } from '../../../lexer/tokens';
+import { default as SymbolFactory } from '../../symbol/factory';
+export default class NoteBinder implements ElementBinder {
+    private symbolFactory;
+    private declarationNode;
+    private ast;
+    constructor(declarationNode: ElementDeclarationNode & {
+        type: SyntaxToken;
+    }, ast: ProgramNode, symbolFactory: SymbolFactory);
+    bind(): CompileError[];
+    private bindBody;
+    private bindSubElements;
 }

package/dist/src/core/analyzer/binder/elementBinder/project.d.ts

@@ -1,10 +1,16 @@
-import { default as ElementBinder } from './elementBinder';
-export default class ProjectBinder extends ElementBinder {
-    protected subfield: {
-        arg: {
-            argBinderRules: never[];
-        };
-        settingList: {};
-    };
-    protected settingList: {};
+import { SyntaxToken } from '../../../lexer/tokens';
+import { ElementBinder } from '../types';
+import { ElementDeclarationNode, ProgramNode } from '../../../parser/nodes';
+import { CompileError } from '../../../errors';
+import { default as SymbolFactory } from '../../symbol/factory';
+export default class ProjectBinder implements ElementBinder {
+    private symbolFactory;
+    private declarationNode;
+    private ast;
+    constructor(declarationNode: ElementDeclarationNode & {
+        type: SyntaxToken;
+    }, ast: ProgramNode, symbolFactory: SymbolFactory);
+    bind(): CompileError[];
+    private bindBody;
+    private bindSubElements;
 }

package/dist/src/core/analyzer/binder/elementBinder/ref.d.ts

@@ -1,17 +1,17 @@
-import { SymbolKind } from '../../symbol/symbolIndex';
-import { default as ElementBinder } from './elementBinder';
-export default class RefBinder extends ElementBinder {
-    protected subfield: {
-        arg: {
-            argBinderRules: {
-                shouldBind: true;
-                topSubnamesSymbolKind: SymbolKind[];
-                remainingSubnamesSymbolKind: SymbolKind;
-                ignoreNameNotFound: boolean;
-                ignoreNameNotFoundForQuotedVariable: boolean;
-            }[];
-        };
-        settingList: {};
-    };
-    protected settingList: {};
+import { ElementDeclarationNode, ProgramNode } from '../../../parser/nodes';
+import { ElementBinder } from '../types';
+import { SyntaxToken } from '../../../lexer/tokens';
+import { CompileError } from '../../../errors';
+import { default as SymbolFactory } from '../../symbol/factory';
+export default class RefBinder implements ElementBinder {
+    private symbolFactory;
+    private declarationNode;
+    private ast;
+    constructor(declarationNode: ElementDeclarationNode & {
+        type: SyntaxToken;
+    }, ast: ProgramNode, symbolFactory: SymbolFactory);
+    bind(): CompileError[];
+    private bindBody;
+    private bindFields;
+    private bindSubElements;
 }

package/dist/src/core/analyzer/binder/elementBinder/table.d.ts

@@ -1,49 +1,21 @@
-import { SymbolKind } from '../../symbol/symbolIndex';
-import { default as ElementBinder } from './elementBinder';
-export default class TableBinder extends ElementBinder {
-    protected subfield: {
-        arg: {
-            argBinderRules: ({
-                shouldBind: false;
-                topSubnamesSymbolKind?: undefined;
-                remainingSubnamesSymbolKind?: undefined;
-                ignoreNameNotFound?: undefined;
-                ignoreNameNotFoundForQuotedVariable?: undefined;
-            } | {
-                shouldBind: true;
-                topSubnamesSymbolKind: SymbolKind[];
-                remainingSubnamesSymbolKind: SymbolKind;
-                ignoreNameNotFound: boolean;
-                ignoreNameNotFoundForQuotedVariable: boolean;
-            })[];
-        };
-        settingList: {
-            ref: {
-                shouldBind: true;
-                topSubnamesSymbolKind: SymbolKind[];
-                remainingSubnamesSymbolKind: SymbolKind;
-                ignoreNameNotFound: boolean;
-                ignoreNameNotFoundForQuotedVariable: boolean;
-            };
-            default: {
-                shouldBind: true;
-                topSubnamesSymbolKind: SymbolKind[];
-                remainingSubnamesSymbolKind: SymbolKind;
-                ignoreNameNotFound: boolean;
-                keywords: string[];
-                ignoreNameNotFoundForQuotedVariable: boolean;
-            };
-            check: {
-                shouldBind: false;
-            };
-        };
-    };
-    protected settingList: {};
-    protected injectionBinderRule: {
-        shouldBind: true;
-        topSubnamesSymbolKind: never[];
-        remainingSubnamesSymbolKind: SymbolKind;
-        ignoreNameNotFound: boolean;
-        ignoreNameNotFoundForQuotedVariable: boolean;
-    };
+import { ElementDeclarationNode, ProgramNode } from '../../../parser/nodes';
+import { ElementBinder } from '../types';
+import { SyntaxToken } from '../../../lexer/tokens';
+import { CompileError } from '../../../errors';
+import { default as SymbolFactory } from '../../symbol/factory';
+export default class TableBinder implements ElementBinder {
+    private symbolFactory;
+    private declarationNode;
+    private ast;
+    constructor(declarationNode: ElementDeclarationNode & {
+        type: SyntaxToken;
+    }, ast: ProgramNode, symbolFactory: SymbolFactory);
+    bind(): CompileError[];
+    resolvePartialInjections(): CompileError[];
+    private bindBody;
+    private bindFields;
+    private tryToBindColumnType;
+    private tryToBindEnumFieldRef;
+    private bindInlineRef;
+    private bindSubElements;
 }

package/dist/src/core/analyzer/binder/elementBinder/tableGroup.d.ts

@@ -1,17 +1,17 @@
-import { SymbolKind } from '../../symbol/symbolIndex';
-import { default as ElementBinder } from './elementBinder';
-export default class TableGroupBinder extends ElementBinder {
-    protected subfield: {
-        arg: {
-            argBinderRules: {
-                shouldBind: true;
-                topSubnamesSymbolKind: SymbolKind[];
-                remainingSubnamesSymbolKind: SymbolKind;
-                ignoreNameNotFound: boolean;
-                ignoreNameNotFoundForQuotedVariable: boolean;
-            }[];
-        };
-        settingList: {};
-    };
-    protected settingList: {};
+import { ElementDeclarationNode, ProgramNode } from '../../../parser/nodes';
+import { ElementBinder } from '../types';
+import { SyntaxToken } from '../../../lexer/tokens';
+import { CompileError } from '../../../errors';
+import { default as SymbolFactory } from '../../symbol/factory';
+export default class TableGroupBinder implements ElementBinder {
+    private symbolFactory;
+    private declarationNode;
+    private ast;
+    constructor(declarationNode: ElementDeclarationNode & {
+        type: SyntaxToken;
+    }, ast: ProgramNode, symbolFactory: SymbolFactory);
+    bind(): CompileError[];
+    private bindBody;
+    private bindFields;
+    private bindSubElements;
 }

package/dist/src/core/analyzer/binder/elementBinder/tablePartial.d.ts

@@ -1,37 +1,19 @@
-import { SymbolKind } from '../../symbol/symbolIndex';
-import { default as ElementBinder } from './elementBinder';
-export default class TablePartialBinder extends ElementBinder {
-    protected subfield: {
-        arg: {
-            argBinderRules: ({
-                shouldBind: false;
-                topSubnamesSymbolKind?: undefined;
-                remainingSubnamesSymbolKind?: undefined;
-                ignoreNameNotFound?: undefined;
-                ignoreNameNotFoundForQuotedVariable?: undefined;
-            } | {
-                shouldBind: true;
-                topSubnamesSymbolKind: SymbolKind[];
-                remainingSubnamesSymbolKind: SymbolKind;
-                ignoreNameNotFound: boolean;
-                ignoreNameNotFoundForQuotedVariable: boolean;
-            })[];
-        };
-        settingList: {
-            ref: {
-                shouldBind: true;
-                topSubnamesSymbolKind: SymbolKind[];
-                remainingSubnamesSymbolKind: SymbolKind;
-                ignoreNameNotFound: boolean;
-                ignoreNameNotFoundForQuotedVariable: boolean;
-            };
-            default: {
-                shouldBind: false;
-            };
-            check: {
-                shouldBind: false;
-            };
-        };
-    };
-    protected settingList: {};
+import { ElementDeclarationNode, ProgramNode } from '../../../parser/nodes';
+import { SyntaxToken } from '../../../lexer/tokens';
+import { ElementBinder } from '../types';
+import { CompileError } from '../../../errors';
+import { default as SymbolFactory } from '../../symbol/factory';
+export default class TablePartialBinder implements ElementBinder {
+    private symbolFactory;
+    private declarationNode;
+    private ast;
+    constructor(declarationNode: ElementDeclarationNode & {
+        type: SyntaxToken;
+    }, ast: ProgramNode, symbolFactory: SymbolFactory);
+    bind(): CompileError[];
+    private bindBody;
+    private bindFields;
+    private tryToBindColumnType;
+    private bindInlineRef;
+    private bindSubElements;
 }

package/dist/src/core/analyzer/binder/types.d.ts

@@ -1,17 +1,4 @@
-import { SymbolKind } from '../symbol/symbolIndex';
-export type BinderRule = {
-    shouldBind: true;
-    topSubnamesSymbolKind: SymbolKind[];
-    remainingSubnamesSymbolKind: SymbolKind;
-    ignoreNameNotFound: boolean;
-    keywords?: readonly string[];
-    ignoreNameNotFoundForQuotedVariable?: boolean;
-} | {
-    shouldBind: false;
-};
-export interface ArgumentBinderRule {
-    argBinderRules: BinderRule[];
-}
-export interface SettingListBinderRule {
-    [index: string]: BinderRule;
+import { CompileError } from '../../errors';
+export interface ElementBinder {
+    bind(): CompileError[];
 }

package/dist/src/core/analyzer/binder/utils.d.ts

@@ -1,5 +1,5 @@
 import { SyntaxToken } from '../../lexer/tokens';
-import { ElementDeclarationNode } from '../../parser/nodes';
+import { ElementDeclarationNode, PrimaryExpressionNode, ProgramNode, SyntaxNode, VariableNode } from '../../parser/nodes';
 import { default as ChecksBinder } from './elementBinder/checks';
 import { default as CustomBinder } from './elementBinder/custom';
 import { default as EnumBinder } from './elementBinder/enum';
@@ -10,6 +10,22 @@ import { default as RefBinder } from './elementBinder/ref';
 import { default as TableBinder } from './elementBinder/table';
 import { default as TableGroupBinder } from './elementBinder/tableGroup';
 import { default as TablePartialBinder } from './elementBinder/tablePartial';
+import { SymbolKind } from '../symbol/symbolIndex';
+import { CompileError } from '../../errors';
 export declare function pickBinder(element: ElementDeclarationNode & {
     type: SyntaxToken;
-}): typeof EnumBinder | typeof TableBinder | typeof TableGroupBinder | typeof ProjectBinder | typeof RefBinder | typeof NoteBinder | typeof IndexesBinder | typeof TablePartialBinder | typeof ChecksBinder | typeof CustomBinder;
+}): typeof ChecksBinder | typeof CustomBinder | typeof EnumBinder | typeof TableBinder | typeof TableGroupBinder | typeof ProjectBinder | typeof RefBinder | typeof NoteBinder | typeof IndexesBinder | typeof TablePartialBinder;
+export declare function scanNonListNodeForBinding(node?: SyntaxNode): {
+    variables: (PrimaryExpressionNode & {
+        expression: VariableNode;
+    })[];
+    tupleElements: (PrimaryExpressionNode & {
+        expression: VariableNode;
+    })[];
+}[];
+export declare function lookupAndBindInScope(initialScope: ElementDeclarationNode | ProgramNode, symbolInfos: {
+    node: PrimaryExpressionNode & {
+        expression: VariableNode;
+    };
+    kind: SymbolKind;
+}[]): CompileError[];

package/dist/src/core/analyzer/symbol/symbolIndex.d.ts

@@ -10,7 +10,7 @@ export declare enum SymbolKind {
     EnumField = "Enum field",
     Note = "Note",
     TablePartial = "TablePartial",
-    TablePartialInjection = "TablePartialInjection"
+    PartialInjection = "PartialInjection"
 }
 export declare function createSchemaSymbolIndex(key: string): NodeSymbolIndex;
 export declare function createTableSymbolIndex(key: string): NodeSymbolIndex;
@@ -21,12 +21,10 @@ export declare function createTableGroupSymbolIndex(key: string): NodeSymbolInde
 export declare function createTableGroupFieldSymbolIndex(key: string): NodeSymbolIndex;
 export declare function createStickyNoteSymbolIndex(key: string): NodeSymbolIndex;
 export declare function createTablePartialSymbolIndex(key: string): NodeSymbolIndex;
-export declare function createTablePartialInjectionSymbolIndex(key: string): NodeSymbolIndex;
+export declare function createPartialInjectionSymbolIndex(key: string): NodeSymbolIndex;
 export declare function createNodeSymbolIndex(key: string, symbolKind: SymbolKind): NodeSymbolIndex;
 export declare function destructureIndex(id: NodeSymbolIndex): Option<{
     name: string;
     kind: SymbolKind;
 }>;
 export declare function isPublicSchemaIndex(id: NodeSymbolIndex): boolean;
-export declare function isInjectionIndex(id: NodeSymbolIndex): boolean;
-export declare function getInjectorIndex(injectionNodeIndex: NodeSymbolIndex): NodeSymbolIndex | null;

package/dist/src/core/analyzer/symbol/symbols.d.ts

@@ -11,7 +11,6 @@ export interface NodeSymbol {
     symbolTable?: SymbolTable;
     declaration?: SyntaxNode;
     references: SyntaxNode[];
-    injectorDeclaration?: SyntaxNode;
 }
 export declare class SchemaSymbol implements NodeSymbol {
     id: NodeSymbolId;
@@ -85,21 +84,23 @@ export declare class TablePartialSymbol implements NodeSymbol {
         declaration: SyntaxNode;
     }, id: NodeSymbolId);
 }
-export declare class TablePartialInjectionSymbol implements NodeSymbol {
+export declare class PartialInjectionSymbol implements NodeSymbol {
     id: NodeSymbolId;
+    symbolTable: SymbolTable;
     declaration: SyntaxNode;
     references: SyntaxNode[];
-    constructor({ declaration }: {
+    constructor({ symbolTable, declaration }: {
+        symbolTable: SymbolTable;
         declaration: SyntaxNode;
     }, id: NodeSymbolId);
 }
 export declare class TablePartialInjectedColumnSymbol implements NodeSymbol {
     id: NodeSymbolId;
-    injectorDeclaration: SyntaxNode;
-    injectorFieldSymbol: NodeSymbol;
+    declaration: SyntaxNode;
+    tablePartialSymbol: TablePartialSymbol;
     references: SyntaxNode[];
-    constructor({ injectorFieldSymbol, injectorDeclaration }: {
-        injectorFieldSymbol: NodeSymbol;
-        injectorDeclaration: SyntaxNode;
+    constructor({ declaration, tablePartialSymbol }: {
+        declaration: SyntaxNode;
+        tablePartialSymbol: TablePartialSymbol;
     }, id: NodeSymbolId);
 }

package/dist/src/core/analyzer/symbol/utils.d.ts

@@ -1,4 +1,4 @@
-import { NodeSymbolIndex } from './symbolIndex';
-import { NodeSymbol, TablePartialInjectedColumnSymbol } from './symbols';
+import { NodeSymbolIndex, SymbolKind } from './symbolIndex';
+import { NodeSymbol } from './symbols';
 export declare function generatePossibleIndexes(name: string): NodeSymbolIndex[];
-export declare function getInjectedFieldSymbolFromInjectorFieldSymbol(injectorSymbol: NodeSymbol): typeof TablePartialInjectedColumnSymbol | null;
+export declare function getSymbolKind(symbol: NodeSymbol): SymbolKind;

package/dist/src/core/analyzer/utils.d.ts

@@ -1,5 +1,5 @@
 import { Option } from '../option';
-import { ElementDeclarationNode, FunctionExpressionNode, InfixExpressionNode, PartialInjectionNode, PrimaryExpressionNode, SyntaxNode, VariableNode } from '../parser/nodes';
+import { ElementDeclarationNode, FunctionExpressionNode, InfixExpressionNode, PrimaryExpressionNode, SyntaxNode, VariableNode } from '../parser/nodes';
 import { NodeSymbolIndex } from './symbol/symbolIndex';
 import { NodeSymbol } from './symbol/symbols';
 import { SyntaxToken } from '../lexer/tokens';
@@ -7,9 +7,13 @@ import { ElementKind } from './types';
 export declare function getElementKind(node?: ElementDeclarationNode): Option<ElementKind>;
 export declare function destructureMemberAccessExpression(node?: SyntaxNode): Option<SyntaxNode[]>;
 export declare function destructureComplexVariable(node?: SyntaxNode): Option<string[]>;
-export declare function destructureComplexTuple(node?: SyntaxNode): Option<{
-    variables: string[];
-    tupleElements?: string[];
+export declare function destructureComplexVariableTuple(node?: SyntaxNode): Option<{
+    variables: (PrimaryExpressionNode & {
+        expression: VariableNode;
+    })[];
+    tupleElements: (PrimaryExpressionNode & {
+        expression: VariableNode;
+    })[];
 }>;
 export declare function extractVariableFromExpression(node?: SyntaxNode): Option<string>;
 export declare function destructureIndexNode(node?: SyntaxNode): Option<{
@@ -21,7 +25,6 @@ export declare function destructureIndexNode(node?: SyntaxNode): Option<{
 export declare function extractVarNameFromPrimaryVariable(node?: PrimaryExpressionNode & {
     expression: VariableNode;
 }): Option<string>;
-export declare function extractVarNameFromPartialInjection(node?: PartialInjectionNode): Option<string>;
 export declare function extractQuotedStringToken(value?: SyntaxNode): Option<string>;
 export declare function isBinaryRelationship(value?: SyntaxNode): value is InfixExpressionNode;
 export declare function isEqualTupleOperands(value: InfixExpressionNode): value is InfixExpressionNode;

package/dist/src/core/analyzer/validator/elementValidators/table.d.ts

@@ -1,6 +1,6 @@
 import { default as SymbolFactory } from '../../symbol/factory';
 import { CompileError } from '../../../errors';
-import { BlockExpressionNode, ElementDeclarationNode, ExpressionNode, FunctionApplicationNode, PartialInjectionNode } from '../../../parser/nodes';
+import { BlockExpressionNode, ElementDeclarationNode, ExpressionNode, FunctionApplicationNode } from '../../../parser/nodes';
 import { ElementValidator } from '../types';
 import { SyntaxToken } from '../../../lexer/tokens';
 import { default as SymbolTable } from '../../symbol/symbolTable';
@@ -18,8 +18,6 @@ export default class TableValidator implements ElementValidator {
     private validateSettingList;
     registerElement(): CompileError[];
     validateBody(body?: FunctionApplicationNode | BlockExpressionNode): CompileError[];
-    validateInjections(injections: PartialInjectionNode[]): CompileError[];
-    registerInjection(injection: PartialInjectionNode): CompileError[];
     validateFields(fields: FunctionApplicationNode[]): CompileError[];
     registerField(field: FunctionApplicationNode): CompileError[];
     validateFieldSetting(parts: ExpressionNode[]): CompileError[];

package/dist/src/core/analyzer/validator/utils.d.ts

@@ -1,5 +1,5 @@
-import { SyntaxToken } from '../../lexer/tokens';
-import { AttributeNode, BlockExpressionNode, ElementDeclarationNode, ListExpressionNode, PrefixExpressionNode, PrimaryExpressionNode, SyntaxNode, TupleExpressionNode, VariableNode } from '../../parser/nodes';
+import { SyntaxToken, SyntaxTokenKind } from '../../lexer/tokens';
+import { AttributeNode, BlockExpressionNode, ElementDeclarationNode, ListExpressionNode, LiteralNode, PrefixExpressionNode, PrimaryExpressionNode, SyntaxNode, TupleExpressionNode, VariableNode } from '../../parser/nodes';
 import { default as CustomValidator } from './elementValidators/custom';
 import { default as EnumValidator } from './elementValidators/enum';
 import { default as IndexesValidator } from './elementValidators/indexes';
@@ -32,12 +32,27 @@ export declare function hasComplexBody(node: ElementDeclarationNode): node is El
 export declare function hasSimpleBody(node: ElementDeclarationNode): node is ElementDeclarationNode & {
     bodyColon: SyntaxToken;
 };
+export declare function isValidPartialInjection(node?: SyntaxNode): node is PrefixExpressionNode & {
+    op: {
+        value: '~';
+    };
+};
 export declare function registerSchemaStack(variables: string[], globalSchema: SymbolTable, symbolFactory: SymbolFactory): SymbolTable;
 export declare function isRelationshipOp(op?: string): boolean;
 export declare function isValidColor(value?: SyntaxNode): boolean;
 export declare function isVoid(value?: SyntaxNode): boolean;
 export declare function isValidDefaultValue(value?: SyntaxNode): boolean;
-export declare function isExpressionANumber(value?: SyntaxNode): boolean;
+export type SignedNumberExpression = (PrimaryExpressionNode & {
+    expression: LiteralNode & {
+        literal: {
+            kind: SyntaxTokenKind.NUMERIC_LITERAL;
+        };
+    };
+}) | (PrefixExpressionNode & {
+    op: '-' | '+';
+    expression: SignedNumberExpression;
+});
+export declare function isExpressionASignedNumberExpression(value?: SyntaxNode): value is SignedNumberExpression;
 export declare function isUnaryRelationship(value?: SyntaxNode): value is PrefixExpressionNode;
 export declare function isTupleOfVariables(value?: SyntaxNode): value is TupleExpressionNode & {
     elementList: (PrimaryExpressionNode & {

package/dist/src/core/interpreter/types.d.ts

@@ -17,7 +17,7 @@ export interface InterpreterDatabase {
     };
     ref: Map<ElementDeclarationNode, Ref>;
     enums: Map<ElementDeclarationNode, Enum>;
-    groupOfTable: {
+    tableOwnerGroup: {
         [tableid: string]: ElementDeclarationNode;
     };
     tableGroups: Map<ElementDeclarationNode, TableGroup>;

package/dist/src/core/lexer/tokens.d.ts

@@ -22,7 +22,6 @@ export declare enum SyntaxTokenKind {
     IDENTIFIER = "<identifier>",
     SEMICOLON = "<semicolon>",
     COLON = "<colon>",
-    TILDE = "<tilde>",
     SINGLE_LINE_COMMENT = "<single-line-comment>",
     MULTILINE_COMMENT = "<multiline-comment>"
 }