dt-sql-parser 4.0.3-beta.0 → 4.0.3-beta.1

package/dist/lib/trino/TrinoSqlParser.js

@@ -590,7 +590,7 @@ export class TrinoSqlParser extends SQLParserBase {
                                 this.state = 425;
                                 this.match(TrinoSqlParser.KW_COMMENT);
                                 this.state = 426;
-                                this.string_();
+                                localContext._comment = this.string_();
                             }
                         }
                         this.state = 431;
@@ -714,7 +714,7 @@ export class TrinoSqlParser extends SQLParserBase {
                                     this.state = 470;
                                     this.match(TrinoSqlParser.KW_COMMENT);
                                     this.state = 471;
-                                    this.string_();
+                                    localContext._comment = this.string_();
                                 }
                                 break;
                         }
@@ -1336,7 +1336,7 @@ export class TrinoSqlParser extends SQLParserBase {
                                 this.state = 679;
                                 this.match(TrinoSqlParser.KW_COMMENT);
                                 this.state = 680;
-                                this.string_();
+                                localContext._comment = this.string_();
                             }
                         }
                         this.state = 685;
@@ -1385,7 +1385,7 @@ export class TrinoSqlParser extends SQLParserBase {
                                 this.state = 697;
                                 this.match(TrinoSqlParser.KW_COMMENT);
                                 this.state = 698;
-                                this.string_();
+                                localContext._comment = this.string_();
                             }
                         }
                         this.state = 703;
@@ -3507,7 +3507,7 @@ export class TrinoSqlParser extends SQLParserBase {
                 this.state = 1270;
                 this.columnNameCreate();
                 this.state = 1271;
-                this.type_(0);
+                localContext._colType = this.type_(0);
                 this.state = 1274;
                 this.errorHandler.sync(this);
                 _la = this.tokenStream.LA(1);
@@ -3527,7 +3527,7 @@ export class TrinoSqlParser extends SQLParserBase {
                             this.state = 1276;
                             this.match(TrinoSqlParser.KW_COMMENT);
                             this.state = 1277;
-                            this.string_();
+                            localContext._comment = this.string_();
                         }
                         break;
                 }
@@ -4998,7 +4998,7 @@ export class TrinoSqlParser extends SQLParserBase {
                                         }
                                     }
                                     this.state = 1573;
-                                    this.identifier();
+                                    localContext._alias = this.identifier();
                                 }
                                 break;
                         }
@@ -6112,7 +6112,7 @@ export class TrinoSqlParser extends SQLParserBase {
                                 }
                             }
                             this.state = 1825;
-                            this.identifier();
+                            localContext._alias = this.identifier();
                             this.state = 1827;
                             this.errorHandler.sync(this);
                             switch (this.interpreter.adaptivePredict(this.tokenStream, 223, this.context)) {
@@ -20391,15 +20391,15 @@ export class CreateTableContext extends StatementContext {
     KW_COMMENT() {
         return this.getToken(TrinoSqlParser.KW_COMMENT, 0);
     }
-    string() {
-        return this.getRuleContext(0, StringContext);
-    }
     KW_WITH() {
         return this.getToken(TrinoSqlParser.KW_WITH, 0);
     }
     properties() {
         return this.getRuleContext(0, PropertiesContext);
     }
+    string() {
+        return this.getRuleContext(0, StringContext);
+    }
     enterRule(listener) {
         if (listener.enterCreateTable) {
             listener.enterCreateTable(this);
@@ -20558,9 +20558,6 @@ export class CreateTableAsSelectContext extends StatementContext {
     KW_COMMENT() {
         return this.getToken(TrinoSqlParser.KW_COMMENT, 0);
     }
-    string() {
-        return this.getRuleContext(0, StringContext);
-    }
     KW_WITH(i) {
         if (i === undefined) {
             return this.getTokens(TrinoSqlParser.KW_WITH);
@@ -20575,6 +20572,9 @@ export class CreateTableAsSelectContext extends StatementContext {
     KW_DATA() {
         return this.getToken(TrinoSqlParser.KW_DATA, 0);
     }
+    string() {
+        return this.getRuleContext(0, StringContext);
+    }
     KW_NO() {
         return this.getToken(TrinoSqlParser.KW_NO, 0);
     }
@@ -21228,15 +21228,15 @@ export class CreateMaterializedViewContext extends StatementContext {
     KW_COMMENT() {
         return this.getToken(TrinoSqlParser.KW_COMMENT, 0);
     }
-    string() {
-        return this.getRuleContext(0, StringContext);
-    }
     KW_WITH() {
         return this.getToken(TrinoSqlParser.KW_WITH, 0);
     }
     properties() {
         return this.getRuleContext(0, PropertiesContext);
     }
+    string() {
+        return this.getRuleContext(0, StringContext);
+    }
     enterRule(listener) {
         if (listener.enterCreateMaterializedView) {
             listener.enterCreateMaterializedView(this);
@@ -21324,9 +21324,6 @@ export class CreateViewContext extends StatementContext {
     KW_COMMENT() {
         return this.getToken(TrinoSqlParser.KW_COMMENT, 0);
     }
-    string() {
-        return this.getRuleContext(0, StringContext);
-    }
     KW_SECURITY() {
         return this.getToken(TrinoSqlParser.KW_SECURITY, 0);
     }
@@ -21336,6 +21333,9 @@ export class CreateViewContext extends StatementContext {
     properties() {
         return this.getRuleContext(0, PropertiesContext);
     }
+    string() {
+        return this.getRuleContext(0, StringContext);
+    }
     KW_DEFINER() {
         return this.getToken(TrinoSqlParser.KW_DEFINER, 0);
     }
@@ -22302,15 +22302,15 @@ export class ColumnDefinitionContext extends antlr.ParserRuleContext {
     KW_COMMENT() {
         return this.getToken(TrinoSqlParser.KW_COMMENT, 0);
     }
-    string() {
-        return this.getRuleContext(0, StringContext);
-    }
     KW_WITH() {
         return this.getToken(TrinoSqlParser.KW_WITH, 0);
     }
     properties() {
         return this.getRuleContext(0, PropertiesContext);
     }
+    string() {
+        return this.getRuleContext(0, StringContext);
+    }
     get ruleIndex() {
         return TrinoSqlParser.RULE_columnDefinition;
     }

package/dist/locale/locale.d.ts

@@ -0,0 +1,41 @@
+declare const i18n: {
+    zh_CN: {
+        stmtInComplete: string;
+        noValidPosition: string;
+        expecting: string;
+        unfinishedMultilineComment: string;
+        unfinishedDoubleQuoted: string;
+        unfinishedSingleQuoted: string;
+        unfinishedTickQuoted: string;
+        noValidInput: string;
+        newObj: string;
+        existingObj: string;
+        new: string;
+        existing: string;
+        orKeyword: string;
+        keyword: string;
+        missing: string;
+        at: string;
+        or: string;
+    };
+    en_US: {
+        stmtInComplete: string;
+        noValidPosition: string;
+        expecting: string;
+        unfinishedMultilineComment: string;
+        unfinishedDoubleQuoted: string;
+        unfinishedSingleQuoted: string;
+        unfinishedTickQuoted: string;
+        noValidInput: string;
+        newObj: string;
+        existingObj: string;
+        new: string;
+        existing: string;
+        orKeyword: string;
+        keyword: string;
+        missing: string;
+        at: string;
+        or: string;
+    };
+};
+export { i18n };

package/dist/locale/locale.js

@@ -0,0 +1,43 @@
+const zh_CN = {
+    stmtInComplete: '语句不完整',
+    noValidPosition: '在此位置无效',
+    expecting: '，期望',
+    unfinishedMultilineComment: '未完成的多行注释',
+    unfinishedDoubleQuoted: '未完成的双引号字符串字变量',
+    unfinishedSingleQuoted: '未完成的单引号字符串字变量',
+    unfinishedTickQuoted: '未完成的反引号引用字符串字变量',
+    noValidInput: '没有有效的输入',
+    newObj: '一个新的对象',
+    existingObj: '一个存在的对象',
+    new: '一个新的',
+    existing: '一个存在的',
+    orKeyword: '或者一个关键字',
+    keyword: '一个关键字',
+    missing: '缺少',
+    at: '在',
+    or: '或者',
+};
+const en_US = {
+    stmtInComplete: 'Statement is incomplete',
+    noValidPosition: 'is not valid at this position',
+    expecting: ', expecting ',
+    unfinishedMultilineComment: 'Unfinished multiline comment',
+    unfinishedDoubleQuoted: 'Unfinished double quoted string literal',
+    unfinishedSingleQuoted: 'Unfinished single quoted string literal',
+    unfinishedTickQuoted: 'Unfinished back tick quoted string literal',
+    noValidInput: 'is no valid input at all',
+    newObj: 'a new object',
+    existingObj: 'an existing object',
+    new: 'a new ',
+    existing: 'an existing ',
+    orKeyword: ' or a keyword',
+    keyword: 'a keyword',
+    missing: 'missing ',
+    at: ' at ',
+    or: ' or ',
+};
+const i18n = {
+    zh_CN,
+    en_US,
+};
+export { i18n };

package/dist/parser/common/basicSQL.d.ts

@@ -1,8 +1,8 @@
-import { Lexer, Token, CommonTokenStream, CharStream, ParserRuleContext, ParseTreeListener } from 'antlr4ng';
+import { Lexer, Token, CommonTokenStream, CharStream, ParserRuleContext, ParseTreeListener, ANTLRErrorListener } from 'antlr4ng';
 import { CandidatesCollection } from 'antlr4-c3';
 import { SQLParserBase } from '../../lib/SQLParserBase';
 import { TextSlice } from './textAndWord';
-import { CaretPosition, Suggestions } from './types';
+import { CaretPosition, LOCALE_TYPE, Suggestions } from './types';
 import { ParseError, ErrorListener } from './parseErrorListener';
 import type { SplitListener } from './splitListener';
 import type { EntityCollector } from './entityCollector';
@@ -47,10 +47,15 @@ export declare abstract class BasicSQL<L extends Lexer = Lexer, PRC extends Pars
      * Get a new splitListener instance.
      */
     protected abstract get splitListener(): SplitListener<ParserRuleContext>;
+    /**
+     * Get a new errorListener instance.
+     */
+    protected abstract createErrorListener(errorListener: ErrorListener): ANTLRErrorListener;
     /**
      * Get a new entityCollector instance.
      */
     protected abstract createEntityCollector(input: string, caretTokenIndex?: number): EntityCollector;
+    locale: LOCALE_TYPE;
     /**
      * Create an antlr4 lexer from input.
      * @param input string

package/dist/parser/common/basicSQL.js

@@ -2,7 +2,6 @@ import { CharStreams, CommonTokenStream, ParseTreeWalker, PredictionMode, } from
 import { CodeCompletionCore } from 'antlr4-c3';
 import { findCaretTokenIndex } from './findCaretTokenIndex';
 import { ctxToText, tokenToWord } from './textAndWord';
-import { ParseErrorListener } from './parseErrorListener';
 import { ErrorStrategy } from './errorStrategy';
 /**
  * Basic SQL class, every sql needs extends it.
@@ -14,6 +13,7 @@ export class BasicSQL {
         this._errorListener = (error) => {
             this._parseErrors.push(error);
         };
+        this.locale = 'en_US';
     }
     /**
      * Create an antlr4 lexer from input.
@@ -24,7 +24,7 @@ export class BasicSQL {
         const lexer = this.createLexerFromCharStream(charStreams);
         if (errorListener) {
             lexer.removeErrorListeners();
-            lexer.addErrorListener(new ParseErrorListener(errorListener));
+            lexer.addErrorListener(this.createErrorListener(errorListener));
         }
         return lexer;
     }
@@ -39,7 +39,7 @@ export class BasicSQL {
         parser.interpreter.predictionMode = PredictionMode.SLL;
         if (errorListener) {
             parser.removeErrorListeners();
-            parser.addErrorListener(new ParseErrorListener(errorListener));
+            parser.addErrorListener(this.createErrorListener(errorListener));
         }
         return parser;
     }
@@ -65,7 +65,7 @@ export class BasicSQL {
         this._charStreams = CharStreams.fromString(input);
         this._lexer = this.createLexerFromCharStream(this._charStreams);
         this._lexer.removeErrorListeners();
-        this._lexer.addErrorListener(new ParseErrorListener(this._errorListener));
+        this._lexer.addErrorListener(this.createErrorListener(this._errorListener));
         this._tokenStream = new CommonTokenStream(this._lexer);
         /**
          * All tokens are generated in advance.
@@ -96,7 +96,7 @@ export class BasicSQL {
         const parser = this.createParserWithCache(input);
         this._parsedInput = input;
         parser.removeErrorListeners();
-        parser.addErrorListener(new ParseErrorListener(this._errorListener));
+        parser.addErrorListener(this.createErrorListener(this._errorListener));
         this._parseTree = parser.program();
         return this._parseTree;
     }

package/dist/parser/common/entityCollector.d.ts

@@ -1,6 +1,6 @@
-import { ParserRuleContext } from 'antlr4ng';
+import { ParserRuleContext, Token } from 'antlr4ng';
+import { TextPosition, WordPosition, WordRange } from './textAndWord';
 import { EntityContextType } from './types';
-import { WordPosition, TextPosition } from './textAndWord';
 /**
  * TODO: more stmt type should be supported.
  */
@@ -24,20 +24,65 @@ export interface StmtContext {
     readonly isContainCaret?: boolean;
 }
 export declare function toStmtContext(ctx: ParserRuleContext, type: StmtContextType, input: string, rootStmt: StmtContext | null, parentStmt: StmtContext | null, isContainCaret?: boolean): StmtContext | null;
-export interface BaseAliasContext {
-    readonly isAlias: boolean;
-    alias?: string | EntityContext | null;
-    origin?: string | EntityContext | StmtContext | null;
+/**
+ * entity's attribute
+ * @key comment: entity's comment attribute
+ * @key colType: column entity's type attribute
+ * @key alias: entity's alias attribute
+ * */
+export declare enum AttrName {
+    comment = "_comment",
+    colType = "_colType",
+    alias = "_alias"
 }
-export interface EntityContext extends BaseAliasContext {
+/**
+ * ParserRuleContext with custom attributes
+ * */
+type ParserRuleContextWithAttr = ParserRuleContext & {
+    [K in AttrName]?: Token;
+};
+/**
+ * Function's arguments
+ * */
+export interface Argument {
+    argMode?: WordRange;
+    argName?: WordRange;
+    argType: WordRange;
+}
+export interface BaseEntityContext {
     readonly entityContextType: EntityContextType;
     readonly text: string;
     readonly position: WordPosition;
     readonly belongStmt: StmtContext;
-    relatedEntities: EntityContext[] | null;
-    columns: EntityContext[] | null;
+    reference?: string | EntityContext;
+    [AttrName.comment]: WordRange | null;
+    [AttrName.alias]?: WordRange | null;
+}
+export interface CommonEntityContext extends BaseEntityContext {
+    relatedEntities: CommonEntityContext[] | null;
+    columns?: ColumnEntityContext[];
+}
+export interface ColumnEntityContext extends BaseEntityContext {
+    [AttrName.colType]: WordRange | null;
+}
+export interface FuncEntityContext extends BaseEntityContext {
+    relatedEntities: CommonEntityContext[] | null;
+    arguments: Argument[] | null;
+    returns?: Argument;
+}
+export type EntityContext = CommonEntityContext | FuncEntityContext | ColumnEntityContext;
+export declare function isCommonEntityContext(entity: EntityContext): entity is CommonEntityContext;
+export declare function isFuncEntityContext(entity: EntityContext): entity is FuncEntityContext;
+export declare function isColumnEntityContext(entity: EntityContext): entity is ColumnEntityContext;
+/**
+ *  what we need when collect attribute information
+ * */
+interface AttrInfo {
+    attrName: AttrName;
+    endContextList: string[];
 }
-export declare function toEntityContext(ctx: ParserRuleContext, type: EntityContextType, input: string, belongStmt: StmtContext, alias?: BaseAliasContext): EntityContext | null;
+export declare function toEntityContext(ctx: ParserRuleContext, type: EntityContextType, input: string, belongStmt: StmtContext, attrInfo?: AttrInfo[]): EntityContext | null;
+export declare function findAttribute(ctx: ParserRuleContextWithAttr | null, keyName: AttrName, endContextNameList: string[]): Token | null;
 /**
  * @todo: Handle alias, includes column alias, table alias, query as alias and so on.
  * @todo: [may be need] Combine the entities in each clause.
@@ -60,11 +105,12 @@ export declare abstract class EntityCollector {
     visitErrorNode(): void;
     enterEveryRule(): void;
     exitEveryRule(): void;
+    getRootStmt(): StmtContext | null;
     getEntities(): EntityContext[];
     enterProgram(): void;
     protected pushStmt(ctx: ParserRuleContext, type: StmtContextType): StmtContext | null;
     protected popStmt(): StmtContext;
-    protected pushEntity(ctx: ParserRuleContext, type: EntityContextType, alias?: BaseAliasContext): EntityContext | null;
+    protected pushEntity(ctx: ParserRuleContext, type: EntityContextType, attrInfo?: AttrInfo[]): EntityContext | null;
     /**
      * Combine entities that inside a single statement.
      * e.g. combine tableName and column if they are inside a same createTableStatement.
@@ -77,3 +123,4 @@ export declare abstract class EntityCollector {
     protected combineRootStmtEntities(stmtContext: StmtContext, entitiesInsideStmt: EntityContext[]): EntityContext[];
     protected combineCreateTableOrViewStmtEntities(stmtContext: StmtContext, entitiesInsideStmt: EntityContext[]): EntityContext[];
 }
+export {};

package/dist/parser/common/entityCollector.js

@@ -9,9 +9,10 @@ var __rest = (this && this.__rest) || function (s, e) {
         }
     return t;
 };
-import { EntityContextType } from './types';
-import { ctxToText, ctxToWord } from './textAndWord';
+import { isToken } from 'antlr4ng';
 import { SimpleStack } from './simpleStack';
+import { ctxToText, isWordRange, tokenToWord, } from './textAndWord';
+import { EntityContextType } from './types';
 /**
  * TODO: more stmt type should be supported.
  */
@@ -41,20 +42,131 @@ export function toStmtContext(ctx, type, input, rootStmt, parentStmt, isContainC
         isContainCaret,
     };
 }
-const baseAlias = {
-    isAlias: false,
-    origin: null,
-    alias: null,
-};
-export function toEntityContext(ctx, type, input, belongStmt, alias) {
-    const word = ctxToWord(ctx, input);
+/**
+ * entity's attribute
+ * @key comment: entity's comment attribute
+ * @key colType: column entity's type attribute
+ * @key alias: entity's alias attribute
+ * */
+export var AttrName;
+(function (AttrName) {
+    AttrName["comment"] = "_comment";
+    AttrName["colType"] = "_colType";
+    AttrName["alias"] = "_alias";
+})(AttrName || (AttrName = {}));
+export function isCommonEntityContext(entity) {
+    if (!entity)
+        return false;
+    return 'relatedEntities' in entity && !('arguments' in entity);
+}
+export function isFuncEntityContext(entity) {
+    if (!entity)
+        return false;
+    return 'arguments' in entity;
+}
+export function isColumnEntityContext(entity) {
+    if (!entity)
+        return false;
+    return AttrName.colType in entity;
+}
+export function toEntityContext(ctx, type, input, belongStmt, attrInfo) {
+    var _a, _b;
+    const word = ctxToText(ctx, input);
     if (!word)
         return null;
-    const { text } = word, position = __rest(word, ["text"]);
-    const finalAlias = Object.assign({}, baseAlias, alias !== null && alias !== void 0 ? alias : {});
-    return Object.assign({ entityContextType: type, text,
+    const { text, startLine, endLine } = word, rest = __rest(word, ["text", "startLine", "endLine"]);
+    const position = Object.assign(Object.assign({}, rest), { line: startLine });
+    let entityInfo = {
+        entityContextType: type,
+        text,
         position,
-        belongStmt, relatedEntities: null, columns: null }, finalAlias);
+        belongStmt,
+        [AttrName.comment]: null,
+    };
+    switch (entityInfo.entityContextType) {
+        case EntityContextType.FUNCTION:
+        case EntityContextType.FUNCTION_CREATE: {
+            entityInfo.relatedEntities = null;
+            entityInfo.arguments = null;
+            break;
+        }
+        case EntityContextType.COLUMN:
+        case EntityContextType.COLUMN_CREATE:
+            entityInfo[AttrName.colType] = null;
+            break;
+        default:
+            entityInfo.relatedEntities = null;
+            break;
+    }
+    if (attrInfo) {
+        for (let k = 0; k < attrInfo.length; k++) {
+            const attributeName = (_a = attrInfo[k]) === null || _a === void 0 ? void 0 : _a.attrName;
+            const attrToken = findAttribute(ctx, attributeName, (_b = attrInfo[k]) === null || _b === void 0 ? void 0 : _b.endContextList);
+            if (attrToken) {
+                const attrVal = isToken(attrToken)
+                    ? tokenToWord(attrToken, input)
+                    : ctxToText(attrToken, input);
+                if (attrVal) {
+                    if (isWordRange(attrVal)) {
+                        entityInfo = Object.assign(entityInfo, {
+                            [attributeName]: attrVal,
+                        });
+                    }
+                    else {
+                        const { startIndex, endIndex, startColumn, endColumn, text } = attrVal, rest = __rest(attrVal, ["startIndex", "endIndex", "startColumn", "endColumn", "text"]);
+                        entityInfo = Object.assign(entityInfo, {
+                            [attributeName]: {
+                                startIndex,
+                                endIndex,
+                                startColumn,
+                                endColumn,
+                                text,
+                                line: rest === null || rest === void 0 ? void 0 : rest.startLine,
+                            },
+                        });
+                    }
+                }
+            }
+        }
+    }
+    return entityInfo;
+}
+export function findAttribute(ctx, keyName, endContextNameList) {
+    var _a, _b;
+    const parent = (ctx === null || ctx === void 0 ? void 0 : ctx.parent) || null;
+    let attrVal = null;
+    if (parent === null || parent === void 0 ? void 0 : parent[keyName]) {
+        attrVal = (parent === null || parent === void 0 ? void 0 : parent[keyName]) || null;
+        return attrVal;
+    }
+    else {
+        if (((_a = parent === null || parent === void 0 ? void 0 : parent.constructor) === null || _a === void 0 ? void 0 : _a.name) && !endContextNameList.includes((_b = parent === null || parent === void 0 ? void 0 : parent.constructor) === null || _b === void 0 ? void 0 : _b.name)) {
+            attrVal = findAttribute(parent, keyName, endContextNameList);
+        }
+        if (!attrVal) {
+            if (parent === null || parent === void 0 ? void 0 : parent.children) {
+                attrVal = findAttributeChildren(parent, keyName);
+            }
+        }
+    }
+    return attrVal;
+}
+function findAttributeChildren(ctx, keyName) {
+    const visitChildren = (ctx === null || ctx === void 0 ? void 0 : ctx.children) || [];
+    let attrVal = null;
+    if (visitChildren.length) {
+        for (let i = 0; i < visitChildren.length; i++) {
+            const child = visitChildren[i] || null;
+            if (child === null || child === void 0 ? void 0 : child[keyName]) {
+                attrVal = (child === null || child === void 0 ? void 0 : child[keyName]) || null;
+                return attrVal;
+            }
+            else {
+                attrVal = findAttributeChildren(child, keyName);
+            }
+        }
+    }
+    return attrVal;
 }
 /**
  * @todo: Handle alias, includes column alias, table alias, query as alias and so on.
@@ -73,6 +185,9 @@ export class EntityCollector {
     visitErrorNode() { }
     enterEveryRule() { }
     exitEveryRule() { }
+    getRootStmt() {
+        return this._rootStmt;
+    }
     getEntities() {
         return Array.from(this._entitiesSet);
     }
@@ -112,8 +227,8 @@ export class EntityCollector {
         }
         return stmtContext;
     }
-    pushEntity(ctx, type, alias) {
-        const entityContext = toEntityContext(ctx, type, this._input, this._stmtStack.peek(), alias);
+    pushEntity(ctx, type, attrInfo) {
+        const entityContext = toEntityContext(ctx, type, this._input, this._stmtStack.peek(), attrInfo);
         if (entityContext) {
             if (this._stmtStack.isEmpty()) {
                 this._entitiesSet.add(entityContext);
@@ -182,10 +297,18 @@ export class EntityCollector {
             return result;
         }, []);
         if (mainEntity && columns.length) {
-            mainEntity.columns = columns;
+            if (isCommonEntityContext(mainEntity)) {
+                mainEntity = Object.assign(mainEntity, {
+                    columns,
+                });
+            }
         }
         if (mainEntity && relatedEntities.length) {
-            mainEntity.relatedEntities = relatedEntities;
+            if (isCommonEntityContext(mainEntity) || isFuncEntityContext(mainEntity)) {
+                mainEntity = Object.assign(mainEntity, {
+                    relatedEntities,
+                });
+            }
         }
         return finalEntities;
     }

package/dist/parser/common/parseErrorListener.d.ts

@@ -1,4 +1,5 @@
-import { Token, Recognizer, ANTLRErrorListener, RecognitionException, ATNSimulator } from 'antlr4ng';
+import { Token, Recognizer, ANTLRErrorListener, RecognitionException, ATNSimulator, Parser } from 'antlr4ng';
+import { LOCALE_TYPE } from './types';
 /**
  * Converted from {@link SyntaxError}.
  */
@@ -29,11 +30,13 @@ export interface SyntaxError {
  * Includes lexical errors and parsing errors.
  */
 export type ErrorListener = (parseError: ParseError, originalError: SyntaxError) => void;
-export declare class ParseErrorListener implements ANTLRErrorListener {
+export declare abstract class ParseErrorListener implements ANTLRErrorListener {
     private _errorListener;
-    constructor(errorListener: ErrorListener);
+    private locale;
+    constructor(errorListener: ErrorListener, locale?: LOCALE_TYPE);
     reportAmbiguity(): void;
     reportAttemptingFullContext(): void;
     reportContextSensitivity(): void;
+    protected abstract getExpectedText(parser: Parser, token: Token): string;
     syntaxError(recognizer: Recognizer<ATNSimulator>, offendingSymbol: Token | null, line: number, charPositionInLine: number, msg: string, e: RecognitionException): void;
 }