@supernova-studio/pulsar-core 1.0.41 → 1.0.43

package/build/typings/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, from: Array<ConcreteToken>);
+    add(node: SyntaxNode): void;
+    debugDescription(): string;
+    equals(obj: SyntaxNodeGroup): boolean;
+    interpret(_context: PLInterpreterContext, _executionContext: PLExecutionContext): Promise<string>;
+}

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

@@ -0,0 +1,26 @@
+import { NodeType, SyntaxNode } from "./SyntaxNode";
+import { PLFunction } from "../../../interpreter/functions/Function";
+import { PLExecutionContext } from "../../../interpreter/ExecutionContext";
+import { PLTransformer } from "../../../interpreter/transformers/Transformer";
+import { PLInterpreterContext } from "../../../interpreter/InterpreterContext";
+import { ConcreteToken } from "../../Tokenization/Concrete/ConcreteToken";
+export declare class SyntaxNodeSubstitution implements SyntaxNode {
+    nodeType: NodeType;
+    backingTokens: Array<ConcreteToken>;
+    debugSymbol: string | null;
+    customDataSource: {
+        function: PLFunction;
+        directive: string;
+    } | null;
+    transformers: Array<{
+        transformer: PLTransformer;
+        directive: string;
+    }>;
+    directive: string;
+    constructor(directive: string, executionContext: PLExecutionContext, from: Array<ConcreteToken>);
+    modifyInputValue(context: PLInterpreterContext, executionContext: PLExecutionContext): Promise<any>;
+    debugDescription(): string;
+    equals(obj: SyntaxNodeSubstitution): boolean;
+    interpret(context: PLInterpreterContext, executionContext: PLExecutionContext): Promise<string>;
+    interpretValue(context: PLInterpreterContext, executionContext: PLExecutionContext): Promise<any>;
+}

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

@@ -0,0 +1,15 @@
+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, from: Array<ConcreteToken>);
+    debugDescription(): string;
+    equals(obj: SyntaxNodeText): boolean;
+    interpret(_context: PLInterpreterContext, _executionContext: PLExecutionContext): Promise<string>;
+}

package/build/typings/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/typings/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/typings/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/typings/language/src/tools/autocomplete/PlaceholderDisabledSnippetPool.d.ts

@@ -0,0 +1,33 @@
+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;
+}

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

@@ -0,0 +1,33 @@
+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;
+    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;
+}

package/build/typings/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/typings/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/typings/language/src/tools/documentation/Documentable.d.ts

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

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

package/build/typings/language/src/tools/highlight/HighlightEngine.d.ts

@@ -0,0 +1,44 @@
+export declare enum PLHighlightEngineTokenType {
+    keyword = "keyword",
+    openingBracket = "openingBracket",
+    closingBracket = "closingBracket",
+    customDelimiter1 = "cd1",
+    customDelimiter2 = "cd2",
+    stringKey = "stringKey",
+    stringConstant = "stringConstant",
+    numericConstant = "numericConstant",
+    comment = "comment",
+    function = "function",
+    method = "method",
+    variable = "variable",
+    plainText = "plainText",
+    dynamicSnippet = "dynamicSnippet"
+}
+export declare type PLHighlightEngineStyleFont = {
+    family: string;
+    weight: number;
+    size: number;
+};
+export declare type PLHighlightEngineToken = {
+    type: PLHighlightEngineTokenType;
+    position: number;
+    count: number;
+    text: string;
+};
+export declare type PLHighlightEngineStyle = {
+    font: PLHighlightEngineStyleFont;
+    color: string;
+    type: PLHighlightEngineTokenType;
+};
+export declare class PLHighlightEngine {
+    styles: Map<PLHighlightEngineTokenType, PLHighlightEngineStyle>;
+    baseFont: PLHighlightEngineStyleFont;
+    baseColor: string;
+    constructor();
+    private setupDefaultStyles;
+    tokenize(_string: string): Array<PLHighlightEngineToken>;
+    tokenAtPosition(position: number, count: number | null, text: string, type: PLHighlightEngineTokenType): PLHighlightEngineToken;
+    setStyles(styles: Array<PLHighlightEngineStyle>): void;
+    setStyle(style: PLHighlightEngineStyle): void;
+    setStyleUsingDefinition(font: PLHighlightEngineStyleFont, color: string, type: PLHighlightEngineTokenType): void;
+}

package/build/typings/language/src/utils/FlowUtils.d.ts

@@ -0,0 +1,5 @@
+export declare class FlowUtils {
+    static offsetLines(content: string, by: number, character: string): string;
+    static offsetLinesIgnoreFirst(content: string, by: number, character: string): string;
+    static offsetLinesCanIgnoreFirstline(content: string, shouldIgnoreFirstLine: boolean, userOffset: number, nodeOffset: number, character: string): string;
+}

package/build/typings/language/src/utils/StringUtils.d.ts

@@ -0,0 +1,72 @@
+export declare class StringUtils {
+    /** Returns string without whitespaces and newlines, trimmed left and right */
+    static trimmed(str: string): string;
+    /** Returns string without double quotes, trimmed left and right */
+    static withoutDoubleQuotes(str: string): string;
+    /** Returns string without single and double quotes, trimmed left and right */
+    static withoutQuotes(str: string): string;
+    /** Returns opening string until the first occurance of the character. If delimiter is not found, returns null */
+    static substringUntilDelimiter(str: string, delimiter: string): string | null;
+    /** Returns whether string is prefixed and suffixed with double quotes */
+    static isSurroundedWithDoubleQuotes(str: string): boolean;
+    /** Returns substring between two round brackets. Returns null if it doesn't fit the format */
+    static argumentStringBetweenBrackets(str: string, keyword: string): string | null;
+    /** Returns substring between two round brackets using syntax-sensitive parsing (ignoring quoted content and properly balancing number of ( ) */
+    static argumentStringBetweenBracketsFirstOccurance(str: string, keyword: string): string | null;
+    /** Returns string without single and double quotes but removes only 1 character at most */
+    static withoutQuotesSingleOccurance(str: string): string;
+    /** Returns string without single and double quotes but removes only 1 character at most */
+    static withoutDoubleQuotesSingleOccurance(str: string): string;
+    /** Returns string without round brackets, trimmed left and right */
+    static withoutRoundBrackets(str: string): string;
+    /** Creates a full range of a string, returning range of (0, length) */
+    static fullRange(str: string): {
+        location: number;
+        length: number;
+    };
+    /** Creates string made of N spaces */
+    static spaces(count: number): string;
+    /** Splits string using separator while properly handling quotes.
+    Content inside single or double quote will be ignored. Only content within closed quote pair will be ignored,
+    Last single, not closed quote will be ignored. Quote types can't be combined, if the quote pair
+    started with one type, it needs to be closed with the same one. There can be multiple types of quote pairs in single string though.
+    Returns original string without splitting if separator is single or double quote as this behavior is undefined */
+    static splitIgnoringQuotedContent(str: string, separator: string): Array<string>;
+    /** Removes spaces when they are inside of brackets, but properly handling spaces inside quoted content which should remain intact */
+    static withoutSpacesInsideRoundBrackets(str: string): string;
+    /** Splits string using separator while properly handling quotes and ignoring all content that comes in ().
+    Content inside single or double quote will be ignored. Only content within closed quote pair will be ignored,
+    Last single, not closed quote will be ignored. Quote types can't be combined, if the quote pair
+    started with one type, it needs to be closed with the same one. There can be multiple types
+    of quote pairs in single string though.
+    Returns original string without splitting if separator is single, double quote or left/right bracket as this behavior is undefined */
+    static splitIgnoringQuotedBracketedContent(str: string, separator: string): Array<string>;
+    /** Tests whether all characters of the string are lowercased and are only letters a-z */
+    static isLowercaseLetters(str: string): boolean;
+    /** Tests whether all characters of the string are lowercased and are only letters a-z, including separator dot */
+    static isLowercaseLettersCanIncludeDot(str: string): boolean;
+    /** Tests whether all characters of the string are letters */
+    static isLetters(str: string): boolean;
+    /** Tests whether all characters of the string are letters, including separator dot */
+    static isLettersCanIncludeDot(str: string): boolean;
+    /** Tests whether the first character of the string is lowercase */
+    static isFirstCharacterLetterLowercase(str: string): boolean;
+    /** Tests whether all characters of the string are spaces */
+    static isOnlySpaces(str: string): boolean;
+    /** Tests whether all characters of the string are spaces or newlines */
+    static isOnlySpacesOrLineBreaks(str: string): boolean;
+    /** Tests whether string represents array definition - starts with [, ends with ]
+     * and doesn't contain : unless in double quotes
+     */
+    static isStructuralArrayDefinition(str: string): boolean;
+    /** Parses array if it is structuraly viable and retrieves array components */
+    static parsedArrayFromDefinition(str: string): Array<string> | null;
+    /** Tests whether string represents dictionary definition - starts with [, ends with ]
+     * and contains at least once :
+     */
+    static isStructuralDictionaryDefinition(str: string): boolean;
+    /** Parses array if it is structuraly viable and retrieves array components */
+    static parsedDictionaryFromDefinition(str: string): Map<string, string> | null;
+    static replaceAll(str: string, find: string, replace: string): string;
+    static escapeRegExp(string: string): string;
+}

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@supernova-studio/pulsar-core",
-  "version": "1.0.41",
+  "version": "1.0.43",
   "description": "Export Engine for Supernova DSM",
   "main": "build/main/pulsar-core.js",
-  "typings": "build/typings/core/src/index.d.ts",
+  "types": "build/typings/core/src/index.d.ts",
   "repository": "https://github.com/Supernova-Studio/Pulsar",
   "license": "MIT",
   "keywords": [],
@@ -17,7 +17,7 @@
     "tsversion": "tsc -v",
     "fix": "run-s fix:*",
     "fix:tslint": "tslint --fix --project .",
-    "test": "run-s build test:*",
+    "test": "run-s test:*",
     "test-skipped:lint": "tslint --project .",
     "test:unit": "nyc --silent ava --verbose --timeout=30s",
     "watch": "run-s clean build:main && run-p \"build:main -- -w\" \"test:unit -- --watch\"",
@@ -99,7 +99,14 @@
   "ava": {
     "failFast": true,
     "files": [
-      "build/main/**/*.spec.js"
+      "src/**/*.spec.ts"
+    ],
+    "extensions": [
+      "ts"
+    ],
+    "require": [
+      "ts-node/register",
+      "tsconfig-paths/register"
     ]
   },
   "config": {},