@flexiberry/berrycore 0.1.0

package/dist/parser/tokenizer/reader/grammer/comment.grammer.d.ts

@@ -0,0 +1,2 @@
+import { LexerGrammer } from "../lexer.types.js";
+export declare const comment: LexerGrammer;

package/dist/parser/tokenizer/reader/grammer/comment.grammer.js

@@ -0,0 +1,13 @@
+import { TokenType } from "../../tokenType.js";
+export const comment = {
+    name: "comment",
+    regex: /^\s*##(.*$)/,
+    groups: [
+        {
+            tokenType: TokenType.Comment,
+            index: 1,
+        },
+    ],
+    isOptional: true,
+    isMultiline: false,
+};

package/dist/parser/tokenizer/reader/grammer/conditions.grammer.d.ts

@@ -0,0 +1,2 @@
+import { LexerGrammer } from "../lexer.types.js";
+export declare const conditionGrammer: LexerGrammer;

package/dist/parser/tokenizer/reader/grammer/conditions.grammer.js

@@ -0,0 +1,68 @@
+import { TokenType } from "../../tokenType.js";
+export const conditionGrammer = {
+    name: "conditions",
+    regex: /^\s*(-)\s*(\d+|true|false|".*?"|'.*?'|`[\s\S]*?`|['"a-zA-Z$\.\-]*)\s*/, // Matches the leading dash and optional spaces
+    groups: [
+        {
+            tokenType: TokenType.Hyphen,
+            index: 1,
+        },
+    ],
+    next: [
+        {
+            name: "conditions",
+            regex: /^\s*(\d+|true|false|".*?"|'.*?'|`[\s\S]*?`|['"a-zA-Z$\.\-]*)\s*(==|!=|>=|<=|>|<)\s*(\d+|true|false|".*?"|'.*?'|`[\s\S]*?`|['"a-zA-Z$\.\-]*)\s*/,
+            groups: [
+                {
+                    tokenType: TokenType.Lhs,
+                    index: 1,
+                },
+                {
+                    tokenType: TokenType.Operator,
+                    index: 2,
+                },
+                {
+                    tokenType: TokenType.Rhs,
+                    index: 3,
+                },
+            ],
+            next: [
+                {
+                    name: "OR",
+                    regex: /\s*(OR)\s*/,
+                    groups: [],
+                    next: [
+                        {
+                            name: "conditionsOr",
+                            regex: /^\s*(OR)\s*(\d+|true|false|".*?"|'.*?'|`[\s\S]*?`|['"a-zA-Z$\.\-]*)\s*(==|!=|>=|<=|>|<)\s*(\d+|true|false|".*?"|'.*?'|`[\s\S]*?`|['"a-zA-Z$\.\-]*)\s*/,
+                            groups: [
+                                {
+                                    tokenType: TokenType.Or,
+                                    index: 1,
+                                },
+                                {
+                                    tokenType: TokenType.Lhs,
+                                    index: 2,
+                                },
+                                {
+                                    tokenType: TokenType.Operator,
+                                    index: 3,
+                                },
+                                {
+                                    tokenType: TokenType.Rhs,
+                                    index: 4,
+                                },
+                            ],
+                            moveNextLine: false,
+                        },
+                    ],
+                    loopUntil: /\s*(OR)\s*/,
+                    isMultiline: false,
+                },
+            ],
+        },
+    ],
+    // moveNextLine: true,
+    loopUntil: /^\s*(-)\s*(\d+|true|false|".*?"|'.*?'|`[\s\S]*?`|['"a-zA-Z$\.\-]*)\s*/,
+    isMultiline: false,
+};

package/dist/parser/tokenizer/reader/grammer/input.grammer.d.ts

@@ -0,0 +1,2 @@
+import { LexerGrammer } from "../lexer.types.js";
+export declare const inputGrammer: LexerGrammer;

package/dist/parser/tokenizer/reader/grammer/input.grammer.js

@@ -0,0 +1,17 @@
+import { TokenType } from "../../tokenType.js";
+export const inputGrammer = {
+    name: "input",
+    regex: /^\s*(Input)\s+(.+?)\s*$/,
+    groups: [
+        {
+            tokenType: TokenType.Input,
+            index: 1,
+        },
+        {
+            tokenType: TokenType.InputPath,
+            index: 2,
+        },
+    ],
+    isOptional: true,
+    isMultiline: false,
+};

package/dist/parser/tokenizer/reader/grammer/keyvalue.grammer.d.ts

@@ -0,0 +1,2 @@
+import { LexerGrammer } from "../lexer.types.js";
+export declare const keyValueGrammer: LexerGrammer;

package/dist/parser/tokenizer/reader/grammer/keyvalue.grammer.js

@@ -0,0 +1,240 @@
+import { TokenType } from "../../tokenType.js";
+export const keyValueGrammer = {
+    name: "keyValue",
+    regex: /^\s*(-)\s*['"a-zA-Z\-]*\s*:/, // Matches the leading dash and optional spaces
+    groups: [
+        {
+            tokenType: TokenType.Hyphen,
+            index: 1,
+        },
+    ],
+    next: [
+        {
+            name: "quotedKey",
+            regex: /^-\s*(['"`])(.*?)(\1)\s*(:)/, // Matches 'key' or "key" followed by colon
+            groups: [
+                {
+                    tokenType: TokenType.Quote,
+                    index: 1,
+                },
+                {
+                    tokenType: TokenType.Identifier,
+                    index: 2,
+                },
+                {
+                    tokenType: TokenType.Quote,
+                    index: 3,
+                },
+                {
+                    tokenType: TokenType.Colon,
+                    index: 4,
+                },
+            ],
+            next: [
+                {
+                    name: "value",
+                    regex: /(['"])(.*?)(\1)/,
+                    groups: [
+                        {
+                            tokenType: TokenType.Quote,
+                            index: 1,
+                        },
+                        {
+                            tokenType: TokenType.Scalar,
+                            index: 2,
+                        },
+                        {
+                            tokenType: TokenType.Quote,
+                            index: 3,
+                        },
+                    ],
+                    isOptional: true,
+                    next: [
+                        {
+                            name: "decrypt",
+                            regex: /^\s+(Decrypt)\s*$/,
+                            groups: [
+                                {
+                                    tokenType: TokenType.Decrypt,
+                                    index: 1,
+                                },
+                            ],
+                            isOptional: true,
+                        },
+                    ],
+                },
+                {
+                    name: "multilineValue",
+                    regex: /(`)([\s\S]*?)(`)/,
+                    isOptional: true,
+                    groups: [
+                        {
+                            tokenType: TokenType.Backtick,
+                            index: 1,
+                        },
+                        {
+                            tokenType: TokenType.Scalar,
+                            index: 2,
+                        },
+                        {
+                            tokenType: TokenType.Backtick,
+                            index: 3,
+                        },
+                    ],
+                    start: /(`)([\s\S]*?)/,
+                    end: /(`)([\s\S]*?)(`)/,
+                    mergeLines: true,
+                    next: [
+                        {
+                            name: "decrypt",
+                            regex: /^\s+(Decrypt)\s*$/,
+                            groups: [
+                                {
+                                    tokenType: TokenType.Decrypt,
+                                    index: 1,
+                                },
+                            ],
+                            isOptional: true,
+                        },
+                    ],
+                },
+                {
+                    name: "unquotedValue",
+                    regex: /(?<!['"])([a-zA-Z_.\-][a-zA-Z0-9_.\-]*)(?!['"])/,
+                    groups: [
+                        {
+                            tokenType: TokenType.Identifier,
+                            index: 1,
+                        },
+                    ],
+                    isOptional: true,
+                    next: [
+                        {
+                            name: "decrypt",
+                            regex: /^\s+(Decrypt)\s*$/,
+                            groups: [
+                                {
+                                    tokenType: TokenType.Decrypt,
+                                    index: 1,
+                                },
+                            ],
+                            isOptional: true,
+                        },
+                    ],
+                },
+            ],
+        },
+        {
+            name: "unquotedKey",
+            regex: /\s*([a-zA-Z_.\-][a-zA-Z0-9_.\-]*)\s*(:)/, // Matches name:
+            groups: [
+                {
+                    tokenType: TokenType.Identifier,
+                    index: 1,
+                },
+                {
+                    tokenType: TokenType.Colon,
+                    index: 2,
+                },
+            ],
+            next: [
+                {
+                    name: "value",
+                    regex: /(['"])(.*?)(\1)/,
+                    groups: [
+                        {
+                            tokenType: TokenType.Quote,
+                            index: 1,
+                        },
+                        {
+                            tokenType: TokenType.Scalar,
+                            index: 2,
+                        },
+                        {
+                            tokenType: TokenType.Quote,
+                            index: 3,
+                        },
+                    ],
+                    isOptional: true,
+                    next: [
+                        {
+                            name: "decrypt",
+                            regex: /^\s+(Decrypt)\s*$/,
+                            groups: [
+                                {
+                                    tokenType: TokenType.Decrypt,
+                                    index: 1,
+                                },
+                            ],
+                            isOptional: true,
+                        },
+                    ],
+                },
+                {
+                    name: "multilineValue",
+                    regex: /(`)([\s\S]*?)(`)/,
+                    isOptional: true,
+                    groups: [
+                        {
+                            tokenType: TokenType.Backtick,
+                            index: 1,
+                        },
+                        {
+                            tokenType: TokenType.Scalar,
+                            index: 2,
+                        },
+                        {
+                            tokenType: TokenType.Backtick,
+                            index: 3,
+                        },
+                    ],
+                    start: /(`)([\s\S]*?)/,
+                    end: /(`)([\s\S]*?)(`)/,
+                    mergeLines: true,
+                    next: [
+                        {
+                            name: "decrypt",
+                            regex: /^\s+(Decrypt)\s*$/,
+                            groups: [
+                                {
+                                    tokenType: TokenType.Decrypt,
+                                    index: 1,
+                                },
+                            ],
+                            isOptional: true,
+                        },
+                    ],
+                },
+                {
+                    name: "unquotedValue",
+                    regex: /\s*([a-zA-Z_\.\-][a-zA-Z0-9_\.\-]*)/,
+                    groups: [
+                        {
+                            tokenType: TokenType.Identifier,
+                            index: 1,
+                        },
+                    ],
+                    isOptional: true,
+                    next: [
+                        {
+                            name: "decrypt",
+                            regex: /^\s+(Decrypt)\s*$/,
+                            groups: [
+                                {
+                                    tokenType: TokenType.Decrypt,
+                                    index: 1,
+                                },
+                            ],
+                            isOptional: true,
+                        },
+                    ],
+                },
+            ],
+            isMultiline: false,
+            isOptional: true,
+        },
+    ],
+    loopUntil: /^\s*(-)\s*['"a-zA-Z\-]*\s*:/,
+    isMultiline: false,
+    moveNextLine: true,
+};

package/dist/parser/tokenizer/reader/grammer/link.grammer.d.ts

@@ -0,0 +1,2 @@
+import { LexerGrammer } from "../lexer.types.js";
+export declare const linkGrammer: LexerGrammer;

package/dist/parser/tokenizer/reader/grammer/link.grammer.js

@@ -0,0 +1,17 @@
+import { TokenType } from "../../tokenType.js";
+export const linkGrammer = {
+    name: "link",
+    regex: /^\s*(Link)\s+(.+?)\s*$/,
+    groups: [
+        {
+            tokenType: TokenType.Link,
+            index: 1,
+        },
+        {
+            tokenType: TokenType.LinkPath,
+            index: 2,
+        },
+    ],
+    isOptional: true,
+    isMultiline: false,
+};

package/dist/parser/tokenizer/reader/grammer/params.grammer.d.ts

@@ -0,0 +1,2 @@
+import { LexerGrammer } from "../lexer.types.js";
+export declare const paramsGrammer: LexerGrammer;

package/dist/parser/tokenizer/reader/grammer/params.grammer.js

@@ -0,0 +1,21 @@
+import { TokenType } from "../../tokenType.js";
+import { keyValueGrammer } from "./keyvalue.grammer.js";
+export const paramsGrammer = {
+    name: "Params",
+    regex: /^\s*(Params)/,
+    groups: [
+        {
+            tokenType: TokenType.Params,
+            index: 1,
+        },
+    ],
+    next: [
+        {
+            ...keyValueGrammer,
+            moveNextLine: true,
+        },
+    ],
+    isOptional: true,
+    isMultiline: false,
+    moveNextLine: true,
+};

package/dist/parser/tokenizer/reader/grammer/step.grammer.d.ts

@@ -0,0 +1,2 @@
+import { LexerGrammer } from "../lexer.types.js";
+export declare const stepGrammer: LexerGrammer;

package/dist/parser/tokenizer/reader/grammer/step.grammer.js

@@ -0,0 +1,25 @@
+import { TokenType } from "../../tokenType.js";
+export const stepGrammer = {
+    name: "step",
+    regex: /^\s*(Step)\s*(?:(Call))\s*(?:(Api))\s*(\w*|\W*)/,
+    groups: [
+        {
+            tokenType: TokenType.Step,
+            index: 1,
+        },
+        {
+            tokenType: TokenType.Call,
+            index: 2,
+        },
+        {
+            tokenType: TokenType.Api,
+            index: 3,
+        },
+        {
+            tokenType: TokenType.Identifier,
+            index: 4,
+        },
+    ],
+    isOptional: true,
+    isMultiline: false,
+};

package/dist/parser/tokenizer/reader/grammer/task.grammer.d.ts

@@ -0,0 +1,2 @@
+import { LexerGrammer } from "../lexer.types.js";
+export declare const taskGrammer: LexerGrammer;

package/dist/parser/tokenizer/reader/grammer/task.grammer.js

@@ -0,0 +1,17 @@
+import { TokenType } from "../../tokenType.js";
+export const taskGrammer = {
+    name: "task",
+    regex: /^\s*(Task)\s*(?:(.*))?$/,
+    groups: [
+        {
+            tokenType: TokenType.Task,
+            index: 1,
+        },
+        {
+            tokenType: TokenType.Title,
+            index: 2,
+        },
+    ],
+    isOptional: true,
+    isMultiline: false,
+};

package/dist/parser/tokenizer/reader/grammer/var.grammer.d.ts

@@ -0,0 +1,2 @@
+import { LexerGrammer } from "../lexer.types.js";
+export declare const varLexerGrammer: LexerGrammer[];

package/dist/parser/tokenizer/reader/grammer/var.grammer.js

@@ -0,0 +1,47 @@
+import { TokenType } from "../../tokenType.js";
+import { keyValueGrammer } from "./keyvalue.grammer.js";
+export const varLexerGrammer = [
+    {
+        name: "var",
+        regex: /^Var/,
+        groups: [
+            {
+                tokenType: TokenType.Var,
+            },
+        ],
+        next: [
+            {
+                name: "pointer",
+                regex: /(@)(\S+)\s+(.*)/,
+                isOptional: true,
+                groups: [
+                    {
+                        tokenType: TokenType.Pointer,
+                        index: 1,
+                    },
+                    {
+                        tokenType: TokenType.Pointed,
+                        index: 2,
+                    },
+                    {
+                        tokenType: TokenType.Title,
+                        index: 3,
+                    },
+                ],
+            },
+            {
+                name: "title",
+                regex: /\s+(.*)/,
+                groups: [
+                    {
+                        tokenType: TokenType.Title,
+                        index: 0,
+                    },
+                ],
+                isOptional: true,
+            },
+            { ...keyValueGrammer, ...{ moveNextLine: true } },
+        ],
+        isMultiline: false,
+    },
+];

package/dist/parser/tokenizer/reader/lexer.engine.d.ts

@@ -0,0 +1,43 @@
+import { Token } from "../token.js";
+export declare class LexerError extends Error {
+    readonly line: number;
+    readonly column: number;
+    constructor(message: string, line: number, column: number);
+}
+export declare class LexerEngine {
+    private input;
+    private tokens;
+    private lines;
+    private lineIndex;
+    private columnIndex;
+    private currentLine;
+    private at;
+    private next;
+    private prev;
+    constructor(input: string);
+    /**
+     * Processes a grammar rule against the given line and updates tokens.
+     * Optimized for readability and performance.
+     */
+    private processGrammer;
+    /**
+     * Merges lines until the grammar's end pattern is matched or lines run out.
+     */
+    private mergeLinesUntilEnd;
+    /**
+     * Processes the groups in the grammar and generates tokens.
+     */
+    private processGroups;
+    /**
+     * Processes any next grammar rules chained to the current grammar.
+     */
+    private processNextGrammars;
+    /**
+     * Handles looping a grammar until a condition is met.
+     */
+    private processLoopUntil;
+    /**
+     * Tokenizes the input string into tokens using the defined grammar list.
+     */
+    tokenize(): Token[];
+}