@dbml/parse 7.0.0-alpha.1 → 7.0.1-alpha.0

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

@@ -1,9 +1,9 @@
-import { SyntaxToken } from '../../../lexer/tokens';
-import { default as SymbolFactory } from '../../symbol/factory';
-import { CompileError, CompileWarning } from '../../../errors';
-import { BlockExpressionNode, ElementDeclarationNode, FunctionApplicationNode, ListExpressionNode } from '../../../parser/nodes';
 import { ElementValidator } from '../types';
-import { default as SymbolTable } from '../../symbol/symbolTable';
+import { CompileError, CompileWarning } from '../../../types/errors';
+import { BlockExpressionNode, ElementDeclarationNode, FunctionApplicationNode, ListExpressionNode } from '../../../types/nodes';
+import { default as SymbolFactory } from '../../../types/symbol/factory';
+import { default as SymbolTable } from '../../../types/symbol/symbolTable';
+import { SyntaxToken } from '../../../types/tokens';
 export default class RefValidator implements ElementValidator {
     private declarationNode;
     private publicSymbolTable;

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

@@ -1,9 +1,9 @@
-import { default as SymbolFactory } from '../../symbol/factory';
-import { CompileError, CompileWarning } from '../../../errors';
-import { BlockExpressionNode, ElementDeclarationNode, ExpressionNode, FunctionApplicationNode } from '../../../parser/nodes';
 import { ElementValidator } from '../types';
-import { SyntaxToken } from '../../../lexer/tokens';
-import { default as SymbolTable } from '../../symbol/symbolTable';
+import { CompileError, CompileWarning } from '../../../types/errors';
+import { BlockExpressionNode, ElementDeclarationNode, ExpressionNode, FunctionApplicationNode } from '../../../types/nodes';
+import { default as SymbolFactory } from '../../../types/symbol/factory';
+import { default as SymbolTable } from '../../../types/symbol/symbolTable';
+import { SyntaxToken } from '../../../types/tokens';
 export default class TableValidator implements ElementValidator {
     private declarationNode;
     private symbolFactory;

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

@@ -1,9 +1,9 @@
-import { CompileError, CompileWarning } from '../../../errors';
 import { ElementValidator } from '../types';
-import { default as SymbolTable } from '../../symbol/symbolTable';
-import { SyntaxToken } from '../../../lexer/tokens';
-import { BlockExpressionNode, ElementDeclarationNode, FunctionApplicationNode } from '../../../parser/nodes';
-import { default as SymbolFactory } from '../../symbol/factory';
+import { CompileError, CompileWarning } from '../../../types/errors';
+import { BlockExpressionNode, ElementDeclarationNode, FunctionApplicationNode } from '../../../types/nodes';
+import { default as SymbolFactory } from '../../../types/symbol/factory';
+import { default as SymbolTable } from '../../../types/symbol/symbolTable';
+import { SyntaxToken } from '../../../types/tokens';
 export default class TableGroupValidator implements ElementValidator {
     private declarationNode;
     private publicSymbolTable;

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

@@ -1,9 +1,9 @@
-import { default as SymbolFactory } from '../../symbol/factory';
-import { CompileError, CompileWarning } from '../../../errors';
-import { BlockExpressionNode, ElementDeclarationNode, ExpressionNode, FunctionApplicationNode } from '../../../parser/nodes';
 import { ElementValidator } from '../types';
-import { SyntaxToken } from '../../../lexer/tokens';
-import { default as SymbolTable } from '../../symbol/symbolTable';
+import { CompileError, CompileWarning } from '../../../types/errors';
+import { BlockExpressionNode, ElementDeclarationNode, ExpressionNode, FunctionApplicationNode } from '../../../types/nodes';
+import { default as SymbolFactory } from '../../../types/symbol/factory';
+import { default as SymbolTable } from '../../../types/symbol/symbolTable';
+import { SyntaxToken } from '../../../types/tokens';
 export default class TablePartialValidator implements ElementValidator {
     private declarationNode;
     private symbolFactory;

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

@@ -1,4 +1,4 @@
-import { CompileError, CompileWarning } from '../../errors';
+import { CompileError, CompileWarning } from '../../types/errors';
 export interface ElementValidator {
     validate(): {
         errors: CompileError[];

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

@@ -1,23 +1,23 @@
-import { SyntaxToken, SyntaxTokenKind } from '../../lexer/tokens';
-import { AttributeNode, BlockExpressionNode, ElementDeclarationNode, ListExpressionNode, LiteralNode, PrefixExpressionNode, PrimaryExpressionNode, SyntaxNode, TupleExpressionNode, VariableNode } from '../../parser/nodes';
+import { AttributeNode, BlockExpressionNode, ElementDeclarationNode, ListExpressionNode, LiteralNode, PrefixExpressionNode, PrimaryExpressionNode, SyntaxNode, TupleExpressionNode, VariableNode } from '../../types/nodes';
+import { default as Report } from '../../types/report';
+import { default as SymbolFactory } from '../../types/symbol/factory';
+import { default as SymbolTable } from '../../types/symbol/symbolTable';
+import { SyntaxToken, SyntaxTokenKind } from '../../types/tokens';
+import { default as ChecksValidator } from './elementValidators/checks';
 import { default as CustomValidator } from './elementValidators/custom';
+import { default as DiagramViewValidator } from './elementValidators/diagramView';
 import { default as EnumValidator } from './elementValidators/enum';
 import { default as IndexesValidator } from './elementValidators/indexes';
 import { default as NoteValidator } from './elementValidators/note';
 import { default as ProjectValidator } from './elementValidators/project';
+import { default as RecordsValidator } from './elementValidators/records';
 import { default as RefValidator } from './elementValidators/ref';
 import { default as TableValidator } from './elementValidators/table';
 import { default as TableGroupValidator } from './elementValidators/tableGroup';
-import { default as SymbolTable } from '../symbol/symbolTable';
-import { default as SymbolFactory } from '../symbol/factory';
-import { default as Report } from '../../report';
 import { default as TablePartialValidator } from './elementValidators/tablePartial';
-import { default as ChecksValidator } from './elementValidators/checks';
-import { default as RecordsValidator } from './elementValidators/records';
-import { default as DiagramViewValidator } from './elementValidators/diagramView';
 export declare function pickValidator(element: ElementDeclarationNode & {
     type: SyntaxToken;
-}): typeof CustomValidator | typeof EnumValidator | typeof TableValidator | typeof TableGroupValidator | typeof ProjectValidator | typeof RefValidator | typeof NoteValidator | typeof IndexesValidator | typeof TablePartialValidator | typeof ChecksValidator | typeof RecordsValidator | typeof DiagramViewValidator;
+}): typeof ChecksValidator | typeof EnumValidator | typeof TableValidator | typeof TableGroupValidator | typeof ProjectValidator | typeof RefValidator | typeof NoteValidator | typeof IndexesValidator | typeof TablePartialValidator | typeof RecordsValidator | typeof DiagramViewValidator | typeof CustomValidator;
 export declare function isValidName(nameNode: SyntaxNode): boolean;
 export declare function isValidAlias(aliasNode: SyntaxNode): aliasNode is PrimaryExpressionNode & {
     expression: VariableNode;
@@ -41,7 +41,6 @@ export declare function isValidPartialInjection(node?: SyntaxNode): node is Pref
 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 type SignedNumberExpression = (PrimaryExpressionNode & {
     expression: LiteralNode & {

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

@@ -1,6 +1,6 @@
-import { default as Report } from '../../report';
-import { ProgramNode } from '../../parser/nodes';
-import { default as SymbolFactory } from '../symbol/factory';
+import { ProgramNode } from '../../types/nodes';
+import { default as Report } from '../../types/report';
+import { default as SymbolFactory } from '../../types/symbol/factory';
 export default class Validator {
     private ast;
     private publicSchemaSymbol;

package/dist/src/core/interpreter/elementInterpreter/diagramView.d.ts

@@ -1,6 +1,6 @@
-import { CompileError } from '../../errors';
-import { ElementDeclarationNode } from '../../parser/nodes';
 import { ElementInterpreter, InterpreterDatabase } from '../types';
+import { CompileError } from '../../types/errors';
+import { ElementDeclarationNode } from '../../types/nodes';
 export declare class DiagramViewInterpreter implements ElementInterpreter {
     private declarationNode;
     private env;

package/dist/src/core/interpreter/elementInterpreter/enum.d.ts

@@ -1,5 +1,5 @@
-import { CompileError } from '../../errors';
-import { ElementDeclarationNode } from '../../parser/nodes';
+import { CompileError } from '../../types/errors';
+import { ElementDeclarationNode } from '../../types/nodes';
 import { ElementInterpreter, InterpreterDatabase } from '../types';
 export declare class EnumInterpreter implements ElementInterpreter {
     private declarationNode;

package/dist/src/core/interpreter/elementInterpreter/project.d.ts

@@ -1,5 +1,5 @@
-import { CompileError } from '../../errors';
-import { ElementDeclarationNode } from '../../parser/nodes';
+import { CompileError } from '../../types/errors';
+import { ElementDeclarationNode } from '../../types/nodes';
 import { ElementInterpreter, InterpreterDatabase } from '../types';
 export declare class ProjectInterpreter implements ElementInterpreter {
     private declarationNode;

package/dist/src/core/interpreter/elementInterpreter/ref.d.ts

@@ -1,5 +1,5 @@
-import { CompileError } from '../../errors';
-import { ElementDeclarationNode } from '../../parser/nodes';
+import { CompileError } from '../../types/errors';
+import { ElementDeclarationNode } from '../../types/nodes';
 import { ElementInterpreter, InterpreterDatabase } from '../types';
 export declare class RefInterpreter implements ElementInterpreter {
     private declarationNode;

package/dist/src/core/interpreter/elementInterpreter/sticky_note.d.ts

@@ -1,6 +1,6 @@
+import { CompileError } from '../../types/errors';
+import { ElementDeclarationNode } from '../../types/nodes';
 import { ElementInterpreter, InterpreterDatabase } from '../types';
-import { ElementDeclarationNode } from '../../parser/nodes';
-import { CompileError } from '../../errors';
 export declare class StickyNoteInterpreter implements ElementInterpreter {
     private declarationNode;
     private env;

package/dist/src/core/interpreter/elementInterpreter/table.d.ts

@@ -1,6 +1,6 @@
+import { CompileError } from '../../types/errors';
+import { ElementDeclarationNode } from '../../types/nodes';
 import { ElementInterpreter, InterpreterDatabase } from '../types';
-import { ElementDeclarationNode } from '../../parser/nodes';
-import { CompileError } from '../../errors';
 export declare class TableInterpreter implements ElementInterpreter {
     private declarationNode;
     private env;

package/dist/src/core/interpreter/elementInterpreter/tableGroup.d.ts

@@ -1,5 +1,5 @@
-import { CompileError } from '../../errors';
-import { ElementDeclarationNode } from '../../parser/nodes';
+import { CompileError } from '../../types/errors';
+import { ElementDeclarationNode } from '../../types/nodes';
 import { ElementInterpreter, InterpreterDatabase } from '../types';
 export declare class TableGroupInterpreter implements ElementInterpreter {
     private declarationNode;

package/dist/src/core/interpreter/elementInterpreter/tablePartial.d.ts

@@ -1,6 +1,6 @@
+import { CompileError } from '../../types/errors';
+import { ElementDeclarationNode } from '../../types/nodes';
 import { ElementInterpreter, InterpreterDatabase } from '../types';
-import { ElementDeclarationNode } from '../../parser/nodes';
-import { CompileError } from '../../errors';
 export declare class TablePartialInterpreter implements ElementInterpreter {
     private declarationNode;
     private env;

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

@@ -1,6 +1,7 @@
-import { ProgramNode } from '../parser/nodes';
-import { Database, InterpreterDatabase } from './types';
-import { default as Report } from '../report';
+import { ProgramNode } from '../types/nodes';
+import { default as Report } from '../types/report';
+import { Database } from '../types/schemaJson';
+import { InterpreterDatabase } from './types';
 export default class Interpreter {
     ast: ProgramNode;
     env: InterpreterDatabase;

package/dist/src/core/interpreter/records/index.d.ts

@@ -1,5 +1,5 @@
-import { ElementDeclarationNode } from '../../parser/nodes';
-import { default as Report } from '../../report';
+import { ElementDeclarationNode } from '../../types/nodes';
+import { default as Report } from '../../types/report';
 import { InterpreterDatabase } from '../types';
 export declare class RecordsInterpreter {
     private env;

package/dist/src/core/interpreter/records/utils/constraints/fk.d.ts

@@ -1,3 +1,3 @@
-import { CompileError } from '../../../../errors';
 import { InterpreterDatabase } from '../../../types';
+import { CompileError } from '../../../../types/errors';
 export declare function validateForeignKeys(env: InterpreterDatabase): CompileError[];

package/dist/src/core/interpreter/records/utils/constraints/helper.d.ts

@@ -1,5 +1,6 @@
-import { RecordValue, Column, TableRecordRow } from '../../../types';
-import { CompileError } from '../../../../errors';
+import { TableRecordRow } from '../../../types';
+import { CompileError } from '../../../../types/errors';
+import { Column, RecordValue } from '../../../../types/schemaJson';
 export declare function extractKeyValueWithDefault(row: Record<string, RecordValue>, columnNames: string[], columns?: (Column | undefined)[]): string;
 export declare function hasNullWithoutDefaultInKey(row: Record<string, RecordValue>, columnNames: string[], columns?: (Column | undefined)[]): boolean;
 export declare function isAutoIncrementColumn(column: Column): boolean;

package/dist/src/core/interpreter/records/utils/constraints/pk.d.ts

@@ -1,3 +1,3 @@
-import { CompileError } from '../../../../errors';
 import { InterpreterDatabase } from '../../../types';
+import { CompileError } from '../../../../types/errors';
 export declare function validatePrimaryKey(env: InterpreterDatabase): CompileError[];

package/dist/src/core/interpreter/records/utils/constraints/unique.d.ts

@@ -1,3 +1,3 @@
-import { CompileError } from '../../../../errors';
 import { InterpreterDatabase } from '../../../types';
+import { CompileError } from '../../../../types/errors';
 export declare function validateUnique(env: InterpreterDatabase): CompileError[];

package/dist/src/core/interpreter/records/utils/data/sqlTypes.d.ts

@@ -1,4 +1,4 @@
-import { ColumnSymbol } from '../../../../analyzer/symbol/symbols';
+import { ColumnSymbol } from '../../../../types/symbol/symbols';
 export type SqlDialect = 'mysql' | 'postgres' | 'mssql' | 'oracle' | 'snowflake';
 export declare function normalizeTypeName(type: string): string;
 export declare function isIntegerType(type: string, dialect?: SqlDialect): boolean;

package/dist/src/core/interpreter/records/utils/data/values.d.ts

@@ -1,5 +1,5 @@
-import { FunctionExpressionNode, SyntaxNode } from '../../../../parser/nodes';
-export { extractNumericLiteral } from '../../../../analyzer/utils';
+import { FunctionExpressionNode, SyntaxNode } from '../../../../types/nodes';
+export { extractNumericLiteral, } from '../../../../analyzer/utils';
 export declare function isNullish(value: SyntaxNode): boolean;
 export declare function isEmptyStringLiteral(value: SyntaxNode): boolean;
 export declare function isFunctionExpression(value: SyntaxNode): value is FunctionExpressionNode;

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

@@ -1,48 +1,18 @@
-import { ElementDeclarationNode, FunctionApplicationNode, SyntaxNode } from '../parser/nodes';
-import { Position } from '../types';
-import { CompileError } from '../errors';
-export interface TokenPosition {
-    start: Position;
-    end: Position;
-}
+import { CompileError } from '../types/errors';
+import { ElementDeclarationNode, FunctionApplicationNode, SyntaxNode } from '../types/nodes';
+import { Alias, DiagramView, Enum, FilterConfig, Note, Project, RecordValueType, Ref, Table, TableGroup, TablePartial } from '../types/schemaJson';
+export type { DiagramView, FilterConfig, };
 export interface ElementInterpreter {
     interpret(): CompileError[];
 }
-/**
- * FilterConfig is a tri-state filter:
- * - [] (empty array) = show all
- * - [...] (array with items) = show only these specific items
- * - null = hide all
- */
-export interface FilterConfig {
-    tables: Array<{
-        name: string;
-        schemaName: string;
-    }> | null;
-    stickyNotes: Array<{
-        name: string;
-    }> | null;
-    tableGroups: Array<{
-        name: string;
-    }> | null;
-    schemas: Array<{
-        name: string;
-    }> | null;
-}
-export interface DiagramView {
-    name: string;
-    schemaName: string | null;
-    visibleEntities: FilterConfig;
-    token: TokenPosition;
-}
 export interface InterpreterDatabase {
     schema: [];
     tables: Map<ElementDeclarationNode, Table>;
     notes: Map<ElementDeclarationNode, Note>;
     refIds: {
-        [refid: string]: ElementDeclarationNode;
+        [refid: string]: SyntaxNode;
     };
-    ref: Map<ElementDeclarationNode, Ref>;
+    ref: Map<SyntaxNode, Ref>;
     enums: Map<ElementDeclarationNode, Enum>;
     tableOwnerGroup: {
         [tableid: string]: ElementDeclarationNode;
@@ -51,7 +21,10 @@ export interface InterpreterDatabase {
     tablePartials: Map<ElementDeclarationNode, TablePartial>;
     aliases: Alias[];
     project: Map<ElementDeclarationNode, Project>;
-    records: Map<Table, TableRecordRow[]>;
+    records: Map<Table, {
+        element: ElementDeclarationNode;
+        rows: TableRecordRow[];
+    }>;
     recordsElements: ElementDeclarationNode[];
     cachedMergedTables: Map<Table, Table>;
     source: string;
@@ -59,11 +32,6 @@ export interface InterpreterDatabase {
     diagramViewWildcards: Map<DiagramView, Set<string>>;
     diagramViewExplicitlySet: Map<DiagramView, Set<string>>;
 }
-export type RecordValueType = 'string' | 'bool' | 'integer' | 'real' | 'date' | 'time' | 'datetime' | string;
-export interface RecordValue {
-    value: any;
-    type: RecordValueType;
-}
 export interface TableRecordRow {
     values: Record<string, {
         value: any;
@@ -77,189 +45,3 @@ export interface TableRecordsData {
     table: Table;
     rows: TableRecordRow[];
 }
-export interface TableRecord {
-    schemaName: string | undefined;
-    tableName: string;
-    columns: string[];
-    values: RecordValue[][];
-}
-export interface Database {
-    schemas: [];
-    tables: Table[];
-    notes: Note[];
-    refs: Ref[];
-    enums: Enum[];
-    tableGroups: TableGroup[];
-    aliases: Alias[];
-    project: Project;
-    tablePartials: TablePartial[];
-    records: TableRecord[];
-    diagramViews: DiagramView[];
-}
-export interface Table {
-    name: string;
-    schemaName: null | string;
-    alias: string | null;
-    fields: Column[];
-    checks: Check[];
-    partials: TablePartialInjection[];
-    token: TokenPosition;
-    indexes: Index[];
-    headerColor?: string;
-    note?: {
-        value: string;
-        token: TokenPosition;
-    };
-}
-export interface Note {
-    name: string;
-    content: string;
-    token: TokenPosition;
-    headerColor?: string;
-}
-export interface ColumnType {
-    schemaName: string | null;
-    type_name: string;
-    args: string | null;
-    numericParams?: {
-        precision: number;
-        scale: number;
-    };
-    lengthParam?: {
-        length: number;
-    };
-    isEnum?: boolean;
-}
-export interface Column {
-    name: string;
-    type: ColumnType;
-    token: TokenPosition;
-    inline_refs: InlineRef[];
-    checks: Check[];
-    pk?: boolean;
-    dbdefault?: {
-        type: 'number' | 'string' | 'boolean' | 'expression';
-        value: number | string;
-    };
-    increment?: boolean;
-    unique?: boolean;
-    not_null?: boolean;
-    note?: {
-        value: string;
-        token: TokenPosition;
-    };
-}
-export interface Index {
-    columns: {
-        value: string;
-        type: string;
-        token: TokenPosition;
-    }[];
-    token: TokenPosition;
-    unique?: boolean;
-    pk?: boolean;
-    name?: string;
-    note?: {
-        value: string;
-        token: TokenPosition;
-    };
-    type?: string;
-}
-export interface Check {
-    token: TokenPosition;
-    expression: string;
-    name?: string;
-}
-export interface InlineRef {
-    schemaName: string | null;
-    tableName: string;
-    fieldNames: string[];
-    relation: '>' | '<' | '-' | '<>';
-    token: TokenPosition;
-}
-export interface Ref {
-    schemaName: string | null;
-    name: string | null;
-    endpoints: RefEndpointPair;
-    color?: string;
-    onDelete?: string;
-    onUpdate?: string;
-    token: TokenPosition;
-}
-export type RefEndpointPair = [RefEndpoint, RefEndpoint];
-export interface RefEndpoint {
-    schemaName: string | null;
-    tableName: string;
-    fieldNames: string[];
-    relation: RelationCardinality;
-    token: TokenPosition;
-}
-export type RelationCardinality = '1' | '*';
-export interface Enum {
-    name: string;
-    schemaName: string | null;
-    token: TokenPosition;
-    values: EnumField[];
-}
-export interface EnumField {
-    name: string;
-    token: TokenPosition;
-    note?: {
-        value: string;
-        token: TokenPosition;
-    };
-}
-export interface TableGroup {
-    name: string | null;
-    schemaName: string | null;
-    tables: TableGroupField[];
-    token: TokenPosition;
-    color?: string;
-    note?: {
-        value: string;
-        token: TokenPosition;
-    };
-}
-export interface TableGroupField {
-    name: string;
-    schemaName: string | null;
-}
-export interface Alias {
-    name: string;
-    kind: 'table';
-    value: {
-        tableName: string;
-        schemaName: string | null;
-    };
-}
-export interface TablePartial {
-    name: string;
-    fields: Column[];
-    token: TokenPosition;
-    indexes: Index[];
-    headerColor?: string;
-    checks: Check[];
-    note?: {
-        value: string;
-        token: TokenPosition;
-    };
-}
-export interface TablePartialInjection {
-    name: string;
-    order: number;
-    token: TokenPosition;
-}
-export type Project = Record<string, never> | {
-    name: string | null;
-    tables: Table[];
-    refs: Ref[];
-    enums: Enum[];
-    tableGroups: TableGroup[];
-    tablePartials: TablePartial[];
-    note?: {
-        value: string;
-        token: TokenPosition;
-    };
-    token: TokenPosition;
-    [index: string & Omit<any, 'name' | 'tables' | 'refs' | 'enums' | 'tableGroups' | 'note' | 'tablePartials' | 'records'>]: string;
-};

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

@@ -1,8 +1,9 @@
-import { ColumnSymbol } from '../analyzer/symbol/symbols';
-import { LiteralNode, PrimaryExpressionNode, SyntaxNode } from '../parser/nodes';
-import { ColumnType, RelationCardinality, Table, TokenPosition, InterpreterDatabase, Ref } from './types';
-import { SyntaxTokenKind } from '../lexer/tokens';
-import { default as Report } from '../report';
+import { LiteralNode, PrimaryExpressionNode, SyntaxNode } from '../types/nodes';
+import { default as Report } from '../types/report';
+import { ColumnType, Ref, RelationCardinality, Table, TokenPosition } from '../types/schemaJson';
+import { ColumnSymbol } from '../types/symbol/symbols';
+import { SyntaxTokenKind } from '../types/tokens';
+import { InterpreterDatabase } from './types';
 export declare function extractNamesFromRefOperand(operand: SyntaxNode, owner?: Table): {
     schemaName: string | null;
     tableName: string;

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

@@ -1,12 +1,14 @@
-import { default as Report } from '../report';
-import { SyntaxToken, SyntaxTokenKind } from './tokens';
+import { Filepath } from '../types/filepath';
+import { default as Report } from '../types/report';
+import { SyntaxToken, SyntaxTokenKind } from '../types/tokens';
 export default class Lexer {
     private start;
     private current;
     private text;
+    private filepath;
     private tokens;
     private errors;
-    constructor(text: string);
+    constructor(text: string, filepath: Filepath);
     private isAtEnd;
     private advance;
     private peek;

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

@@ -1,4 +1,4 @@
-import { SyntaxToken } from './tokens';
+import { SyntaxToken } from '../types/tokens';
 export declare function hasTrailingNewLines(token: SyntaxToken): boolean;
 export declare function isAtStartOfLine(previous: SyntaxToken, token: SyntaxToken): boolean;
 export declare function hasTrailingSpaces(token: SyntaxToken): boolean;

package/dist/src/core/parser/contextStack.d.ts

@@ -1,4 +1,4 @@
-import { SyntaxToken } from '../lexer/tokens';
+import { SyntaxToken } from '../types/tokens';
 export declare const enum ParsingContext {
     ListExpression = 0,
     GroupExpression = 1,

package/dist/src/core/parser/factory.d.ts

@@ -1,8 +1,10 @@
-import { SyntaxNode, SyntaxNodeId, SyntaxNodeIdGenerator } from './nodes';
+import { Filepath } from '../types/filepath';
+import { SyntaxNode, SyntaxNodeId, SyntaxNodeIdGenerator } from '../types/nodes';
 export default class NodeFactory {
     private generator;
-    constructor(generator: SyntaxNodeIdGenerator);
+    private filepath;
+    constructor(generator: SyntaxNodeIdGenerator, filepath: Filepath);
     create<T extends SyntaxNode, A>(Type: {
-        new (args: A, id: SyntaxNodeId): T;
+        new (args: A, id: SyntaxNodeId, filepath: Filepath): T;
     }, args: A): T;
 }

package/dist/src/core/parser/parser.d.ts

@@ -1,6 +1,7 @@
-import { SyntaxToken } from '../lexer/tokens';
-import { default as Report } from '../report';
-import { ProgramNode, SyntaxNodeIdGenerator } from './nodes';
+import { Filepath } from '../types/filepath';
+import { ProgramNode, SyntaxNodeIdGenerator } from '../types/nodes';
+import { default as Report } from '../types/report';
+import { SyntaxToken } from '../types/tokens';
 export default class Parser {
     private tokens;
     private current;
@@ -8,7 +9,7 @@ export default class Parser {
     private contextStack;
     private nodeFactory;
     private source;
-    constructor(source: string, tokens: SyntaxToken[], nodeIdGenerator: SyntaxNodeIdGenerator);
+    constructor(source: string, tokens: SyntaxToken[], nodeIdGenerator: SyntaxNodeIdGenerator, filepath: Filepath);
     private isAtEnd;
     private advance;
     private peek;