@supernova-studio/pulsar-core 1.0.41 → 1.0.43

package/build/typings/language/src/interpreter/transformers/specific/string/TransformerContains.d.ts

@@ -0,0 +1,11 @@
+import { PLTransformer } from "../../Transformer";
+import { PLDoc } from "../../../../tools/documentation/Doc";
+import { PLTransformerArgument } from "../../TransformerArgument";
+import { PLExecutionContext } from "../../../ExecutionContext";
+import { PLInterpreterContext } from "../../../InterpreterContext";
+export declare class PLTransformerContains extends PLTransformer {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    transformStringValue(value: string, args: Array<PLTransformerArgument>, context: PLInterpreterContext, executionContext: PLExecutionContext): Promise<any>;
+}

package/build/typings/language/src/interpreter/transformers/specific/string/TransformerDefault.d.ts

@@ -0,0 +1,12 @@
+import { PLTransformer } from "../../Transformer";
+import { PLDoc } from "../../../../tools/documentation/Doc";
+import { PLTransformerArgument } from "../../TransformerArgument";
+import { PLExecutionContext } from "../../../ExecutionContext";
+import { PLInterpreterContext } from "../../../InterpreterContext";
+export declare class PLTransformerDefault extends PLTransformer {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    transformStringValue(value: string, args: Array<PLTransformerArgument>, context: PLInterpreterContext, executionContext: PLExecutionContext): Promise<any>;
+    transformNullValue(args: Array<PLTransformerArgument>, context: PLInterpreterContext, executionContext: PLExecutionContext): Promise<any>;
+}

package/build/typings/language/src/interpreter/transformers/specific/string/TransformerEquals.d.ts

@@ -0,0 +1,11 @@
+import { PLTransformer } from "../../Transformer";
+import { PLDoc } from "../../../../tools/documentation/Doc";
+import { PLTransformerArgument } from "../../TransformerArgument";
+import { PLExecutionContext } from "../../../ExecutionContext";
+import { PLInterpreterContext } from "../../../InterpreterContext";
+export declare class PLTransformerEquals extends PLTransformer {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    transformStringValue(value: string, args: Array<PLTransformerArgument>, context: PLInterpreterContext, executionContext: PLExecutionContext): Promise<any>;
+}

package/build/typings/language/src/interpreter/transformers/specific/string/TransformerEqualsTernary.d.ts

@@ -0,0 +1,11 @@
+import { PLTransformer } from "../../Transformer";
+import { PLDoc } from "../../../../tools/documentation/Doc";
+import { PLTransformerArgument } from "../../TransformerArgument";
+import { PLExecutionContext } from "../../../ExecutionContext";
+import { PLInterpreterContext } from "../../../InterpreterContext";
+export declare class PLTransformerEqualsTernary extends PLTransformer {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    transformStringValue(value: string, args: Array<PLTransformerArgument>, context: PLInterpreterContext, executionContext: PLExecutionContext): Promise<any>;
+}

package/build/typings/language/src/interpreter/transformers/specific/string/TransformerExtended.d.ts

@@ -0,0 +1,11 @@
+import { PLTransformer } from "../../Transformer";
+import { PLDoc } from "../../../../tools/documentation/Doc";
+import { PLTransformerArgument } from "../../TransformerArgument";
+import { PLExecutionContext } from "../../../ExecutionContext";
+import { PLInterpreterContext } from "../../../InterpreterContext";
+export declare class PLTransformerExtended extends PLTransformer {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    transformStringValue(value: string, args: Array<PLTransformerArgument>, context: PLInterpreterContext, executionContext: PLExecutionContext): Promise<any>;
+}

package/build/typings/language/src/interpreter/transformers/specific/string/TransformerLowercased.d.ts

@@ -0,0 +1,11 @@
+import { PLTransformer } from "../../Transformer";
+import { PLDoc } from "../../../../tools/documentation/Doc";
+import { PLTransformerArgument } from "../../TransformerArgument";
+import { PLExecutionContext } from "../../../ExecutionContext";
+import { PLInterpreterContext } from "../../../InterpreterContext";
+export declare class PLTransformerLowercased extends PLTransformer {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    transformStringValue(value: string, _args: Array<PLTransformerArgument>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): Promise<any>;
+}

package/build/typings/language/src/interpreter/transformers/specific/string/TransformerPrefixed.d.ts

@@ -0,0 +1,11 @@
+import { PLTransformer } from "../../Transformer";
+import { PLDoc } from "../../../../tools/documentation/Doc";
+import { PLTransformerArgument } from "../../TransformerArgument";
+import { PLExecutionContext } from "../../../ExecutionContext";
+import { PLInterpreterContext } from "../../../InterpreterContext";
+export declare class PLTransformerPrefixed extends PLTransformer {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    transformStringValue(value: string, args: Array<PLTransformerArgument>, context: PLInterpreterContext, executionContext: PLExecutionContext): Promise<any>;
+}

package/build/typings/language/src/interpreter/transformers/specific/string/TransformerReplacing.d.ts

@@ -0,0 +1,11 @@
+import { PLTransformer } from "../../Transformer";
+import { PLDoc } from "../../../../tools/documentation/Doc";
+import { PLTransformerArgument } from "../../TransformerArgument";
+import { PLExecutionContext } from "../../../ExecutionContext";
+import { PLInterpreterContext } from "../../../InterpreterContext";
+export declare class PLTransformerReplacing extends PLTransformer {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    transformStringValue(value: string, args: Array<PLTransformerArgument>, context: PLInterpreterContext, executionContext: PLExecutionContext): Promise<any>;
+}

package/build/typings/language/src/interpreter/transformers/specific/string/TransformerSlashDoubleQuotes.d.ts

@@ -0,0 +1,11 @@
+import { PLTransformer } from "../../Transformer";
+import { PLDoc } from "../../../../tools/documentation/Doc";
+import { PLTransformerArgument } from "../../TransformerArgument";
+import { PLExecutionContext } from "../../../ExecutionContext";
+import { PLInterpreterContext } from "../../../InterpreterContext";
+export declare class PLTransformerSlashDoubleQuotes extends PLTransformer {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    transformStringValue(value: string, _args: Array<PLTransformerArgument>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): Promise<any>;
+}

package/build/typings/language/src/interpreter/transformers/specific/string/TransformerSlashNewlines.d.ts

@@ -0,0 +1,11 @@
+import { PLTransformer } from "../../Transformer";
+import { PLDoc } from "../../../../tools/documentation/Doc";
+import { PLTransformerArgument } from "../../TransformerArgument";
+import { PLExecutionContext } from "../../../ExecutionContext";
+import { PLInterpreterContext } from "../../../InterpreterContext";
+export declare class PLTransformerSlashNewlines extends PLTransformer {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    transformStringValue(value: string, _args: Array<PLTransformerArgument>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): Promise<any>;
+}

package/build/typings/language/src/interpreter/transformers/specific/string/TransformerSlashSingleQuotes.d.ts

@@ -0,0 +1,11 @@
+import { PLTransformer } from "../../Transformer";
+import { PLDoc } from "../../../../tools/documentation/Doc";
+import { PLTransformerArgument } from "../../TransformerArgument";
+import { PLExecutionContext } from "../../../ExecutionContext";
+import { PLInterpreterContext } from "../../../InterpreterContext";
+export declare class PLTransformerSlashSingleQuotes extends PLTransformer {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    transformStringValue(value: string, _args: Array<PLTransformerArgument>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): Promise<any>;
+}

package/build/typings/language/src/interpreter/transformers/specific/string/TransformerSnakecased.d.ts

@@ -0,0 +1,11 @@
+import { PLTransformer } from "../../Transformer";
+import { PLDoc } from "../../../../tools/documentation/Doc";
+import { PLTransformerArgument } from "../../TransformerArgument";
+import { PLExecutionContext } from "../../../ExecutionContext";
+import { PLInterpreterContext } from "../../../InterpreterContext";
+export declare class PLTransformerSnakecased extends PLTransformer {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    transformStringValue(value: string, _args: Array<PLTransformerArgument>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): Promise<any>;
+}

package/build/typings/language/src/interpreter/transformers/specific/string/TransformerSplit.d.ts

@@ -0,0 +1,11 @@
+import { PLTransformer } from "../../Transformer";
+import { PLDoc } from "../../../../tools/documentation/Doc";
+import { PLTransformerArgument } from "../../TransformerArgument";
+import { PLExecutionContext } from "../../../ExecutionContext";
+import { PLInterpreterContext } from "../../../InterpreterContext";
+export declare class PLTransformerSplit extends PLTransformer {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    transformStringValue(value: string, args: Array<PLTransformerArgument>, context: PLInterpreterContext, executionContext: PLExecutionContext): Promise<any>;
+}

package/build/typings/language/src/interpreter/transformers/specific/string/TransformerSplitExpr.d.ts

@@ -0,0 +1,11 @@
+import { PLTransformer } from "../../Transformer";
+import { PLDoc } from "../../../../tools/documentation/Doc";
+import { PLTransformerArgument } from "../../TransformerArgument";
+import { PLExecutionContext } from "../../../ExecutionContext";
+import { PLInterpreterContext } from "../../../InterpreterContext";
+export declare class PLTransformerSplitExpr extends PLTransformer {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    transformStringValue(value: string, args: Array<PLTransformerArgument>, context: PLInterpreterContext, executionContext: PLExecutionContext): Promise<any>;
+}

package/build/typings/language/src/interpreter/transformers/specific/string/TransformerSubstring.d.ts

@@ -0,0 +1,11 @@
+import { PLTransformer } from "../../Transformer";
+import { PLDoc } from "../../../../tools/documentation/Doc";
+import { PLTransformerArgument } from "../../TransformerArgument";
+import { PLExecutionContext } from "../../../ExecutionContext";
+import { PLInterpreterContext } from "../../../InterpreterContext";
+export declare class PLTransformerSubstring extends PLTransformer {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    transformStringValue(value: string, args: Array<PLTransformerArgument>, context: PLInterpreterContext, executionContext: PLExecutionContext): Promise<any>;
+}

package/build/typings/language/src/interpreter/transformers/specific/string/TransformerSuffixed.d.ts

@@ -0,0 +1,11 @@
+import { PLTransformer } from "../../Transformer";
+import { PLDoc } from "../../../../tools/documentation/Doc";
+import { PLTransformerArgument } from "../../TransformerArgument";
+import { PLExecutionContext } from "../../../ExecutionContext";
+import { PLInterpreterContext } from "../../../InterpreterContext";
+export declare class PLTransformerSuffixed extends PLTransformer {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    transformStringValue(value: string, args: Array<PLTransformerArgument>, context: PLInterpreterContext, executionContext: PLExecutionContext): Promise<any>;
+}

package/build/typings/language/src/interpreter/transformers/specific/string/TransformerTrimmingCharacter.d.ts

@@ -0,0 +1,12 @@
+import { PLTransformer } from "../../Transformer";
+import { PLDoc } from "../../../../tools/documentation/Doc";
+import { PLTransformerArgument } from "../../TransformerArgument";
+import { PLExecutionContext } from "../../../ExecutionContext";
+import { PLInterpreterContext } from "../../../InterpreterContext";
+export declare class PLTransformerTrimmingCharacter extends PLTransformer {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    transformStringValue(value: string, args: Array<PLTransformerArgument>, context: PLInterpreterContext, executionContext: PLExecutionContext): Promise<any>;
+    trim(s: any, c: any): string;
+}

package/build/typings/language/src/interpreter/transformers/specific/string/TransformerTrimmingSpaces.d.ts

@@ -0,0 +1,11 @@
+import { PLTransformer } from "../../Transformer";
+import { PLDoc } from "../../../../tools/documentation/Doc";
+import { PLTransformerArgument } from "../../TransformerArgument";
+import { PLExecutionContext } from "../../../ExecutionContext";
+import { PLInterpreterContext } from "../../../InterpreterContext";
+export declare class PLTransformerTrimmingSpaces extends PLTransformer {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    transformStringValue(value: string, _args: Array<PLTransformerArgument>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): Promise<any>;
+}

package/build/typings/language/src/interpreter/transformers/specific/string/TransformerUppercased.d.ts

@@ -0,0 +1,11 @@
+import { PLTransformer } from "../../Transformer";
+import { PLDoc } from "../../../../tools/documentation/Doc";
+import { PLTransformerArgument } from "../../TransformerArgument";
+import { PLExecutionContext } from "../../../ExecutionContext";
+import { PLInterpreterContext } from "../../../InterpreterContext";
+export declare class PLTransformerUppercased extends PLTransformer {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    transformStringValue(value: string, _args: Array<PLTransformerArgument>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): Promise<any>;
+}

package/build/typings/language/src/interpreter/variables/Variable.d.ts

@@ -0,0 +1,19 @@
+export declare class PLVariable {
+    /** Variable identifier */
+    identifier: string;
+    /** Context identifiers where it was defined, which is used in scope lookup */
+    scope: Array<string>;
+    /** If set, variable can be redefined after it was defined for the first time */
+    isMutable: boolean;
+    /** If set, variable is considered global and will be available in any context */
+    isGlobal: boolean;
+    /** Data payload of the variable */
+    payload: any;
+    constructor(identifier: string, scope: Array<string>, isMutable: boolean, isGlobal: boolean, payload: any);
+    static immutableProperty(scope: Array<string>, identifier: string, payload: any): PLVariable;
+    static mutableProperty(scope: Array<string>, identifier: string, payload: any): PLVariable;
+    static immutableGlobalProperty(scope: Array<string>, identifier: string, payload: any): PLVariable;
+    setPayload(payload: any): void;
+    isAvailableInContext(flowIdentifier: Array<string>): boolean;
+    debugDescription(): string;
+}

package/build/typings/language/src/interpreter/variables/VariableContext.d.ts

@@ -0,0 +1,10 @@
+import { PLVariable } from "./Variable";
+export declare class PLVariableContext {
+    stack: Array<PLVariable>;
+    functionReturnStack: Array<Map<string, any>>;
+    constructor();
+    setVariable(identifier: string, isGlobal: boolean, isMutable: boolean, context: Array<string>, payload: any): void;
+    getVariable(identifier: string, context: Array<string>): PLVariable;
+    getVariableFailable(identifier: string, context: Array<string>): PLVariable | null;
+    variables(identifier: string): Array<PLVariable>;
+}

package/build/typings/language/src/parser/Tokenization/Concrete/ConcreteBuffer.d.ts

@@ -0,0 +1,19 @@
+import { ConcreteToken } from "./ConcreteToken";
+export declare class ConcreteBuffer {
+    tokens: Array<ConcreteToken>;
+    isEmpty(): boolean;
+    size(): number;
+    constructor(tokens: Array<ConcreteToken>);
+    addToken(token: ConcreteToken): void;
+    addTokens(tokens: [ConcreteToken]): void;
+    removeFirst(): ConcreteToken | null;
+    removeLast(): ConcreteToken | null;
+    removeAt(at: number): ConcreteToken | null;
+    removeLastFew(count: number): Array<ConcreteToken>;
+    removeFirstFew(count: number): Array<ConcreteToken>;
+    shallowCopy(): ConcreteBuffer;
+    first(): ConcreteToken | null;
+    last(): ConcreteToken | null;
+    lookahead(offset: number): ConcreteToken | null;
+    debugDescription(): string;
+}

package/build/typings/language/src/parser/Tokenization/Concrete/ConcreteParser.d.ts

@@ -0,0 +1,25 @@
+import { PLDebugger } from "../../../debugger/Debugger";
+import { PLBlueprintConfiguration } from "../../../blueprints/BlueprintConfiguration";
+import { LexicalBuffer } from "../Lexical/LexicalBuffer";
+import { LexicalToken } from "../Lexical/LexicalToken";
+import { ConcreteBuffer } from "./ConcreteBuffer";
+import { ConcreteToken } from "./ConcreteToken";
+interface ExtractionResult {
+    token: ConcreteToken;
+    size: number;
+}
+export declare class ConcreteParser {
+    tokens: LexicalBuffer;
+    configuration: PLBlueprintConfiguration;
+    debugger: PLDebugger;
+    constructor(tokens: LexicalBuffer, configuration: PLBlueprintConfiguration, debug: PLDebugger);
+    parse(): ConcreteBuffer;
+    extractTextToken(tokens: Array<LexicalToken>, prefix: string): ExtractionResult;
+    extractSubstitutionToken(tokens: Array<LexicalToken>, openingToken: LexicalToken): ExtractionResult;
+    extractCommentToken(tokens: Array<LexicalToken>): number;
+    extractFlow(tokens: Array<LexicalToken>, lineOffset: number, isFirstLineDirective: boolean, openingToken: LexicalToken): ExtractionResult;
+    isEqual(t1: LexicalToken, t2: LexicalToken): boolean;
+    isText(t1: LexicalToken): boolean;
+    textFrom(token: LexicalToken): string;
+}
+export {};

package/build/typings/language/src/parser/Tokenization/Concrete/ConcreteToken.d.ts

@@ -0,0 +1,21 @@
+import { LexicalToken } from "../Lexical/LexicalToken";
+export declare enum ConcreteTokenType {
+    text = "text",
+    substitution = "substitution",
+    flow = "flow",
+    flowEnd = "flowEnd"
+}
+export declare class ConcreteToken {
+    /** Type of the concrete token */
+    type: ConcreteTokenType;
+    /** Additional information associated with the token - usually its payload */
+    associatedValue: string | null;
+    /** Line offset from the line beginning */
+    lineOffset: number;
+    /** Flag signifying that the concrete token is the first executable token on a single processed line (but might not be the only one) */
+    firstLineDirective: boolean;
+    /** Lexical tokens providing raw information for the concrete token */
+    lts: LexicalToken[];
+    /** Debug symbol identifier */
+    debugSymbol: string | null;
+}

package/build/typings/language/src/parser/Tokenization/Lexical/LexicalBuffer.d.ts

@@ -0,0 +1,22 @@
+import { LexicalToken } from "./LexicalToken";
+export declare class LexicalBuffer {
+    tokens: Array<LexicalToken>;
+    lastId: number;
+    isEmpty(): boolean;
+    size(): number;
+    constructor(tokens: Array<LexicalToken>);
+    addToken(token: LexicalToken): void;
+    addTokens(tokens: Array<LexicalToken>): void;
+    removeFirst(): LexicalToken | null;
+    removeLast(): LexicalToken | null;
+    removeAt(at: number): LexicalToken | null;
+    removeLastFew(count: number): Array<LexicalToken>;
+    removeFirstFew(count: number): Array<LexicalToken>;
+    shallowCopy(): LexicalBuffer;
+    shallowCopyOmittingVirtualTokens(): LexicalBuffer;
+    first(): LexicalToken | null;
+    last(): LexicalToken | null;
+    lookahead(offset: number): LexicalToken | null;
+    sequentialIdentifier(): string;
+    debugDescription(): string;
+}

package/build/typings/language/src/parser/Tokenization/Lexical/LexicalParser.d.ts

@@ -0,0 +1,14 @@
+import { PLDebugger } from "../../../debugger/Debugger";
+import { PLBlueprintConfiguration } from "../../../blueprints/BlueprintConfiguration";
+import { LexicalBuffer } from "./LexicalBuffer";
+import { LexicalToken } from "./LexicalToken";
+export declare class LexicalParser {
+    definition: string;
+    configuration: PLBlueprintConfiguration;
+    debugger: PLDebugger;
+    constructor(definition: string, configuration: PLBlueprintConfiguration, debug: PLDebugger);
+    parse(): LexicalBuffer;
+    enclosingFlowTagCombination(line: number, character: number): Array<LexicalToken>;
+    openingToken(from: string, line: number, character: number): LexicalToken | null;
+    enclosingToken(from: string, line: number, character: number): LexicalToken | null;
+}

package/build/typings/language/src/parser/Tokenization/Lexical/LexicalToken.d.ts

@@ -0,0 +1,24 @@
+export declare enum LexicalTokenType {
+    openingSubstitution = "openingSubstitution",
+    enclosingSubstitution = "enclosingSubstitution",
+    openingFlow = "openingFlow",
+    enclosingFlow = "enclosingFlow",
+    flowEnd = "flowEnd",
+    openingComment = "openingComment",
+    enclosingComment = "enclosingComment",
+    openingEditorPlaceholder = "openingEditorPLaceholder",
+    enclosingEditorPlaceholder = "enclosingEditorPlaceholder",
+    plainText = "plainText",
+    newline = "newline"
+}
+export declare class LexicalToken {
+    type: LexicalTokenType;
+    associatedValue: string | null;
+    startChar: number;
+    startLine: number;
+    endChar: number;
+    endLine: number;
+    debugSymbol: string | null;
+    /** Flag signifying that token was created by the system */
+    virtual: boolean;
+}

package/build/typings/language/src/parser/errors/LanguageError.d.ts

@@ -0,0 +1,5 @@
+import { PLErrorAnalysis } from "./LanguageErrorAnalysis";
+export declare class PLError extends Error {
+    analysis: PLErrorAnalysis | null;
+    constructor(message: string, analysis: PLErrorAnalysis | null);
+}

package/build/typings/language/src/parser/errors/LanguageErrorAnalysis.d.ts

@@ -0,0 +1,25 @@
+export declare enum PLErrorSeverityType {
+    warning = 0,
+    error = 1
+}
+export declare enum PLErrorSourceType {
+    analyzer = 0,
+    runtime = 1
+}
+export declare type PLErrorRange = {
+    startLine: number;
+    startChar: number;
+    endLine: number;
+    endChar: number;
+};
+export declare class PLErrorAnalysis {
+    severity?: PLErrorSeverityType;
+    source?: PLErrorSourceType;
+    range?: PLErrorRange;
+    constructor(severity?: PLErrorSeverityType, source?: PLErrorSourceType, range?: {
+        startLine: number;
+        startChar: number;
+        endLine: number;
+        endChar: number;
+    });
+}

package/build/typings/language/src/parser/symbols/Symbol.d.ts

@@ -0,0 +1,29 @@
+import { SymbolType } from "./SymbolType";
+export interface SymbolModel {
+    identifier: string;
+    source: string;
+    startLine: number;
+    startChar: number;
+    endLine: number;
+    endChar: number;
+    type: SymbolType;
+}
+export declare class Symbol implements SymbolModel {
+    identifier: string;
+    source: string;
+    startLine: number;
+    startChar: number;
+    endLine: number;
+    endChar: number;
+    type: SymbolType;
+    constructor(model: SymbolModel);
+    /** Retrieve symbol data without identifier */
+    anonymizedSymbolData(): {
+        source: string;
+        startLine: number;
+        startChar: number;
+        endLine: number;
+        endChar: number;
+        type: SymbolType;
+    };
+}

package/build/typings/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/typings/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/typings/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/typings/language/src/parser/symbols/SymbolType.d.ts

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

package/build/typings/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/typings/language/src/parser/syntax/SyntaxTree.d.ts

@@ -0,0 +1,7 @@
+import { SyntaxNodeGroup } from "./nodes/SyntaxNodeGroup";
+export declare class SyntaxTree {
+    rootNode: SyntaxNodeGroup;
+    constructor(rootNode?: SyntaxNodeGroup);
+    debugDescription(): string;
+    equals(obj: SyntaxTree): boolean;
+}

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

@@ -0,0 +1,16 @@
+import { PLExecutionContext } from "../../../interpreter/ExecutionContext";
+import { ConcreteToken } from "../../Tokenization/Concrete/ConcreteToken";
+import { PLInterpreterContext } from "../../../interpreter/InterpreterContext";
+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 interpret(context: PLInterpreterContext, executionContext: PLExecutionContext): Promise<string>;
+    abstract debugDescription(): string;
+}

package/build/typings/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>;
+}