@dbml/parse 3.6.1 → 3.6.2

package/dist/lib/lexer/lexer.d.ts

@@ -0,0 +1,43 @@
+import { CompileError } from '../errors';
+import { default as Report } from '../report';
+import { SyntaxToken, SyntaxTokenKind } from './tokens';
+
+export default class Lexer {
+    private start;
+    private current;
+    private text;
+    private tokens;
+    private errors;
+    constructor(text: string);
+    private isAtEnd;
+    private advance;
+    private peek;
+    check(sequence: string): boolean;
+    match(sequence: string): boolean;
+    private addToken;
+    private createToken;
+    lex(): Report<SyntaxToken[], CompileError>;
+    scanTokens(): void;
+    gatherTrivia(): void;
+    gatherInvalid(): void;
+    consumeUntil(tokenKind: SyntaxTokenKind, stopSequence: string, { allowNewline, // Whether newline is allowed
+    allowEof, // Whether EOF is allowed
+    raw, // Whether to interpret '\' as a backlash
+    consumeStopSequence, }: {
+        allowNewline: boolean;
+        allowEof: boolean;
+        raw: boolean;
+        consumeStopSequence?: boolean;
+    }): void;
+    singleLineStringLiteral(): void;
+    multilineStringLiteral(): void;
+    functionExpression(): void;
+    quotedVariable(): void;
+    singleLineComment(): void;
+    multilineComment(): void;
+    identifier(): void;
+    operator(): void;
+    numericLiteralOrIdentifier(): void;
+    colorLiteral(): void;
+    escapedString(): string;
+}

package/dist/lib/lexer/tokens.d.ts

@@ -0,0 +1,46 @@
+import { Position } from '../types';
+
+export declare enum SyntaxTokenKind {
+    SPACE = "<space>",
+    TAB = "<tab>",
+    NEWLINE = "<newline>",
+    COMMA = "<comma>",
+    LPAREN = "<lparen>",
+    RPAREN = "<rparen>",
+    LBRACE = "<lbrace>",
+    RBRACE = "<rbrace>",
+    LBRACKET = "<lbracket>",
+    RBRACKET = "<rbracket>",
+    LANGLE = "<langle>",
+    RANGLE = "<rangle>",
+    OP = "<op>",
+    EOF = "<eof>",
+    NUMERIC_LITERAL = "<number>",
+    STRING_LITERAL = "<string>",
+    COLOR_LITERAL = "<color>",
+    FUNCTION_EXPRESSION = "<function-expression>",
+    QUOTED_STRING = "<variable>",
+    IDENTIFIER = "<identifier>",
+    SEMICOLON = "<semicolon>",
+    COLON = "<colon>",
+    SINGLE_LINE_COMMENT = "<single-line-comment>",
+    MULTILINE_COMMENT = "<multiline-comment>"
+}
+export declare function isTriviaToken(token: SyntaxToken): boolean;
+export declare function isOp(c?: string): boolean;
+export declare function isOpToken(token?: SyntaxToken): boolean;
+export declare class SyntaxToken {
+    kind: SyntaxTokenKind;
+    value: string;
+    leadingTrivia: SyntaxToken[];
+    trailingTrivia: SyntaxToken[];
+    leadingInvalid: SyntaxToken[];
+    trailingInvalid: SyntaxToken[];
+    startPos: Readonly<Position>;
+    start: Readonly<number>;
+    endPos: Readonly<Position>;
+    end: Readonly<number>;
+    isInvalid: boolean;
+    protected constructor(kind: SyntaxTokenKind, startPos: Position, endPos: Position, value: string, isInvalid: boolean);
+    static create(kind: SyntaxTokenKind, startPos: Position, endPos: Position, value: string, isInvalid: boolean): SyntaxToken;
+}

package/dist/lib/lexer/utils.d.ts

@@ -0,0 +1,8 @@
+import { SyntaxToken } from './tokens';
+
+export declare function hasTrailingNewLines(token: SyntaxToken): boolean;
+export declare function isAtStartOfLine(previous: SyntaxToken, token: SyntaxToken): boolean;
+export declare function hasTrailingSpaces(token: SyntaxToken): boolean;
+export declare function getTokenFullEnd(token: SyntaxToken): number;
+export declare function getTokenFullStart(token: SyntaxToken): number;
+export declare function isComment(token: SyntaxToken): boolean;

package/dist/lib/option.d.ts

@@ -0,0 +1,17 @@
+export type Option<T> = Some<T> | None<T>;
+export declare class Some<T> {
+    value: T;
+    constructor(value: T);
+    unwrap(): T;
+    unwrap_or<S>(orValue: S): S | T;
+    and_then<S>(callback: (_: T) => Option<S>): Option<S>;
+    map<S>(callback: (_: T) => S): Option<S>;
+    isOk(): boolean;
+}
+export declare class None<T> {
+    unwrap(): T;
+    unwrap_or<S>(orValue: S): S | T;
+    and_then<S>(callback: (_: T) => Option<S>): Option<S>;
+    map<S>(callback: (_: T) => S): Option<S>;
+    isOk(): boolean;
+}

package/dist/lib/parser/contextStack.d.ts

@@ -0,0 +1,21 @@
+import { SyntaxToken } from '../lexer/tokens';
+
+export declare const enum ParsingContext {
+    ListExpression = 0,
+    GroupExpression = 1,
+    BlockExpression = 2
+}
+export declare class ParsingContextStack {
+    private stack;
+    private numberOfNestedLParens;
+    private numberOfNestedLBrackets;
+    private numberOfNestedLBraces;
+    push(ctx: ParsingContext): void;
+    pop(): ParsingContext | undefined;
+    top(): ParsingContext | undefined;
+    isWithinGroupExpressionContext(): boolean;
+    isWithinListExpressionContext(): boolean;
+    isWithinBlockExpressionContext(): boolean;
+    withContextDo<T>(context: ParsingContext, callback: () => T): () => T;
+    findHandlerContext(tokens: SyntaxToken[], curTokenId: number): ParsingContext | undefined;
+}

package/dist/lib/parser/factory.d.ts

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

package/dist/lib/parser/nodes.d.ts

@@ -0,0 +1,209 @@
+import { SyntaxToken } from '../lexer/tokens';
+import { NodeSymbol } from '../analyzer/symbol/symbols';
+import { Position } from '../types';
+
+export type SyntaxNodeId = number;
+export declare class SyntaxNodeIdGenerator {
+    private id;
+    reset(): void;
+    nextId(): SyntaxNodeId;
+}
+export declare class SyntaxNode {
+    id: Readonly<SyntaxNodeId>;
+    kind: SyntaxNodeKind;
+    startPos: Readonly<Position>;
+    start: Readonly<number>;
+    fullStart: Readonly<number>;
+    endPos: Readonly<Position>;
+    end: Readonly<number>;
+    fullEnd: Readonly<number>;
+    symbol?: NodeSymbol;
+    referee?: NodeSymbol;
+    constructor(id: SyntaxNodeId, kind: SyntaxNodeKind, args: Readonly<SyntaxToken | SyntaxNode | undefined>[]);
+}
+export declare enum SyntaxNodeKind {
+    PROGRAM = "<program>",
+    ELEMENT_DECLARATION = "<element-declaration>",
+    ATTRIBUTE = "<attribute>",
+    IDENTIFIER_STREAM = "<identifer-stream>",
+    LITERAL = "<literal>",
+    VARIABLE = "<variable>",
+    PREFIX_EXPRESSION = "<prefix-expression>",
+    INFIX_EXPRESSION = "<infix-expression>",
+    POSTFIX_EXPRESSION = "<postfix-expression>",
+    FUNCTION_EXPRESSION = "<function-expression>",
+    FUNCTION_APPLICATION = "<function-application>",
+    BLOCK_EXPRESSION = "<block-expression>",
+    LIST_EXPRESSION = "<list-expression>",
+    TUPLE_EXPRESSION = "<tuple-expression>",
+    CALL_EXPRESSION = "<call-expression>",
+    PRIMARY_EXPRESSION = "<primary-expression>",
+    GROUP_EXPRESSION = "<group-expression>",
+    DUMMY = "<dummy>",
+    ARRAY = "<array>"
+}
+export declare class ProgramNode extends SyntaxNode {
+    body: ElementDeclarationNode[];
+    eof?: SyntaxToken;
+    constructor({ body, eof }: {
+        body?: ElementDeclarationNode[];
+        eof?: SyntaxToken;
+    }, id: SyntaxNodeId);
+}
+export declare class ElementDeclarationNode extends SyntaxNode {
+    type?: SyntaxToken;
+    name?: NormalExpressionNode;
+    as?: SyntaxToken;
+    alias?: NormalExpressionNode;
+    attributeList?: ListExpressionNode;
+    bodyColon?: SyntaxToken;
+    parent?: ElementDeclarationNode | ProgramNode;
+    body?: FunctionApplicationNode | BlockExpressionNode;
+    constructor({ type, name, as, alias, attributeList, bodyColon, body, }: {
+        type?: SyntaxToken;
+        name?: NormalExpressionNode;
+        as?: SyntaxToken;
+        alias?: NormalExpressionNode;
+        attributeList?: ListExpressionNode;
+        bodyColon?: SyntaxToken;
+        body?: BlockExpressionNode | FunctionApplicationNode;
+    }, id: SyntaxNodeId);
+}
+export declare class IdentiferStreamNode extends SyntaxNode {
+    identifiers: SyntaxToken[];
+    constructor({ identifiers }: {
+        identifiers?: SyntaxToken[];
+    }, id: SyntaxNodeId);
+}
+export declare class AttributeNode extends SyntaxNode {
+    name?: IdentiferStreamNode | PrimaryExpressionNode;
+    colon?: SyntaxToken;
+    value?: NormalExpressionNode | IdentiferStreamNode;
+    constructor({ name, colon, value, }: {
+        name?: IdentiferStreamNode | PrimaryExpressionNode;
+        colon?: SyntaxToken;
+        value?: NormalExpressionNode | IdentiferStreamNode;
+    }, id: SyntaxNodeId);
+}
+export type NormalExpressionNode = PrefixExpressionNode | InfixExpressionNode | PostfixExpressionNode | BlockExpressionNode | ListExpressionNode | TupleExpressionNode | CallExpressionNode | PrimaryExpressionNode | FunctionExpressionNode | DummyNode | ArrayNode;
+export type ExpressionNode = ElementDeclarationNode | NormalExpressionNode | FunctionApplicationNode;
+export declare class PrefixExpressionNode extends SyntaxNode {
+    op?: SyntaxToken;
+    expression?: NormalExpressionNode;
+    constructor({ op, expression }: {
+        op?: SyntaxToken;
+        expression?: NormalExpressionNode;
+    }, id: SyntaxNodeId);
+}
+export declare class InfixExpressionNode extends SyntaxNode {
+    op?: SyntaxToken;
+    leftExpression?: NormalExpressionNode;
+    rightExpression?: NormalExpressionNode;
+    constructor({ op, leftExpression, rightExpression, }: {
+        op?: SyntaxToken;
+        leftExpression?: NormalExpressionNode;
+        rightExpression?: NormalExpressionNode;
+    }, id: SyntaxNodeId);
+}
+export declare class PostfixExpressionNode extends SyntaxNode {
+    op?: SyntaxToken;
+    expression?: NormalExpressionNode;
+    constructor({ op, expression }: {
+        op?: SyntaxToken;
+        expression?: NormalExpressionNode;
+    }, id: SyntaxNodeId);
+}
+export declare class FunctionExpressionNode extends SyntaxNode {
+    value?: SyntaxToken;
+    constructor({ value }: {
+        value?: SyntaxToken;
+    }, id: SyntaxNodeId);
+}
+export declare class FunctionApplicationNode extends SyntaxNode {
+    callee?: ExpressionNode;
+    args: ExpressionNode[];
+    constructor({ callee, args }: {
+        callee?: ExpressionNode;
+        args?: ExpressionNode[];
+    }, id: SyntaxNodeId);
+}
+export declare class BlockExpressionNode extends SyntaxNode {
+    blockOpenBrace?: SyntaxToken;
+    body: (ElementDeclarationNode | FunctionApplicationNode)[];
+    blockCloseBrace?: SyntaxToken;
+    constructor({ blockOpenBrace, body, blockCloseBrace, }: {
+        blockOpenBrace?: SyntaxToken;
+        body?: (ElementDeclarationNode | FunctionApplicationNode)[];
+        blockCloseBrace?: SyntaxToken;
+    }, id: SyntaxNodeId);
+}
+export declare class ListExpressionNode extends SyntaxNode {
+    listOpenBracket?: SyntaxToken;
+    elementList: AttributeNode[];
+    commaList: SyntaxToken[];
+    listCloseBracket?: SyntaxToken;
+    constructor({ listOpenBracket, elementList, commaList, listCloseBracket, }: {
+        listOpenBracket?: SyntaxToken;
+        elementList?: AttributeNode[];
+        commaList?: SyntaxToken[];
+        listCloseBracket?: SyntaxToken;
+    }, id: SyntaxNodeId);
+}
+export declare class TupleExpressionNode extends SyntaxNode {
+    tupleOpenParen?: SyntaxToken;
+    elementList: NormalExpressionNode[];
+    commaList: SyntaxToken[];
+    tupleCloseParen?: SyntaxToken;
+    constructor({ tupleOpenParen, elementList, commaList, tupleCloseParen, }: {
+        tupleOpenParen?: SyntaxToken;
+        elementList?: NormalExpressionNode[];
+        commaList?: SyntaxToken[];
+        tupleCloseParen?: SyntaxToken;
+    }, id: SyntaxNodeId);
+}
+export declare class GroupExpressionNode extends TupleExpressionNode {
+    constructor({ groupOpenParen, expression, groupCloseParen, }: {
+        groupOpenParen?: SyntaxToken;
+        expression?: NormalExpressionNode;
+        groupCloseParen?: SyntaxToken;
+    }, id: SyntaxNodeId);
+}
+export declare class CallExpressionNode extends SyntaxNode {
+    callee?: NormalExpressionNode;
+    argumentList?: TupleExpressionNode;
+    constructor({ callee, argumentList, }: {
+        callee?: NormalExpressionNode;
+        argumentList?: TupleExpressionNode;
+    }, id: SyntaxNodeId);
+}
+export declare class LiteralNode extends SyntaxNode {
+    literal?: SyntaxToken;
+    constructor({ literal }: {
+        literal?: SyntaxToken;
+    }, id: SyntaxNodeId);
+}
+export declare class VariableNode extends SyntaxNode {
+    variable?: SyntaxToken;
+    constructor({ variable }: {
+        variable?: SyntaxToken;
+    }, id: SyntaxNodeId);
+}
+export declare class PrimaryExpressionNode extends SyntaxNode {
+    expression?: LiteralNode | VariableNode;
+    constructor({ expression }: {
+        expression?: LiteralNode | VariableNode;
+    }, id: SyntaxNodeId);
+}
+export declare class DummyNode extends SyntaxNode {
+    constructor({ pre }: {
+        pre: Readonly<SyntaxNode> | Readonly<SyntaxToken>;
+    }, id: SyntaxNodeId);
+}
+export declare class ArrayNode extends SyntaxNode {
+    array?: NormalExpressionNode;
+    indexer?: ListExpressionNode;
+    constructor({ expression, indexer }: {
+        expression?: NormalExpressionNode;
+        indexer: ListExpressionNode;
+    }, id: SyntaxNodeId);
+}

package/dist/lib/parser/parser.d.ts

@@ -0,0 +1,54 @@
+import { CompileError } from '../errors';
+import { SyntaxToken } from '../lexer/tokens';
+import { default as Report } from '../report';
+import { ProgramNode, SyntaxNodeIdGenerator } from './nodes';
+
+export default class Parser {
+    private tokens;
+    private current;
+    private errors;
+    private contextStack;
+    private nodeFactory;
+    constructor(tokens: SyntaxToken[], nodeIdGenerator: SyntaxNodeIdGenerator);
+    private isAtEnd;
+    private advance;
+    private peek;
+    private match;
+    private check;
+    private previous;
+    private canHandle;
+    private consume;
+    private discardUntil;
+    private gatherInvalid;
+    parse(): Report<{
+        ast: ProgramNode;
+        tokens: SyntaxToken[];
+    }, CompileError>;
+    private program;
+    private synchronizeProgram;
+    private elementDeclaration;
+    private synchronizeElementDeclarationName;
+    private synchronizeElementDeclarationAlias;
+    private fieldDeclaration;
+    private expression;
+    private shouldStopExpression;
+    private normalExpression;
+    private expression_bp;
+    private leftExpression_bp;
+    private extractOperand;
+    private functionExpression;
+    private blockExpression;
+    private canBeField;
+    private synchronizeBlock;
+    private primaryExpression;
+    private tupleExpression;
+    private synchronizeTuple;
+    private listExpression;
+    private synchronizeList;
+    private attribute;
+    private synchronizeAttributeName;
+    private attributeValue;
+    private synchronizeAttributeValue;
+    private attributeName;
+    private logError;
+}

package/dist/lib/parser/utils.d.ts

@@ -0,0 +1,47 @@
+import { SyntaxToken, SyntaxTokenKind } from '../lexer/tokens';
+import { Option } from '../option';
+import { default as NodeFactory } from './factory';
+import { ElementDeclarationNode, ExpressionNode, IdentiferStreamNode, InfixExpressionNode, LiteralNode, NormalExpressionNode, PrimaryExpressionNode, SyntaxNode, VariableNode } from './nodes';
+
+export declare function convertFuncAppToElem(callee: ExpressionNode | undefined, args: NormalExpressionNode[], factory: NodeFactory): Option<ElementDeclarationNode>;
+export declare function isAsKeyword(token: SyntaxToken): token is SyntaxToken & {
+    kind: SyntaxTokenKind.IDENTIFIER;
+    value: 'as';
+};
+export declare function markInvalid(nodeOrToken?: SyntaxNode | SyntaxToken): void;
+export declare function isInvalidToken(token?: SyntaxToken): boolean;
+export declare function getMemberChain(node: SyntaxNode): Readonly<(SyntaxNode | SyntaxToken)[]>;
+export declare function extractVariableNode(value?: unknown): Option<SyntaxToken>;
+export declare function isExpressionAQuotedString(value?: unknown): value is PrimaryExpressionNode & ({
+    expression: VariableNode & {
+        variable: SyntaxToken & {
+            kind: SyntaxTokenKind.QUOTED_STRING;
+        };
+    };
+} | {
+    expression: LiteralNode & {
+        literal: SyntaxToken & {
+            kind: SyntaxTokenKind.STRING_LITERAL;
+        };
+    };
+});
+export declare function isExpressionAVariableNode(value?: unknown): value is PrimaryExpressionNode & {
+    expression: VariableNode & {
+        variable: SyntaxToken;
+    };
+};
+export declare function isExpressionAnIdentifierNode(value?: unknown): value is PrimaryExpressionNode & {
+    expression: VariableNode & {
+        variable: {
+            kind: SyntaxTokenKind.IDENTIFIER;
+        };
+    };
+};
+export declare function isAccessExpression(node: SyntaxNode): node is InfixExpressionNode & {
+    leftExpression: SyntaxNode;
+    rightExpression: SyntaxNode;
+    op: SyntaxToken & {
+        value: '.';
+    };
+};
+export declare function extractStringFromIdentifierStream(stream?: IdentiferStreamNode): Option<string>;

package/dist/lib/report.d.ts

@@ -0,0 +1,9 @@
+export default class Report<T, E> {
+    private value;
+    private errors;
+    constructor(value: T, errors?: E[]);
+    getValue(): T;
+    getErrors(): E[];
+    chain<U>(fn: (_: T) => Report<U, E>): Report<U, E>;
+    map<U>(fn: (_: T) => U): Report<U, E>;
+}

package/dist/lib/serialization/serialize.d.ts

@@ -0,0 +1,5 @@
+import { ProgramNode } from '../parser/nodes';
+import { default as Report } from '../report';
+import { CompileError } from '../errors';
+
+export declare function serialize(report: Readonly<Report<ProgramNode, CompileError>>, pretty?: boolean): string;

package/dist/lib/utils.d.ts

@@ -0,0 +1,12 @@
+import { SyntaxToken } from './lexer/tokens';
+import { SyntaxNode } from './parser/nodes';
+
+export declare function isAlphaOrUnderscore(char: string): boolean;
+export declare function isDigit(char: string): boolean;
+export declare function isHexChar(char: string): boolean;
+export declare function isAlphaNumeric(char: string): boolean;
+export declare function alternateLists<T, S>(firstList: T[], secondList: S[]): (T | S)[];
+export declare function isOffsetWithinFullSpan(offset: number, nodeOrToken: SyntaxNode | SyntaxToken): boolean;
+export declare function isOffsetWithinSpan(offset: number, nodeOrToken: SyntaxNode | SyntaxToken): boolean;
+export declare function returnIfIsOffsetWithinFullSpan(offset: number, node?: SyntaxNode): SyntaxNode | undefined;
+export declare function returnIfIsOffsetWithinFullSpan(offset: number, token?: SyntaxToken): SyntaxToken | undefined;

package/dist/services/definition/provider.d.ts

@@ -0,0 +1,8 @@
+import { Definition, DefinitionProvider, TextModel, Position } from '../types';
+import { default as Compiler } from '../../compiler';
+
+export default class DBMLDefinitionProvider implements DefinitionProvider {
+    private compiler;
+    constructor(compiler: Compiler);
+    provideDefinition(model: TextModel, position: Position): Definition;
+}

package/dist/services/index.d.ts

@@ -0,0 +1,6 @@
+import { default as DBMLCompletionItemProvider } from './suggestions/provider';
+import { default as DBMLDefinitionProvider } from './definition/provider';
+import { default as DBMLReferencesProvider } from './references/provider';
+
+export * from './types';
+export { DBMLCompletionItemProvider, DBMLDefinitionProvider, DBMLReferencesProvider, };

package/dist/services/references/provider.d.ts

@@ -0,0 +1,8 @@
+import { default as Compiler } from '../../compiler';
+import { Location, ReferenceProvider, TextModel, Position } from '../types';
+
+export default class DBMLReferencesProvider implements ReferenceProvider {
+    private compiler;
+    constructor(compiler: Compiler);
+    provideReferences(model: TextModel, position: Position): Location[];
+}

package/dist/services/suggestions/provider.d.ts

@@ -0,0 +1,9 @@
+import { default as Compiler } from '../../compiler';
+import { CompletionList, TextModel, CompletionItemProvider, Position } from '../types';
+
+export default class DBMLCompletionItemProvider implements CompletionItemProvider {
+    private compiler;
+    triggerCharacters: string[];
+    constructor(compiler: Compiler, triggerCharacters?: string[]);
+    provideCompletionItems(model: TextModel, position: Position): CompletionList;
+}

package/dist/services/suggestions/utils.d.ts

@@ -0,0 +1,9 @@
+import { SymbolKind } from '../../lib/analyzer/symbol/symbolIndex';
+import { CompletionItemKind, CompletionList } from '../types';
+import { SyntaxToken } from '../../lib/lexer/tokens';
+
+export declare function pickCompletionItemKind(symbolKind: SymbolKind): CompletionItemKind;
+export declare function shouldPrependSpace(token: SyntaxToken | undefined, offset: number): boolean;
+export declare function noSuggestions(): CompletionList;
+export declare function prependSpace(completionList: CompletionList): CompletionList;
+export declare function addQuoteIfNeeded(completionList: CompletionList): CompletionList;

package/dist/services/types.d.ts

@@ -0,0 +1,60 @@
+import { Position as IPosition, editor, languages, IRange, IDisposable, CancellationToken as ICancellationToken } from 'monaco-editor-core';
+
+export type Position = IPosition;
+export type TextModel = editor.ITextModel;
+export type ProviderResult<T> = languages.ProviderResult<T>;
+export type Range = IRange;
+export type Location = languages.Location;
+export type Disposable = IDisposable;
+export type CompletionContext = languages.CompletionContext;
+export type CancellationToken = ICancellationToken;
+export interface CompletionItemProvider {
+    triggerCharacters?: string[];
+    provideCompletionItems(model: TextModel, position: Position, context: CompletionContext, token: CancellationToken): ProviderResult<CompletionList>;
+    resolveCompletionItem?(item: CompletionItem, token: CancellationToken): ProviderResult<CompletionItem>;
+}
+export type CompletionItem = languages.CompletionItem;
+export type CompletionList = languages.CompletionList;
+export declare enum CompletionItemKind {
+    Function = 1,
+    Constructor = 2,
+    Field = 3,
+    Variable = 4,
+    Class = 5,
+    Struct = 6,
+    Interface = 7,
+    Module = 8,
+    Property = 9,
+    Event = 10,
+    Operator = 11,
+    Unit = 12,
+    Value = 13,
+    Constant = 14,
+    Enum = 15,
+    EnumMember = 16,
+    Keyword = 17,
+    Text = 18,
+    Color = 19,
+    File = 20,
+    Reference = 21,
+    Customcolor = 22,
+    Folder = 23,
+    TypeParameter = 24,
+    User = 25,
+    Issue = 26,
+    Snippet = 27
+}
+export declare enum CompletionItemInsertTextRule {
+    None = 0,
+    KeepWhitespace = 1,
+    InsertAsSnippet = 4
+}
+export type DocumentColorProvider = languages.DocumentColorProvider;
+export type ColorInformation = languages.IColorInformation;
+export type ColorPresentation = languages.IColorPresentation;
+export type Color = languages.IColor;
+export type DefinitionProvider = languages.DefinitionProvider;
+export type Definition = languages.Definition;
+export type CodeActionList = languages.CodeActionList;
+export type SignatureHelpResult = languages.SignatureHelpResult;
+export type ReferenceProvider = languages.ReferenceProvider;

package/dist/services/utils.d.ts

@@ -0,0 +1,3 @@
+import { TextModel, Position } from './types';
+
+export declare function getOffsetFromMonacoPosition(model: TextModel, position: Position): number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dbml/parse",
-  "version": "3.6.1",
+  "version": "3.6.2",
   "description": "> TODO: description",
   "author": "Holistics <dev@holistics.io>",
   "license": "Apache-2.0",
@@ -12,6 +12,7 @@
   ],
   "main": "./dist/dbml-parse.js",
   "module": "./dist/dbml-parse.mjs",
+  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
       "import": "./dist/dbml-parse.mjs",
@@ -22,7 +23,7 @@
     "dist"
   ],
   "scripts": {
-    "build": "vite build",
+    "build": "tsc --noEmit && vite build",
     "dev": "vite build --watch",
     "test": "vitest run",
     "test:watch": "vitest tests",
@@ -37,6 +38,7 @@
     "typescript": "^5.2.2",
     "vite": "^4.5.0",
     "vite-dts": "^1.0.4",
+    "vite-plugin-dts": "^3.9.1",
     "vitest": "^0.34.6"
   },
   "dependencies": {
@@ -45,5 +47,5 @@
   "peerDependencies": {
     "lodash": "^4.17.21"
   },
-  "gitHead": "2d7bc464a2e56cbe1555347c3292456cc2ddc4f7"
+  "gitHead": "d3d82a3e8260f733098edc5fbfdbd3f8a381c6e3"
 }