@supernova-studio/pulsar-core 2.0.14 → 2.0.15

package/build/main/language/src/parser/symbols/SymbolBuffer.d.ts

@@ -0,0 +1,16 @@
+export declare class SymbolBuffer {
+    line: number;
+    char: number;
+    seekFirstMode: boolean;
+    constructor();
+    /** Modify seeking buffer with singular character */
+    seekUsingCharacter(char: string): void;
+    /** Modify seeking buffer with sequence of characters. Can be both regular and special (newlines) characters and modifies buffer accordingly */
+    seekUsingMultipleCharacters(chars: string): void;
+    /** Modify counters by regular character */
+    seekNextChar(): void;
+    /** Modify counters by newline character */
+    seekNextLine(): void;
+    /** Set behavior of counter. When enabled, counter will start from -1, expecting seek to happen before first data read. Defaults to true */
+    setSeekHappensFirst(seekFirst: boolean): void;
+}

package/build/main/language/src/parser/symbols/SymbolFactory.d.ts

@@ -0,0 +1,27 @@
+import { SyntaxNode } from '../syntax/nodes/SyntaxNode';
+import { ConcreteToken } from '../Tokenization/Concrete/ConcreteToken';
+import { LexicalToken } from '../Tokenization/Lexical/LexicalToken';
+import { Symbol } from './Symbol';
+export declare class SymbolFactory {
+    private evaluatedSource;
+    constructor(source: string);
+    setSource(source: string): void;
+    private symbol;
+    lexicalSymbolFromToken(token: LexicalToken): Symbol;
+    concreteSymbolFromToken(token: ConcreteToken): Symbol;
+    syntaxSymbolFromNode(token: SyntaxNode): Symbol;
+    /** Compute symbol range from array of given lexical tokens. Will find beginning and end line and char or return -1 if no tokens were given */
+    computeSymbolRangeFromLexicalTokens(tokens: LexicalToken[]): {
+        startLine: number;
+        startChar: number;
+        endLine: number;
+        endChar: number;
+    };
+    /** Compute symbol range from array of given concrete tokens. Will find beginning and end line and char or return -1 if no tokens were given */
+    computeSymbolRangeFromConcreteTokens(tokens: ConcreteToken[]): {
+        startLine: number;
+        startChar: number;
+        endLine: number;
+        endChar: number;
+    };
+}

package/build/main/language/src/parser/symbols/SymbolTable.d.ts

@@ -0,0 +1,22 @@
+import { SyntaxNode } from '../syntax/nodes/SyntaxNode';
+import { ConcreteToken } from '../Tokenization/Concrete/ConcreteToken';
+import { LexicalToken } from '../Tokenization/Lexical/LexicalToken';
+import { Symbol } from './Symbol';
+export declare class PLSymbolTable {
+    private symbolFactory;
+    readonly symbols: Map<string, Symbol>;
+    constructor(source: string);
+    emitSymbolFromLexicalToken(token: LexicalToken): Symbol;
+    emitSymbolFromConcreteToken(token: ConcreteToken): Symbol;
+    emitSymbolFromSyntaxNode(node: SyntaxNode): Symbol;
+    private storeSymbol;
+    setExecutedSource(source: string): void;
+    lexicalPhaseSymbols(): Array<Symbol>;
+    lexicalPhaseSymbolsSortedByLocation(): Array<Symbol>;
+    concretePhaseSymbols(): Array<Symbol>;
+    concretePhaseSymbolSortedByLocation(): Array<Symbol>;
+    syntaxPhaseSymbols(): Array<Symbol>;
+    syntaxPhaseSymbolSortedByLocation(): Array<Symbol>;
+    symbolById(symbolId: string): Symbol | null;
+    symbolArraySortedByLocation(symbols: Array<Symbol>): Array<Symbol>;
+}

package/build/main/language/src/parser/symbols/SymbolType.d.ts

@@ -0,0 +1,5 @@
+export declare enum SymbolType {
+    lexicalToken = "lt",
+    concreteToken = "ct",
+    syntaxToken = "st"
+}

package/build/main/language/src/parser/syntax/SyntaxParser.d.ts

@@ -0,0 +1,13 @@
+import { PLExecutionContext } from '../../interpreter/ExecutionContext';
+import { ConcreteBuffer } from '../Tokenization/Concrete/ConcreteBuffer';
+import { SyntaxNodeFlow } from './nodes/SyntaxNodeFlow';
+import { SyntaxTree } from './SyntaxTree';
+export declare class SyntaxParser {
+    readonly tokens: ConcreteBuffer;
+    executionContext: PLExecutionContext;
+    openedFlowNodes: Array<SyntaxNodeFlow>;
+    constructor(tokens: ConcreteBuffer, executionContext: PLExecutionContext);
+    parse(): SyntaxTree;
+    parseTokens(tokens: ConcreteBuffer): SyntaxTree;
+    lastOpenedChainNode(): SyntaxNodeFlow | null;
+}

package/build/main/language/src/parser/syntax/SyntaxTree.d.ts

@@ -0,0 +1,8 @@
+import { PLExecutionContext } from '../../interpreter/ExecutionContext';
+import { SyntaxNodeGroup } from './nodes/SyntaxNodeGroup';
+export declare class SyntaxTree {
+    rootNode: SyntaxNodeGroup;
+    constructor(executionContext: PLExecutionContext, rootNode?: SyntaxNodeGroup);
+    debugDescription(): string;
+    equals(obj: SyntaxTree): boolean;
+}

package/build/main/language/src/parser/syntax/nodes/SyntaxNode.d.ts

@@ -0,0 +1,13 @@
+import { ConcreteToken } from '../../Tokenization/Concrete/ConcreteToken';
+export declare enum NodeType {
+    text = 0,
+    flow = 1,
+    substitution = 2,
+    group = 3
+}
+export declare abstract class SyntaxNode {
+    nodeType: NodeType;
+    backingTokens: Array<ConcreteToken>;
+    debugSymbol: string | null;
+    abstract debugDescription(): string;
+}

package/build/main/language/src/parser/syntax/nodes/SyntaxNodeFlow.d.ts

@@ -0,0 +1,34 @@
+import { PLExecutionContext } from '../../../interpreter/ExecutionContext';
+import { PLFlow } from '../../../interpreter/flows/Flow';
+import { PLFlowSource } from '../../../interpreter/flows/FlowSource';
+import { ConcreteToken } from '../../Tokenization/Concrete/ConcreteToken';
+import { PLFlowOutput } from './../../../interpreter/flows/FlowOutput';
+import { PLInterpreterContext } from './../../../interpreter/InterpreterContext';
+import { NodeType, SyntaxNode } from './SyntaxNode';
+import { SyntaxNodeGroup } from './SyntaxNodeGroup';
+export declare class SyntaxNodeFlow implements SyntaxNode {
+    nodeType: NodeType;
+    backingTokens: Array<ConcreteToken>;
+    debugSymbol: string | null;
+    flowGroup: SyntaxNodeGroup;
+    flowIdentifier: string;
+    directive: string;
+    flow: PLFlow;
+    lineOffset: number;
+    firstLineDirective: boolean;
+    outputs: Map<string, PLFlowOutput>;
+    sources: Map<string, PLFlowSource>;
+    keywords: Map<string, boolean>;
+    previousChainFlow?: SyntaxNodeFlow;
+    nextChainFlow?: SyntaxNodeFlow;
+    parent?: SyntaxNodeFlow;
+    constructor(directive: string, lineOffset: number, firstLineDirective: boolean, flowGroup: SyntaxNodeGroup | null, executionContext: PLExecutionContext, from: Array<ConcreteToken>);
+    setLinksToFlow(node: SyntaxNodeFlow): void;
+    unlinkPreviousChainedFlow(): void;
+    unlinkNextChainedFlow(): void;
+    setParent(node: SyntaxNodeFlow | null): void;
+    flowStackIdentifier(): Array<string>;
+    debugDescription(): string;
+    equals(obj: SyntaxNodeFlow): boolean;
+    interpret(_context: PLInterpreterContext, _executionContext: PLExecutionContext): Promise<string>;
+}

package/build/main/language/src/parser/syntax/nodes/SyntaxNodeGroup.d.ts

@@ -0,0 +1,17 @@
+import { SyntaxNode } from './SyntaxNode';
+import { NodeType } from './SyntaxNode';
+import { PLExecutionContext } from '../../../interpreter/ExecutionContext';
+import { PLInterpreterContext } from './../../../interpreter/InterpreterContext';
+import { ConcreteToken } from '../../Tokenization/Concrete/ConcreteToken';
+export declare class SyntaxNodeGroup implements SyntaxNode {
+    nodeType: NodeType;
+    debugSymbol: string | null;
+    backingTokens: Array<ConcreteToken>;
+    nodes: Array<SyntaxNode>;
+    depth: number;
+    constructor(nodes: Array<SyntaxNode>, depth: number, executionContext: PLExecutionContext, from: Array<ConcreteToken>);
+    add(node: SyntaxNode): void;
+    debugDescription(): string;
+    equals(obj: SyntaxNodeGroup): boolean;
+    interpret(_context: PLInterpreterContext, _executionContext: PLExecutionContext): Promise<string>;
+}

package/build/main/language/src/parser/syntax/nodes/SyntaxNodeText.d.ts

@@ -0,0 +1,16 @@
+import { SyntaxNode } from './SyntaxNode';
+import { NodeType } from './SyntaxNode';
+import { PLExecutionContext } from '../../../interpreter/ExecutionContext';
+import { PLInterpreterContext } from './../../../interpreter/InterpreterContext';
+import { ConcreteToken } from '../../Tokenization/Concrete/ConcreteToken';
+export declare class SyntaxNodeText implements SyntaxNode {
+    nodeType: NodeType;
+    backingTokens: Array<ConcreteToken>;
+    debugSymbol: string | null;
+    text: string;
+    constructor(text: string, executionContext: PLExecutionContext, from: Array<ConcreteToken>);
+    debugDescription(): string;
+    equals(obj: SyntaxNodeText): boolean;
+    interpret(_context: PLInterpreterContext, _executionContext: PLExecutionContext): Promise<string>;
+    interpretSync(_context: PLInterpreterContext, _executionContext: PLExecutionContext): string;
+}

package/build/main/language/src/parser/syntax/nodes/substitution/SyntaxNodeSubstitution.d.ts

@@ -0,0 +1,24 @@
+import { NodeType, SyntaxNode } from '../SyntaxNode';
+import { PLFunction } from '../../../../interpreter/functions/Function';
+import { PLExecutionContext } from '../../../../interpreter/ExecutionContext';
+import { ConcreteToken } from '../../../Tokenization/Concrete/ConcreteToken';
+import jsep from 'jsep';
+import { SyntaxNodeSubstitutionExecutionMode } from './SyntaxNodeSubstitutionAnalyzer';
+import { SyntaxNodeSubstitutionInterpreter } from './interpreters/SyntaxNodeSubstitutionInterpreter';
+export declare class SyntaxNodeSubstitution implements SyntaxNode {
+    nodeType: NodeType;
+    backingTokens: Array<ConcreteToken>;
+    debugSymbol: string | null;
+    customDataSource: {
+        function: PLFunction;
+        directive: string;
+    } | null;
+    directive: string;
+    isVirtual: boolean;
+    rootExpression: jsep.Expression;
+    preferredExecutionMode: SyntaxNodeSubstitutionExecutionMode;
+    interpreter: SyntaxNodeSubstitutionInterpreter;
+    constructor(directive: string, executionContext: PLExecutionContext, from: Array<ConcreteToken>, isVirtual: boolean);
+    debugDescription(): string;
+    equals(obj: SyntaxNodeSubstitution): boolean;
+}

package/build/main/language/src/parser/syntax/nodes/substitution/SyntaxNodeSubstitutionAnalyzer.d.ts

@@ -0,0 +1,21 @@
+import { PLExecutionContext } from "../../../../interpreter/ExecutionContext";
+import jsep from "jsep";
+import { ObjectExpression } from '@jsep-plugin/object';
+import { SyntaxNodeSubstitution } from "./SyntaxNodeSubstitution";
+export declare enum SyntaxNodeSubstitutionExecutionMode {
+    sync = 0,
+    async = 1
+}
+export declare class SyntaxNodeSubstitutionAnalyzer {
+    executionContext: PLExecutionContext;
+    constructor(executionContext: PLExecutionContext);
+    analyzePreferredExecutionMode(node: SyntaxNodeSubstitution): SyntaxNodeSubstitutionExecutionMode;
+    needsAsyncExpression(expression: jsep.Expression): boolean;
+    needsAsyncCallExpression(expression: jsep.CallExpression): boolean;
+    needsAsyncCallMemberExpression(callee: jsep.MemberExpression): boolean;
+    needsAsyncArrayExpression(expression: jsep.ArrayExpression): boolean;
+    needsAsyncBinaryExpression(expression: jsep.BinaryExpression): boolean;
+    needsAsyncConditionalExpression(expression: jsep.ConditionalExpression): boolean;
+    needsAsyncMemberExpression(expression: jsep.MemberExpression): boolean;
+    needsAsyncObjectExpression(expression: ObjectExpression): boolean;
+}

package/build/main/language/src/parser/syntax/nodes/substitution/interpreters/SyntaxNodeSubstitutionAsyncInterpreter.d.ts

@@ -0,0 +1,27 @@
+import { PLExecutionContext } from '../../../../../interpreter/ExecutionContext';
+import { PLInterpreterContext } from '../../../../../interpreter/InterpreterContext';
+import jsep from 'jsep';
+import { ObjectExpression } from '@jsep-plugin/object';
+import { SyntaxNodeSubstitution } from '../SyntaxNodeSubstitution';
+import { SyntaxNodeSubstitutionInterpreter } from './SyntaxNodeSubstitutionInterpreter';
+export declare class SyntaxNodeSubstitutionAsyncInterpreter extends SyntaxNodeSubstitutionInterpreter {
+    expressionResolutionLookup: Object;
+    node: SyntaxNodeSubstitution;
+    constructor(node: SyntaxNodeSubstitution);
+    interpretAsync(context: PLInterpreterContext, executionContext: PLExecutionContext): Promise<any>;
+    resolveExpression(expression: jsep.Expression, context: PLInterpreterContext, executionContext: PLExecutionContext): Promise<any>;
+    processIdentifier(expression: jsep.Identifier, context: PLInterpreterContext, executionContext: PLExecutionContext): any;
+    processLiteralExpression(expression: jsep.Literal, context: PLInterpreterContext, executionContext: PLExecutionContext): string | boolean | number;
+    processUnaryExpression(expression: jsep.UnaryExpression, context: PLInterpreterContext, executionContext: PLExecutionContext): Promise<any>;
+    processBinaryExpression(expression: jsep.BinaryExpression, context: PLInterpreterContext, executionContext: PLExecutionContext): Promise<any>;
+    validateBooleanBinaryOp(leftValue: any, rightValue: any, operator: string): void;
+    validateNumericBinaryOp(leftValue: any, rightValue: any, operator: string): void;
+    processArrayExpression(expression: jsep.ArrayExpression, context: PLInterpreterContext, executionContext: PLExecutionContext): Promise<Array<any>>;
+    processConditionalExpression(expression: jsep.ConditionalExpression, context: PLInterpreterContext, executionContext: PLExecutionContext): Promise<any>;
+    processThisExpression(expression: jsep.ThisExpression, context: PLInterpreterContext, executionContext: PLExecutionContext): any;
+    processMemberExpression(expression: jsep.MemberExpression, context: PLInterpreterContext, executionContext: PLExecutionContext): Promise<any>;
+    processCallExpression(expression: jsep.CallExpression, context: PLInterpreterContext, executionContext: PLExecutionContext): Promise<any>;
+    processCallMemberExpression(callee: jsep.MemberExpression, args: Array<any>, context: PLInterpreterContext, executionContext: PLExecutionContext): Promise<any>;
+    processCompoundExpression(expression: jsep.Compound, context: PLInterpreterContext, executionContext: PLExecutionContext): any;
+    processObjectExpression(expression: ObjectExpression, context: PLInterpreterContext, executionContext: PLExecutionContext): Promise<any>;
+}

package/build/main/language/src/parser/syntax/nodes/substitution/interpreters/SyntaxNodeSubstitutionInterpreter.d.ts

@@ -0,0 +1,10 @@
+import { PLExecutionContext } from "../../../../../interpreter/ExecutionContext";
+import { PLInterpreterContext } from "../../../../../interpreter/InterpreterContext";
+import { SyntaxNodeSubstitution } from "../SyntaxNodeSubstitution";
+export declare class SyntaxNodeSubstitutionInterpreter {
+    expressionResolutionLookup: Object;
+    node: SyntaxNodeSubstitution;
+    constructor(node: SyntaxNodeSubstitution);
+    interpretSync(context: PLInterpreterContext, executionContext: PLExecutionContext): any;
+    interpretAsync(context: PLInterpreterContext, executionContext: PLExecutionContext): Promise<any>;
+}

package/build/main/language/src/parser/syntax/nodes/substitution/interpreters/SyntaxNodeSubstitutionSyncInterpreter.d.ts

@@ -0,0 +1,25 @@
+import { PLExecutionContext } from '../../../../../interpreter/ExecutionContext';
+import { PLInterpreterContext } from '../../../../../interpreter/InterpreterContext';
+import jsep from 'jsep';
+import { ObjectExpression } from '@jsep-plugin/object';
+import { SyntaxNodeSubstitutionInterpreter } from './SyntaxNodeSubstitutionInterpreter';
+import { SyntaxNodeSubstitution } from '../SyntaxNodeSubstitution';
+export declare class SyntaxNodeSubstitutionSyncInterpreter extends SyntaxNodeSubstitutionInterpreter {
+    constructor(node: SyntaxNodeSubstitution);
+    interpretSync(context: PLInterpreterContext, executionContext: PLExecutionContext): any;
+    resolveExpression(expression: jsep.Expression, context: PLInterpreterContext, executionContext: PLExecutionContext): any;
+    processIdentifier(expression: jsep.Identifier, context: PLInterpreterContext, executionContext: PLExecutionContext): any;
+    processLiteralExpression(expression: jsep.Literal, context: PLInterpreterContext, executionContext: PLExecutionContext): string | boolean | number;
+    processUnaryExpression(expression: jsep.UnaryExpression, context: PLInterpreterContext, executionContext: PLExecutionContext): any;
+    processBinaryExpression(expression: jsep.BinaryExpression, context: PLInterpreterContext, executionContext: PLExecutionContext): any;
+    validateBooleanBinaryOp(leftValue: any, rightValue: any, operator: string): void;
+    validateNumericBinaryOp(leftValue: any, rightValue: any, operator: string): void;
+    processArrayExpression(expression: jsep.ArrayExpression, context: PLInterpreterContext, executionContext: PLExecutionContext): Array<any>;
+    processConditionalExpression(expression: jsep.ConditionalExpression, context: PLInterpreterContext, executionContext: PLExecutionContext): any;
+    processThisExpression(expression: jsep.ThisExpression, context: PLInterpreterContext, executionContext: PLExecutionContext): any;
+    processMemberExpression(expression: jsep.MemberExpression, context: PLInterpreterContext, executionContext: PLExecutionContext): any;
+    processCallExpression(expression: jsep.CallExpression, context: PLInterpreterContext, executionContext: PLExecutionContext): any;
+    processCallMemberExpression(callee: jsep.MemberExpression, args: Array<any>, context: PLInterpreterContext, executionContext: PLExecutionContext): any;
+    processCompoundExpression(expression: jsep.Compound, context: PLInterpreterContext, executionContext: PLExecutionContext): any;
+    processObjectExpression(expression: ObjectExpression, context: PLInterpreterContext, executionContext: PLExecutionContext): any;
+}

package/build/main/language/src/tools/autocomplete/AutocompleteEngine.d.ts

@@ -0,0 +1,31 @@
+import { PLDoc } from './../documentation/Doc';
+export declare enum PLAutocompleteEngineSuggestionType {
+    method = "method",
+    transformer = "transformer",
+    snippet = "snippet",
+    variable = "variable"
+}
+export declare type PLAutocompleteEngineSuggestion = {
+    type: PLAutocompleteEngineSuggestionType;
+    inputString: string;
+    documentationObject: PLDoc;
+    suggestionString: string;
+    declarationString: string | null;
+    ranges: Array<{
+        location: number;
+        length: number;
+    }>;
+    weight: number;
+    caretLocation: number | null;
+};
+export declare type PLAutocompleteEngineApplicationResult = {
+    resultingString: string;
+    proposedSelectionLocation: number;
+    proposedSelectionLength: number;
+};
+export declare class PLAutocompleteEngine {
+    constructor();
+    suggestNextBasedOnString(_string: String, _selectionLocation: number, _selectionLength: number): Array<PLAutocompleteEngineSuggestion>;
+    suggestedStringUntilSelection(string: String, selectionLocation: number, _selectionLength: number): string;
+    applySuggestion(suggestion: PLAutocompleteEngineSuggestion, string: String, selectionLocation: number, _selectionLength: number, _decoderAddition: number): PLAutocompleteEngineApplicationResult;
+}

package/build/main/language/src/tools/autocomplete/BlueprintAutocompleteEngine.d.ts

@@ -0,0 +1,40 @@
+import { PLAutocompleteEngine, PLAutocompleteEngineSuggestion } from './AutocompleteEngine';
+import { PLAutocompleteBlueprintSnippet } from './BlueprintSnippets';
+import { PLExecutionContext } from './../../interpreter/ExecutionContext';
+export declare enum PLBlueprintAutocompleteEngineControlCharacter {
+    substitutionOpen = "{{",
+    substitutionClose = "}}",
+    flowOpening = "{[",
+    flowClosing = "/]}",
+    commentOpen = "/*",
+    commentClose = "*/",
+    quote = "\"",
+    none = "none"
+}
+export declare class PLBlueprintAutocompleteEngine extends PLAutocompleteEngine {
+    executionContext: PLExecutionContext;
+    snippets: Array<PLAutocompleteBlueprintSnippet>;
+    includePlaceholders: boolean;
+    constructor(executionContext: PLExecutionContext, includePlaceholders?: boolean);
+    update(executionContext: PLExecutionContext): void;
+    loadSnippets(snippets: Array<PLAutocompleteBlueprintSnippet>): void;
+    suggestNextBasedOnString(string: string, selectionLocation: number, selectionLength: number): Array<PLAutocompleteEngineSuggestion>;
+    private suggestionsForString;
+    private variableSuggestionsContainingKeyword;
+    private transformerSuggestionsContainingKeyword;
+    private snippetSuggestionsContainingKeyword;
+    private functionSuggestionsContainingKeyword;
+    private convertFunctionToSuggestion;
+    private convertTransformerToSuggestion;
+    private convertVariableToSuggestion;
+    private convertSnippetToSuggestion;
+    private sortedSuggestions;
+    private rangesOfSubsequence;
+    private compactRanges;
+    private longestRangeOfRanges;
+    private seekLastControlCharacterOfString;
+    private allControlCharacters;
+    private lastPartOfStringContains;
+    private lastWordOfString;
+    private lastLineOfString;
+}

package/build/main/language/src/tools/autocomplete/BlueprintSnippets.d.ts

@@ -0,0 +1,16 @@
+export declare type PLAutocompleteBlueprintSnippet = {
+    /** Snippet invocation keyword */
+    keyword: string;
+    /** Snippet content to be inserted into the code */
+    content: string;
+    /** Snippet description */
+    description: string | null;
+    /** Suggestion string that will be used to replace user input if use commits the action */
+    caretPosition: number | null;
+    /** Priority */
+    priority: number;
+};
+export declare class PLAutocompleteBlueprintSnippets {
+    constructor();
+    snippetPool(includingEditorPlaceholder?: boolean): Array<PLAutocompleteBlueprintSnippet>;
+}

package/build/main/language/src/tools/autocomplete/PlaceholderDisabledSnippetPool.d.ts

@@ -0,0 +1,34 @@
+import { PLAutocompleteBlueprintSnippet } from './BlueprintSnippets';
+export declare class PLPlaceholderDisabledSnippetPool {
+    constructor();
+    allSnippets(): Array<PLAutocompleteBlueprintSnippet>;
+    commentSnippet(): PLAutocompleteBlueprintSnippet;
+    commentMultilineSnippet(): PLAutocompleteBlueprintSnippet;
+    flowSnippet(): PLAutocompleteBlueprintSnippet;
+    flowEndSnippet(): PLAutocompleteBlueprintSnippet;
+    flowNoBodySnippet(): PLAutocompleteBlueprintSnippet;
+    substitutionSnippet(): PLAutocompleteBlueprintSnippet;
+    logFlowSnippet(): PLAutocompleteBlueprintSnippet;
+    varFlowSnippet(): PLAutocompleteBlueprintSnippet;
+    letFlowSnippet(): PLAutocompleteBlueprintSnippet;
+    setFlowSnippet(): PLAutocompleteBlueprintSnippet;
+    globalFlowSnippet(): PLAutocompleteBlueprintSnippet;
+    importFlowSnippet(): PLAutocompleteBlueprintSnippet;
+    returnFlowSnippet(): PLAutocompleteBlueprintSnippet;
+    emitFlowSnippet(): PLAutocompleteBlueprintSnippet;
+    injectFlowSnippet(): PLAutocompleteBlueprintSnippet;
+    codeMergeFlowSnippet(): PLAutocompleteBlueprintSnippet;
+    mapFlowSnippet(): PLAutocompleteBlueprintSnippet;
+    mapElseFlowSnippet(): PLAutocompleteBlueprintSnippet;
+    forFlowSnippet(): PLAutocompleteBlueprintSnippet;
+    forElseFlowSnippet(): PLAutocompleteBlueprintSnippet;
+    traverseFlowSnippet(): PLAutocompleteBlueprintSnippet;
+    switchFlowSnippet(): PLAutocompleteBlueprintSnippet;
+    switchDefaultFlowSnippet(): PLAutocompleteBlueprintSnippet;
+    caseFlowSnippet(): PLAutocompleteBlueprintSnippet;
+    defaultFlowSnippet(): PLAutocompleteBlueprintSnippet;
+    ifFlowSnippet(): PLAutocompleteBlueprintSnippet;
+    ifElseFlowSnippet(): PLAutocompleteBlueprintSnippet;
+    ifElseIfElseFlowSnippet(): PLAutocompleteBlueprintSnippet;
+    elseSnippet(): PLAutocompleteBlueprintSnippet;
+}

package/build/main/language/src/tools/autocomplete/PlaceholderEnabledSnippetPool.d.ts

@@ -0,0 +1,35 @@
+import { PLAutocompleteBlueprintSnippet } from './BlueprintSnippets';
+export declare class PLPlaceholderEnabledSnippetPool {
+    constructor();
+    allSnippets(): Array<PLAutocompleteBlueprintSnippet>;
+    commentSnippet(): PLAutocompleteBlueprintSnippet;
+    commentMultilineSnippet(): PLAutocompleteBlueprintSnippet;
+    flowSnippet(): PLAutocompleteBlueprintSnippet;
+    flowEndSnippet(): PLAutocompleteBlueprintSnippet;
+    flowNoBodySnippet(): PLAutocompleteBlueprintSnippet;
+    substitutionSnippet(): PLAutocompleteBlueprintSnippet;
+    logFlowSnippet(): PLAutocompleteBlueprintSnippet;
+    letFlowSnippet(): PLAutocompleteBlueprintSnippet;
+    constFlowSnippet(): PLAutocompleteBlueprintSnippet;
+    setFlowSnippet(): PLAutocompleteBlueprintSnippet;
+    globalFlowSnippet(): PLAutocompleteBlueprintSnippet;
+    importFlowSnippet(): PLAutocompleteBlueprintSnippet;
+    returnFlowSnippet(): PLAutocompleteBlueprintSnippet;
+    emitFlowSnippet(): PLAutocompleteBlueprintSnippet;
+    injectFlowSnippet(): PLAutocompleteBlueprintSnippet;
+    codeMergeFlowSnippet(): PLAutocompleteBlueprintSnippet;
+    mapFlowSnippet(): PLAutocompleteBlueprintSnippet;
+    mapElseFlowSnippet(): PLAutocompleteBlueprintSnippet;
+    forFlowSnippet(): PLAutocompleteBlueprintSnippet;
+    forElseFlowSnippet(): PLAutocompleteBlueprintSnippet;
+    traverseFlowSnippet(): PLAutocompleteBlueprintSnippet;
+    traverseChildrenFlowSnippet(): PLAutocompleteBlueprintSnippet;
+    switchFlowSnippet(): PLAutocompleteBlueprintSnippet;
+    switchDefaultFlowSnippet(): PLAutocompleteBlueprintSnippet;
+    caseFlowSnippet(): PLAutocompleteBlueprintSnippet;
+    defaultFlowSnippet(): PLAutocompleteBlueprintSnippet;
+    ifFlowSnippet(): PLAutocompleteBlueprintSnippet;
+    ifElseFlowSnippet(): PLAutocompleteBlueprintSnippet;
+    ifElseIfElseFlowSnippet(): PLAutocompleteBlueprintSnippet;
+    elseFlowSnippet(): PLAutocompleteBlueprintSnippet;
+}

package/build/main/language/src/tools/documentation/DeclarationBuilder.d.ts

@@ -0,0 +1,8 @@
+import { PLFunction } from '../../interpreter/functions/Function';
+import { PLTransformer } from '../../interpreter/transformers/Transformer';
+export declare class PLDeclarationBuilder {
+    static snippetDeclarationForFunction(func: PLFunction, includePlaceholders: boolean): string;
+    static snippetDeclarationForTransformer(transformer: PLTransformer, includePlaceholders: boolean): string;
+    static documentationDeclarationForFunction(func: PLFunction): string;
+    static documentationDeclarationForTransformer(transformer: PLTransformer): string;
+}

package/build/main/language/src/tools/documentation/Doc.d.ts

@@ -0,0 +1,30 @@
+import { PLFunction } from './../../interpreter/functions/Function';
+import { PLTransformer } from '../../interpreter/transformers/Transformer';
+export declare type DocDataType = string;
+export declare enum DocDataTypePredefinedType {
+    number = "Number",
+    bool = "Bool",
+    string = "string",
+    int = "Int",
+    double = "Double",
+    float = "Float",
+    array = "Array",
+    dict = "Dictionary",
+    any = "Any"
+}
+export interface DocArgument {
+    name: string;
+    description: string;
+    dataType: DocDataType;
+}
+export declare class PLDoc {
+    name: string;
+    description: string;
+    returnType: string | null;
+    link: string | null;
+    arguments: Array<DocArgument>;
+    constructor(name: string, link: string | null, text: string, dataType: string | null, args: Array<DocArgument> | null);
+    static functionDoc(func: PLFunction, text: string, dataType: DocDataType | DocDataTypePredefinedType, args: Array<DocArgument>, link: string | null): PLDoc;
+    static transfomerDoc(transformer: PLTransformer, text: string, dataType: DocDataType | DocDataTypePredefinedType, args: Array<DocArgument>, link: string | null): PLDoc;
+    static arg(name: string, text: string, dataType: DocDataType | DocDataTypePredefinedType): DocArgument;
+}

package/build/main/language/src/tools/documentation/Documentable.d.ts

@@ -0,0 +1,4 @@
+import { PLDoc } from './Doc';
+export interface PLDocumentable {
+    documentation(): PLDoc | null;
+}

package/build/main/language/src/tools/highlight/BlueprintHighlightEngine.d.ts

@@ -0,0 +1,51 @@
+import { PLHighlightEngine, PLHighlightEngineToken } from './HighlightEngine';
+import { PLFlow } from './../../interpreter/flows/Flow';
+import { PLTransformer } from './../../interpreter/transformers/Transformer';
+import { PLFunction } from './../../interpreter/functions/Function';
+import { PLExecutionContext } from './../../interpreter/ExecutionContext';
+import { PLBlueprintHighlightEngineState } from './BlueprintHighlightEngineState';
+import { SyntaxNodeSubstitution } from '../../parser/syntax/nodes/substitution/SyntaxNodeSubstitution';
+export declare class PLBlueprintHighlightEngine extends PLHighlightEngine {
+    blueprintFlowOpeningTag: string;
+    blueprintFlowClosingTag: string;
+    blueprintFlowClosingEndingTag: string;
+    blueprintFlowOpeningSubstitution: string;
+    blueprintFlowClosingSubstitution: string;
+    blueprintCommentOpening: string;
+    blueprintCommentClosing: string;
+    blueprintSnippetOpening: string;
+    blueprintSnippetClosing: string;
+    blueprintFunctions: Map<string, PLFunction>;
+    blueprintTransformers: Map<string, PLTransformer>;
+    blueprintFlows: Map<string, PLFlow>;
+    executionContext: PLExecutionContext;
+    constructor(executionContext: PLExecutionContext);
+    tokenize(string: string): Array<PLHighlightEngineToken>;
+    tokenizeControlTokens(string: string): Array<PLHighlightEngineToken>;
+    tokenizeNoncontrolTokens(string: string): Array<PLHighlightEngineToken>;
+    tokenizeUntilCommentEnd(state: PLBlueprintHighlightEngineState, string: string): {
+        remaining: string;
+        tokens: Array<PLHighlightEngineToken>;
+    };
+    tokenizeUntilSnippetEnd(state: PLBlueprintHighlightEngineState, string: string): {
+        remaining: string;
+        tokens: Array<PLHighlightEngineToken>;
+    };
+    tokenizeUntilSubstitutionEndOrNewline(state: PLBlueprintHighlightEngineState, string: string): {
+        remaining: string;
+        tokens: Array<PLHighlightEngineToken>;
+    };
+    tokenizeUntilFlowEndOrNewline(state: PLBlueprintHighlightEngineState, string: string): {
+        remaining: string;
+        tokens: Array<PLHighlightEngineToken>;
+    };
+    tokenizeUntilAnyNonControlOpeningTag(state: PLBlueprintHighlightEngineState, string: string): string;
+    tokenizeUntilAnyControlOpeningTag(state: PLBlueprintHighlightEngineState, string: string): {
+        remaining: string;
+        tokens: Array<PLHighlightEngineToken>;
+    };
+    tokenizeFlow(definition: string, initialSeekIndex: number): Array<PLHighlightEngineToken>;
+    tokenizeSubstitution(definition: string, initialSeekIndex: number): Array<PLHighlightEngineToken>;
+    highlightSubstitution(_node: SyntaxNodeSubstitution, _definition: string, _initialSeekIndex: number): Array<PLHighlightEngineToken>;
+    updateKeywords(executionContext: PLExecutionContext): void;
+}

package/build/main/language/src/tools/highlight/BlueprintHighlightEngineState.d.ts

@@ -0,0 +1,41 @@
+export declare class PLBlueprintHighlightEngineState {
+    seekedIndex: number;
+    followsDot: boolean;
+    followsFunction: boolean;
+    followsFlowOpening: boolean;
+    followsSubstitutionOpening: boolean;
+    commentOpened: boolean;
+    snippetOpened: boolean;
+    bufferStart: number;
+    buffer: string;
+    fullString: string;
+    lineSeparator: string;
+    wordSeparator: string;
+    constructor(fullString: string);
+    resetAfterNewline(): void;
+    resetAfterSpace(): void;
+    resetAfterSubstitutionOpeningTag(): void;
+    resetAfterSubstitutionClosingTag(): void;
+    resetAfterFlowOpeningTag(): void;
+    resetAfterBracket(): void;
+    resetAfterFlowClosingTag(): void;
+    openComment(): void;
+    resetAfterClosingComment(): void;
+    openSnippet(): void;
+    resetAfterClosingSnippet(): void;
+    addToBuffer(character: string): void;
+    isBufferedNewline(): boolean;
+    isLastCharacterWordSeparator(): boolean;
+    isLastCharacterLineSeparator(): boolean;
+    isLastCharacterOpeningBracket(): boolean;
+    isLastCharacterClosingBracket(): boolean;
+    isLastCharacterQuote(): boolean;
+    isLastCharacterFunctionMark(): boolean;
+    lastBufferPart(size: number): string | null;
+    lastBufferPartIfEquals(equals: string): {
+        equals: boolean;
+        startIndex: number;
+        size: number;
+    } | null;
+    textAtPosition(position: number, length: number): string;
+}