@promptbook/core 0.44.0-1 → 0.44.0-10

package/umd/index.umd.js

@@ -1,8 +1,8 @@
 (function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('spacetrim'), require('prettier'), require('prettier/parser-html'), require('moment')) :
-    typeof define === 'function' && define.amd ? define(['exports', 'spacetrim', 'prettier', 'prettier/parser-html', 'moment'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["promptbook-core"] = {}, global.spaceTrim));
-})(this, (function (exports, spaceTrim) { 'use strict';
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('spacetrim'), require('prettier'), require('prettier/parser-html'), require('moment'), require('lorem-ipsum')) :
+    typeof define === 'function' && define.amd ? define(['exports', 'spacetrim', 'prettier', 'prettier/parser-html', 'moment', 'lorem-ipsum'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["promptbook-core"] = {}, global.spaceTrim, null, null, null, global.loremIpsum));
+})(this, (function (exports, spaceTrim, prettier, parserHtml, moment, loremIpsum) { 'use strict';
 
     function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -127,85 +127,6 @@
         return to.concat(ar || Array.prototype.slice.call(from));
     }
 
-    /**
-     * This error indicates that the promptbook in a markdown format cannot be parsed into a valid promptbook object
-     */
-    var PromptbookSyntaxError = /** @class */ (function (_super) {
-        __extends(PromptbookSyntaxError, _super);
-        function PromptbookSyntaxError(message) {
-            var _this = _super.call(this, message) || this;
-            _this.name = 'PromptbookSyntaxError';
-            Object.setPrototypeOf(_this, PromptbookSyntaxError.prototype);
-            return _this;
-        }
-        return PromptbookSyntaxError;
-    }(Error));
-
-    /**
-     * Supported script languages
-     */
-    var SUPPORTED_SCRIPT_LANGUAGES = ['javascript', 'typescript', 'python'];
-
-    /**
-     * Parses the template and returns the list of all parameter names
-     *
-     * @param template the template with parameters in {curly} braces
-     * @returns the list of parameter names
-     *
-     * @private within the library
-     */
-    function extractParameters(template) {
-        var e_1, _a;
-        var matches = template.matchAll(/{\w+}/g);
-        var parameterNames = [];
-        try {
-            for (var matches_1 = __values(matches), matches_1_1 = matches_1.next(); !matches_1_1.done; matches_1_1 = matches_1.next()) {
-                var match = matches_1_1.value;
-                var parameterName = match[0].slice(1, -1);
-                if (!parameterNames.includes(parameterName)) {
-                    parameterNames.push(parameterName);
-                }
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (matches_1_1 && !matches_1_1.done && (_a = matches_1.return)) _a.call(matches_1);
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
-        return parameterNames;
-    }
-
-    /**
-     * Computes the deepness of the markdown structure.
-     *
-     * @private within the library
-     */
-    function countMarkdownStructureDeepness(markdownStructure) {
-        var e_1, _a;
-        var maxDeepness = 0;
-        try {
-            for (var _b = __values(markdownStructure.sections), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var section = _c.value;
-                maxDeepness = Math.max(maxDeepness, countMarkdownStructureDeepness(section));
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
-        return maxDeepness + 1;
-    }
-
-    /**
-     * The maximum number of iterations for a loops
-     */
-    var LOOP_LIMIT = 1000;
-
     /**
      * This error type indicates that the error should not happen and its last check before crashing with some other error
      */
@@ -220,218 +141,6 @@
         return UnexpectedError;
     }(Error));
 
-    /**
-     * Parse a markdown string into a MarkdownStructure object.
-     *
-     * Note: This function does work with code blocks
-     * Note: This function does not work with markdown comments
-     *
-     * @param markdown The markdown string to parse.
-     * @returns The MarkdownStructure object.
-     *
-     * @private within the library
-     */
-    function markdownToMarkdownStructure(markdown) {
-        var e_1, _a;
-        var lines = markdown.split('\n');
-        var root = { level: 0, title: '', contentLines: [], sections: [], parent: null };
-        var current = root;
-        var isInsideCodeBlock = false;
-        try {
-            for (var lines_1 = __values(lines), lines_1_1 = lines_1.next(); !lines_1_1.done; lines_1_1 = lines_1.next()) {
-                var line = lines_1_1.value;
-                var headingMatch = line.match(/^(?<mark>#{1,6})\s(?<title>.*)/);
-                if (isInsideCodeBlock || !headingMatch) {
-                    if (line.startsWith('```')) {
-                        isInsideCodeBlock = !isInsideCodeBlock;
-                    }
-                    current.contentLines.push(line);
-                }
-                else {
-                    var level = headingMatch.groups.mark.length;
-                    var title = headingMatch.groups.title.trim();
-                    var parent_1 = void 0;
-                    if (level > current.level) {
-                        // Note: Going deeper (next section is child of current)
-                        parent_1 = current;
-                    }
-                    else {
-                        // Note: Going up or staying at the same level (next section is sibling or parent or grandparent,... of current)
-                        parent_1 = current;
-                        var loopLimit = LOOP_LIMIT;
-                        while (parent_1.level !== level - 1) {
-                            if (loopLimit-- < 0) {
-                                throw new UnexpectedError('Loop limit reached during parsing of markdown structure in `markdownToMarkdownStructure`');
-                            }
-                            if (parent_1.parent === null /* <- Note: We are in root */) {
-                                // [🌻]
-                                throw new Error(spaceTrim__default["default"]("\n                                The file has an invalid structure.\n                                The markdown file must have exactly one top-level section.\n                            "));
-                            }
-                            parent_1 = parent_1.parent;
-                        }
-                    }
-                    var section = { level: level, title: title, contentLines: [], sections: [], parent: parent_1 };
-                    parent_1.sections.push(section);
-                    current = section;
-                }
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (lines_1_1 && !lines_1_1.done && (_a = lines_1.return)) _a.call(lines_1);
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
-        if (root.sections.length === 1) {
-            var markdownStructure = parsingMarkdownStructureToMarkdownStructure(root.sections[0]);
-            return markdownStructure;
-        }
-        // [🌻]
-        throw new Error('The markdown file must have exactly one top-level section.');
-        // return root;
-    }
-    /**
-     * @private
-     */
-    function parsingMarkdownStructureToMarkdownStructure(parsingMarkdownStructure) {
-        var level = parsingMarkdownStructure.level, title = parsingMarkdownStructure.title, contentLines = parsingMarkdownStructure.contentLines, sections = parsingMarkdownStructure.sections;
-        return {
-            level: level,
-            title: title,
-            content: spaceTrim__default["default"](contentLines.join('\n')),
-            sections: sections.map(parsingMarkdownStructureToMarkdownStructure),
-        };
-    }
-
-    /**
-     * Utility function to extract all list items from markdown
-     *
-     * Note: It works with both ul and ol
-     * Note: It omits list items in code blocks
-     * Note: It flattens nested lists
-     * Note: It can not work with html syntax and comments
-     *
-     * @param markdown any valid markdown
-     * @returns
-     */
-    function extractAllListItemsFromMarkdown(markdown) {
-        var e_1, _a;
-        var lines = markdown.split('\n');
-        var listItems = [];
-        var isInCodeBlock = false;
-        try {
-            for (var lines_1 = __values(lines), lines_1_1 = lines_1.next(); !lines_1_1.done; lines_1_1 = lines_1.next()) {
-                var line = lines_1_1.value;
-                var trimmedLine = line.trim();
-                if (trimmedLine.startsWith('```')) {
-                    isInCodeBlock = !isInCodeBlock;
-                }
-                if (!isInCodeBlock && (trimmedLine.startsWith('-') || trimmedLine.match(/^\d+\./))) {
-                    var listItem = trimmedLine.replace(/^-|\d+\./, '').trim();
-                    listItems.push(listItem);
-                }
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (lines_1_1 && !lines_1_1.done && (_a = lines_1.return)) _a.call(lines_1);
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
-        return listItems;
-    }
-
-    /**
-     * Makes first letter of a string uppercase
-     *
-     */
-    function capitalize(word) {
-        return word.substring(0, 1).toUpperCase() + word.substring(1);
-    }
-
-    /**
-     * Extracts all code blocks from markdown.
-     *
-     * Note: There are 3 simmilar function:
-     * - `extractBlock` just extracts the content of the code block which is also used as build-in function for postprocessing
-     * - `extractOneBlockFromMarkdown` extracts exactly one code block with language of the code block
-     * - `extractAllBlocksFromMarkdown` extracts all code blocks with language of the code block
-     *
-     * @param markdown any valid markdown
-     * @returns code blocks with language and content
-     *
-     */
-    function extractAllBlocksFromMarkdown(markdown) {
-        var e_1, _a;
-        var codeBlocks = [];
-        var lines = markdown.split('\n');
-        var currentCodeBlock = null;
-        try {
-            for (var lines_1 = __values(lines), lines_1_1 = lines_1.next(); !lines_1_1.done; lines_1_1 = lines_1.next()) {
-                var line = lines_1_1.value;
-                if (line.startsWith('```')) {
-                    var language = line.slice(3).trim() || null;
-                    if (currentCodeBlock === null) {
-                        currentCodeBlock = { language: language, content: '' };
-                    }
-                    else {
-                        if (language !== null) {
-                            // [🌻]
-                            throw new Error("".concat(capitalize(currentCodeBlock.language || 'the'), " code block was not closed and already opening new ").concat(language, " code block"));
-                        }
-                        codeBlocks.push(currentCodeBlock);
-                        currentCodeBlock = null;
-                    }
-                }
-                else if (currentCodeBlock !== null) {
-                    if (currentCodeBlock.content !== '') {
-                        currentCodeBlock.content += '\n';
-                    }
-                    currentCodeBlock.content += line.split('\\`\\`\\`').join('```') /* <- TODO: Maybe make propper unescape */;
-                }
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (lines_1_1 && !lines_1_1.done && (_a = lines_1.return)) _a.call(lines_1);
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
-        if (currentCodeBlock !== null) {
-            // [🌻]
-            throw new Error("".concat(capitalize(currentCodeBlock.language || 'the'), " code block was not closed at the end of the markdown"));
-        }
-        return codeBlocks;
-    }
-
-    /**
-     * Extracts exactly ONE code block from markdown.
-     *
-     * Note: If there are multiple or no code blocks the function throws an error
-     *
-     * Note: There are 3 simmilar function:
-     * - `extractBlock` just extracts the content of the code block which is also used as build-in function for postprocessing
-     * - `extractOneBlockFromMarkdown` extracts exactly one code block with language of the code block
-     * - `extractAllBlocksFromMarkdown` extracts all code blocks with language of the code block
-     *
-     * @param markdown any valid markdown
-     * @returns code block with language and content
-     */
-    function extractOneBlockFromMarkdown(markdown) {
-        var codeBlocks = extractAllBlocksFromMarkdown(markdown);
-        if (codeBlocks.length !== 1) {
-            // TODO: Report more specific place where the error happened
-            throw new Error(/* <- [🌻] */ 'There should be exactly one code block in the markdown');
-        }
-        return codeBlocks[0];
-    }
-    /***
-     * TODO: [🌻] !!! Decide of this is internal util, external util OR validator/postprocessor
-     */
-
     /**
      * Removes HTML or Markdown comments from a string.
      *
@@ -443,94 +152,18 @@
     }
 
     /**
-     * The version of the Promptbook library
-     */
-    var PROMPTBOOK_VERSION = '0.44.0-0';
-
-    /**
-     * Parses the given script and returns the list of all used variables that are not defined in the script
-     *
-     * @param script from which to extract the variables
-     * @returns the list of variable names
-     * @throws {PromptbookSyntaxError} if the script is invalid
-     *
-     * @private within the promptbookStringToJson
+     * This error indicates that the promptbook in a markdown format cannot be parsed into a valid promptbook object
      */
-    function extractVariables(script) {
-        var variables = [];
-        script = "(()=>{".concat(script, "})()");
-        try {
-            for (var i = 0; i < 100 /* <- TODO: This limit to configuration */; i++)
-                try {
-                    eval(script);
-                }
-                catch (error) {
-                    if (!(error instanceof ReferenceError)) {
-                        throw error;
-                    }
-                    var undefinedName = error.message.split(' ')[0];
-                    /*
-                    Note: Remapping error
-                          From: [ReferenceError: thing is not defined],
-                          To:   [Error: Parameter {thing} is not defined],
-                    */
-                    if (!undefinedName) {
-                        throw error;
-                    }
-                    if (script.includes(undefinedName + '(')) {
-                        script = "const ".concat(undefinedName, " = ()=>'';") + script;
-                    }
-                    else {
-                        variables.push(undefinedName);
-                        script = "const ".concat(undefinedName, " = '';") + script;
-                    }
-                }
-        }
-        catch (error) {
-            if (!(error instanceof Error)) {
-                throw error;
-            }
-            throw new PromptbookSyntaxError(spaceTrim__default["default"](function (block) { return "\n                    Can not extract variables from the script\n\n                    ".concat(block(error.name), ": ").concat(block(error.message), "\n                "); }));
+    var PromptbookSyntaxError = /** @class */ (function (_super) {
+        __extends(PromptbookSyntaxError, _super);
+        function PromptbookSyntaxError(message) {
+            var _this = _super.call(this, message) || this;
+            _this.name = 'PromptbookSyntaxError';
+            Object.setPrototypeOf(_this, PromptbookSyntaxError.prototype);
+            return _this;
         }
-        return variables;
-    }
-
-    /**
-     * Execution type describes the way how the block is executed
-     *
-     * @see https://github.com/webgptorg/promptbook#execution-type
-     */
-    var ExecutionTypes = [
-        'PROMPT_TEMPLATE',
-        'SIMPLE_TEMPLATE',
-        'SCRIPT',
-        'PROMPT_DIALOG',
-        // <- [🥻] Insert here when making new command
-    ];
-
-    /**
-     * Units of text measurement
-     */
-    var EXPECTATION_UNITS = ['CHARACTERS', 'WORDS', 'SENTENCES', 'PARAGRAPHS', 'LINES', 'PAGES'];
-    /**
-     * TODO: use one helper type> (string_prompt | string_javascript | string_markdown) & string_template
-     */
-
-    /**
-     * Removes Markdown formatting tags from a string.
-     *
-     * @param {string} str - The string to remove Markdown tags from.
-     * @returns {string} The input string with all Markdown tags removed.
-     */
-    function removeMarkdownFormatting(str) {
-        // Remove bold formatting
-        str = str.replace(/\*\*(.*?)\*\*/g, '$1');
-        // Remove italic formatting
-        str = str.replace(/\*(.*?)\*/g, '$1');
-        // Remove code formatting
-        str = str.replace(/`(.*?)`/g, '$1');
-        return str;
-    }
+        return PromptbookSyntaxError;
+    }(Error));
 
     /**
      * Function parseNumber will parse number from string
@@ -591,103 +224,44 @@
         }
         var num = parseFloat(value);
         if (isNaN(num)) {
-            throw new PromptbookSyntaxError("Unexpected NaN when parsing number from \"".concat(originalValue, "\""));
-        }
-        return num;
-    }
-    /**
-     * TODO: Maybe use sth. like safe-eval in fraction/calculation case @see https://www.npmjs.com/package/safe-eval
-     */
-
-    /**
-     * This error indicates errors during the execution of the promptbook
-     */
-    var PromptbookExecutionError = /** @class */ (function (_super) {
-        __extends(PromptbookExecutionError, _super);
-        function PromptbookExecutionError(message) {
-            var _this = _super.call(this, message) || this;
-            _this.name = 'PromptbookExecutionError';
-            Object.setPrototypeOf(_this, PromptbookExecutionError.prototype);
-            return _this;
-        }
-        return PromptbookExecutionError;
-    }(Error));
-
-    /**
-     * This error occurs during the parameter replacement in the template
-     *
-     * Note: This is a kindof subtype of PromptbookExecutionError because it occurs during the execution of the pipeline
-     */
-    var TemplateError = /** @class */ (function (_super) {
-        __extends(TemplateError, _super);
-        function TemplateError(message) {
-            var _this = _super.call(this, message) || this;
-            _this.name = 'TemplateError';
-            Object.setPrototypeOf(_this, TemplateError.prototype);
-            return _this;
-        }
-        return TemplateError;
-    }(Error));
-
-    /**
-     * Replaces parameters in template with values from parameters object
-     *
-     * @param template the template with parameters in {curly} braces
-     * @param parameters the object with parameters
-     * @returns the template with replaced parameters
-     * @throws {TemplateError} if parameter is not defined, not closed, or not opened
-     *
-     * @private within the createPromptbookExecutor
-     */
-    function replaceParameters(template, parameters) {
-        var replacedTemplate = template;
-        var match;
-        var loopLimit = LOOP_LIMIT;
-        var _loop_1 = function () {
-            if (loopLimit-- < 0) {
-                throw new UnexpectedError('Loop limit reached during parameters replacement in `replaceParameters`');
-            }
-            var precol = match.groups.precol;
-            var parameterName = match.groups.parameterName;
-            if (parameterName === '') {
-                return "continue";
-            }
-            if (parameterName.indexOf('{') !== -1 || parameterName.indexOf('}') !== -1) {
-                throw new TemplateError('Parameter is already opened or not closed');
-            }
-            if (parameters[parameterName] === undefined) {
-                throw new TemplateError("Parameter {".concat(parameterName, "} is not defined"));
-            }
-            var parameterValue = parameters[parameterName];
-            if (parameterValue === undefined) {
-                throw new TemplateError("Parameter {".concat(parameterName, "} is not defined"));
-            }
-            parameterValue = parameterValue.toString();
-            if (parameterValue.includes('\n') && /^\s*\W{0,3}\s*$/.test(precol)) {
-                parameterValue = parameterValue
-                    .split('\n')
-                    .map(function (line, index) { return (index === 0 ? line : "".concat(precol).concat(line)); })
-                    .join('\n');
-            }
-            replacedTemplate =
-                replacedTemplate.substring(0, match.index + precol.length) +
-                    parameterValue +
-                    replacedTemplate.substring(match.index + precol.length + parameterName.length + 2);
-        };
-        while ((match = /^(?<precol>.*){(?<parameterName>\w+)}(.*)/m /* <- Not global */
-            .exec(replacedTemplate))) {
-            _loop_1();
-        }
-        // [💫] Check if there are parameters that are not closed properly
-        if (/{\w+$/.test(replacedTemplate)) {
-            throw new TemplateError('Parameter is not closed');
-        }
-        // [💫] Check if there are parameters that are not opened properly
-        if (/^\w+}/.test(replacedTemplate)) {
-            throw new TemplateError('Parameter is not opened');
+            throw new PromptbookSyntaxError("Unexpected NaN when parsing number from \"".concat(originalValue, "\""));
         }
-        return replacedTemplate;
+        return num;
     }
+    /**
+     * TODO: Maybe use sth. like safe-eval in fraction/calculation case @see https://www.npmjs.com/package/safe-eval
+     */
+
+    /**
+     * This error indicates errors during the execution of the promptbook
+     */
+    var PromptbookExecutionError = /** @class */ (function (_super) {
+        __extends(PromptbookExecutionError, _super);
+        function PromptbookExecutionError(message) {
+            var _this = _super.call(this, message) || this;
+            _this.name = 'PromptbookExecutionError';
+            Object.setPrototypeOf(_this, PromptbookExecutionError.prototype);
+            return _this;
+        }
+        return PromptbookExecutionError;
+    }(Error));
+
+    /**
+     * This error occurs when some expectation is not met in the execution of the pipeline
+     *
+     * @private Always catched and rethrown as `PromptbookExecutionError`
+     * Note: This is a kindof subtype of PromptbookExecutionError
+     */
+    var ExpectError = /** @class */ (function (_super) {
+        __extends(ExpectError, _super);
+        function ExpectError(message) {
+            var _this = _super.call(this, message) || this;
+            _this.name = 'ExpectError';
+            Object.setPrototypeOf(_this, ExpectError.prototype);
+            return _this;
+        }
+        return ExpectError;
+    }(Error));
 
     /**
      * Counts number of characters in the text
@@ -969,70 +543,356 @@
                 defaultDiacriticsRemovalMap[i].base;
         }
     }
-    // <- TODO: !!!! Put to maker function
-    /*
-      @see https://stackoverflow.com/questions/990904/remove-accents-diacritics-in-a-string-in-javascript
-       Licensed under the Apache License, Version 2.0 (the "License");
-       you may not use this file except in compliance with the License.
-       You may obtain a copy of the License at
-
-           http://www.apache.org/licenses/LICENSE-2.0
-
-       Unless required by applicable law or agreed to in writing, software
-       distributed under the License is distributed on an "AS IS" BASIS,
-       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-       See the License for the specific language governing permissions and
-       limitations under the License.
-    */
+    // <- TODO: !!!! Put to maker function
+    /*
+      @see https://stackoverflow.com/questions/990904/remove-accents-diacritics-in-a-string-in-javascript
+       Licensed under the Apache License, Version 2.0 (the "License");
+       you may not use this file except in compliance with the License.
+       You may obtain a copy of the License at
+
+           http://www.apache.org/licenses/LICENSE-2.0
+
+       Unless required by applicable law or agreed to in writing, software
+       distributed under the License is distributed on an "AS IS" BASIS,
+       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+       See the License for the specific language governing permissions and
+       limitations under the License.
+    */
+
+    /**
+     *
+     */
+    function removeDiacritics(input) {
+        /*eslint no-control-regex: "off"*/
+        return input.replace(/[^\u0000-\u007E]/g, function (a) {
+            return DIACRITIC_VARIANTS_LETTERS[a] || a;
+        });
+    }
+
+    /**
+     * Counts number of words in the text
+     */
+    function countWords(text) {
+        text = text.replace(/[\p{Extended_Pictographic}]/gu, 'a');
+        text = removeDiacritics(text);
+        return text.split(/[^a-zа-я0-9]+/i).filter(function (word) { return word.length > 0; }).length;
+    }
+
+    /**
+     * Index of all counter functions
+     */
+    var CountUtils = {
+        CHARACTERS: countCharacters,
+        WORDS: countWords,
+        SENTENCES: countSentences,
+        PARAGRAPHS: countParagraphs,
+        LINES: countLines,
+        PAGES: countPages,
+    };
+
+    /**
+     * Function checkExpectations will check if the expectations on given value are met
+     *
+     * Note: There are two simmilar functions:
+     * - `checkExpectations` which throws an error if the expectations are not met
+     * - `isPassingExpectations` which returns a boolean
+     *
+     * @throws {ExpectError} if the expectations are not met
+     * @returns {void} Nothing
+     */
+    function checkExpectations(expectations, value) {
+        var e_1, _a;
+        try {
+            for (var _b = __values(Object.entries(expectations)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var _d = __read(_c.value, 2), unit = _d[0], _e = _d[1], max = _e.max, min = _e.min;
+                var amount = CountUtils[unit.toUpperCase()](value);
+                if (min && amount < min) {
+                    throw new ExpectError("Expected at least ".concat(min, " ").concat(unit, " but got ").concat(amount));
+                } /* not else */
+                if (max && amount > max) {
+                    throw new ExpectError("Expected at most ".concat(max, " ").concat(unit, " but got ").concat(amount));
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+    }
+    /**
+     * Function checkExpectations will check if the expectations on given value are met
+     *
+     * Note: There are two simmilar functions:
+     * - `checkExpectations` which throws an error if the expectations are not met
+     * - `isPassingExpectations` which returns a boolean
+     *
+     * @returns {boolean} True if the expectations are met
+     */
+    function isPassingExpectations(expectations, value) {
+        try {
+            checkExpectations(expectations, value);
+            return true;
+        }
+        catch (error) {
+            if (!(error instanceof ExpectError)) {
+                throw error;
+            }
+            return false;
+        }
+    }
+    /**
+     * TODO: [💝] Unite object for expecting amount and format
+     */
+
+    /**
+     * The maximum number of iterations for a loops
+     */
+    var LOOP_LIMIT = 1000;
+    /**
+     * The maximum number of iterations for a loops which adds characters one by one
+     */
+    var CHARACTER_LOOP_LIMIT = 100000;
+
+    /**
+     * This error occurs during the parameter replacement in the template
+     *
+     * Note: This is a kindof subtype of PromptbookExecutionError because it occurs during the execution of the pipeline
+     */
+    var TemplateError = /** @class */ (function (_super) {
+        __extends(TemplateError, _super);
+        function TemplateError(message) {
+            var _this = _super.call(this, message) || this;
+            _this.name = 'TemplateError';
+            Object.setPrototypeOf(_this, TemplateError.prototype);
+            return _this;
+        }
+        return TemplateError;
+    }(Error));
+
+    /**
+     * Replaces parameters in template with values from parameters object
+     *
+     * @param template the template with parameters in {curly} braces
+     * @param parameters the object with parameters
+     * @returns the template with replaced parameters
+     * @throws {TemplateError} if parameter is not defined, not closed, or not opened
+     *
+     * @private within the createPromptbookExecutor
+     */
+    function replaceParameters(template, parameters) {
+        var replacedTemplate = template;
+        var match;
+        var loopLimit = LOOP_LIMIT;
+        var _loop_1 = function () {
+            if (loopLimit-- < 0) {
+                throw new UnexpectedError('Loop limit reached during parameters replacement in `replaceParameters`');
+            }
+            var precol = match.groups.precol;
+            var parameterName = match.groups.parameterName;
+            if (parameterName === '') {
+                return "continue";
+            }
+            if (parameterName.indexOf('{') !== -1 || parameterName.indexOf('}') !== -1) {
+                throw new TemplateError('Parameter is already opened or not closed');
+            }
+            if (parameters[parameterName] === undefined) {
+                throw new TemplateError("Parameter {".concat(parameterName, "} is not defined"));
+            }
+            var parameterValue = parameters[parameterName];
+            if (parameterValue === undefined) {
+                throw new TemplateError("Parameter {".concat(parameterName, "} is not defined"));
+            }
+            parameterValue = parameterValue.toString();
+            if (parameterValue.includes('\n') && /^\s*\W{0,3}\s*$/.test(precol)) {
+                parameterValue = parameterValue
+                    .split('\n')
+                    .map(function (line, index) { return (index === 0 ? line : "".concat(precol).concat(line)); })
+                    .join('\n');
+            }
+            replacedTemplate =
+                replacedTemplate.substring(0, match.index + precol.length) +
+                    parameterValue +
+                    replacedTemplate.substring(match.index + precol.length + parameterName.length + 2);
+        };
+        while ((match = /^(?<precol>.*){(?<parameterName>\w+)}(.*)/m /* <- Not global */
+            .exec(replacedTemplate))) {
+            _loop_1();
+        }
+        // [💫] Check if there are parameters that are not closed properly
+        if (/{\w+$/.test(replacedTemplate)) {
+            throw new TemplateError('Parameter is not closed');
+        }
+        // [💫] Check if there are parameters that are not opened properly
+        if (/^\w+}/.test(replacedTemplate)) {
+            throw new TemplateError('Parameter is not opened');
+        }
+        return replacedTemplate;
+    }
+
+    /**
+     * Function isValidJsonString will tell you if the string is valid JSON or not
+     */
+    function isValidJsonString(value) {
+        try {
+            JSON.parse(value);
+            return true;
+        }
+        catch (error) {
+            if (!(error instanceof Error)) {
+                throw error;
+            }
+            if (error.message.includes('Unexpected token')) {
+                return false;
+            }
+            return false;
+        }
+    }
+
+    /**
+     * Makes first letter of a string uppercase
+     *
+     */
+    function capitalize(word) {
+        return word.substring(0, 1).toUpperCase() + word.substring(1);
+    }
+
+    /**
+     * Extracts all code blocks from markdown.
+     *
+     * Note: There are 3 simmilar function:
+     * - `extractBlock` just extracts the content of the code block which is also used as build-in function for postprocessing
+     * - `extractOneBlockFromMarkdown` extracts exactly one code block with language of the code block
+     * - `extractAllBlocksFromMarkdown` extracts all code blocks with language of the code block
+     *
+     * @param markdown any valid markdown
+     * @returns code blocks with language and content
+     *
+     */
+    function extractAllBlocksFromMarkdown(markdown) {
+        var e_1, _a;
+        var codeBlocks = [];
+        var lines = markdown.split('\n');
+        var currentCodeBlock = null;
+        try {
+            for (var lines_1 = __values(lines), lines_1_1 = lines_1.next(); !lines_1_1.done; lines_1_1 = lines_1.next()) {
+                var line = lines_1_1.value;
+                if (line.startsWith('```')) {
+                    var language = line.slice(3).trim() || null;
+                    if (currentCodeBlock === null) {
+                        currentCodeBlock = { language: language, content: '' };
+                    }
+                    else {
+                        if (language !== null) {
+                            // [🌻]
+                            throw new Error("".concat(capitalize(currentCodeBlock.language || 'the'), " code block was not closed and already opening new ").concat(language, " code block"));
+                        }
+                        codeBlocks.push(currentCodeBlock);
+                        currentCodeBlock = null;
+                    }
+                }
+                else if (currentCodeBlock !== null) {
+                    if (currentCodeBlock.content !== '') {
+                        currentCodeBlock.content += '\n';
+                    }
+                    currentCodeBlock.content += line.split('\\`\\`\\`').join('```') /* <- TODO: Maybe make propper unescape */;
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (lines_1_1 && !lines_1_1.done && (_a = lines_1.return)) _a.call(lines_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        if (currentCodeBlock !== null) {
+            // [🌻]
+            throw new Error("".concat(capitalize(currentCodeBlock.language || 'the'), " code block was not closed at the end of the markdown"));
+        }
+        return codeBlocks;
+    }
 
     /**
+     * Utility function to extract all list items from markdown
+     *
+     * Note: It works with both ul and ol
+     * Note: It omits list items in code blocks
+     * Note: It flattens nested lists
+     * Note: It can not work with html syntax and comments
      *
+     * @param markdown any valid markdown
+     * @returns
      */
-    function removeDiacritics(input) {
-        /*eslint no-control-regex: "off"*/
-        return input.replace(/[^\u0000-\u007E]/g, function (a) {
-            return DIACRITIC_VARIANTS_LETTERS[a] || a;
-        });
+    function extractAllListItemsFromMarkdown(markdown) {
+        var e_1, _a;
+        var lines = markdown.split('\n');
+        var listItems = [];
+        var isInCodeBlock = false;
+        try {
+            for (var lines_1 = __values(lines), lines_1_1 = lines_1.next(); !lines_1_1.done; lines_1_1 = lines_1.next()) {
+                var line = lines_1_1.value;
+                var trimmedLine = line.trim();
+                if (trimmedLine.startsWith('```')) {
+                    isInCodeBlock = !isInCodeBlock;
+                }
+                if (!isInCodeBlock && (trimmedLine.startsWith('-') || trimmedLine.match(/^\d+\./))) {
+                    var listItem = trimmedLine.replace(/^-|\d+\./, '').trim();
+                    listItems.push(listItem);
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (lines_1_1 && !lines_1_1.done && (_a = lines_1.return)) _a.call(lines_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return listItems;
     }
 
     /**
-     * Counts number of words in the text
+     * Extracts exactly ONE code block from markdown.
+     *
+     * Note: If there are multiple or no code blocks the function throws an error
+     *
+     * Note: There are 3 simmilar function:
+     * - `extractBlock` just extracts the content of the code block which is also used as build-in function for postprocessing
+     * - `extractOneBlockFromMarkdown` extracts exactly one code block with language of the code block
+     * - `extractAllBlocksFromMarkdown` extracts all code blocks with language of the code block
+     *
+     * @param markdown any valid markdown
+     * @returns code block with language and content
      */
-    function countWords(text) {
-        text = text.replace(/[\p{Extended_Pictographic}]/gu, 'a');
-        text = removeDiacritics(text);
-        return text.split(/[^a-zа-я0-9]+/i).filter(function (word) { return word.length > 0; }).length;
+    function extractOneBlockFromMarkdown(markdown) {
+        var codeBlocks = extractAllBlocksFromMarkdown(markdown);
+        if (codeBlocks.length !== 1) {
+            // TODO: Report more specific place where the error happened
+            throw new Error(/* <- [🌻] */ 'There should be exactly one code block in the markdown');
+        }
+        return codeBlocks[0];
     }
-
-    /**
-     * Index of all counter functions
+    /***
+     * TODO: [🌻] !!! Decide of this is internal util, external util OR validator/postprocessor
      */
-    var CountUtils = {
-        CHARACTERS: countCharacters,
-        WORDS: countWords,
-        SENTENCES: countSentences,
-        PARAGRAPHS: countParagraphs,
-        LINES: countLines,
-        PAGES: countPages,
-    };
 
     /**
-     * Function isValidJsonString will tell you if the string is valid JSON or not
+     * Removes Markdown formatting tags from a string.
+     *
+     * @param {string} str - The string to remove Markdown tags from.
+     * @returns {string} The input string with all Markdown tags removed.
      */
-    function isValidJsonString(value) {
-        try {
-            JSON.parse(value);
-            return true;
-        }
-        catch (error) {
-            if (!(error instanceof Error)) {
-                throw error;
-            }
-            if (error.message.includes('Unexpected token')) {
-                return false;
-            }
-            return false;
-        }
+    function removeMarkdownFormatting(str) {
+        // Remove bold formatting
+        str = str.replace(/\*\*(.*?)\*\*/g, '$1');
+        // Remove italic formatting
+        str = str.replace(/\*(.*?)\*/g, '$1');
+        // Remove code formatting
+        str = str.replace(/`(.*?)`/g, '$1');
+        return str;
     }
 
     /* tslint:disable */
@@ -1085,79 +945,298 @@
         catch (e_1_1) { e_1 = { error: e_1_1 }; }
         finally {
             try {
-                if (sentence_1_1 && !sentence_1_1.done && (_a = sentence_1.return)) _a.call(sentence_1);
+                if (sentence_1_1 && !sentence_1_1.done && (_a = sentence_1.return)) _a.call(sentence_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        normalizedName = normalizedName.replace(/_+/g, '_');
+        normalizedName = normalizedName.replace(/_?\/_?/g, '/');
+        normalizedName = normalizedName.replace(/^_/, '');
+        normalizedName = normalizedName.replace(/_$/, '');
+        return normalizedName;
+    }
+    /**
+     * TODO: [🌺] Use some intermediate util splitWords
+     */
+
+    /* tslint:disable */
+    function normalizeTo_camelCase(sentence, __firstLetterCapital) {
+        var e_1, _a;
+        if (__firstLetterCapital === void 0) { __firstLetterCapital = false; }
+        var charType;
+        var lastCharType = null;
+        var normalizedName = '';
+        try {
+            for (var sentence_1 = __values(sentence), sentence_1_1 = sentence_1.next(); !sentence_1_1.done; sentence_1_1 = sentence_1.next()) {
+                var char = sentence_1_1.value;
+                var normalizedChar = void 0;
+                if (/^[a-z]$/.test(char)) {
+                    charType = 'LOWERCASE';
+                    normalizedChar = char;
+                }
+                else if (/^[A-Z]$/.test(char)) {
+                    charType = 'UPPERCASE';
+                    normalizedChar = char.toLowerCase();
+                }
+                else if (/^[0-9]$/.test(char)) {
+                    charType = 'NUMBER';
+                    normalizedChar = char;
+                }
+                else {
+                    charType = 'OTHER';
+                    normalizedChar = '';
+                }
+                if (!lastCharType) {
+                    if (__firstLetterCapital) {
+                        normalizedChar = normalizedChar.toUpperCase(); //TODO: DRY
+                    }
+                }
+                else if (charType !== lastCharType &&
+                    !(charType === 'LOWERCASE' && lastCharType === 'UPPERCASE') &&
+                    !(lastCharType === 'NUMBER') &&
+                    !(charType === 'NUMBER')) {
+                    normalizedChar = normalizedChar.toUpperCase(); //TODO: [🌺] DRY
+                }
+                normalizedName += normalizedChar;
+                lastCharType = charType;
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (sentence_1_1 && !sentence_1_1.done && (_a = sentence_1.return)) _a.call(sentence_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return normalizedName;
+    }
+    /**
+     * TODO: [🌺] Use some intermediate util splitWords
+     */
+
+    function normalizeTo_PascalCase(sentence) {
+        return normalizeTo_camelCase(sentence, true);
+    }
+
+    /**
+     * Supported script languages
+     */
+    var SUPPORTED_SCRIPT_LANGUAGES = ['javascript', 'typescript', 'python'];
+
+    /**
+     * Parses the template and returns the list of all parameter names
+     *
+     * @param template the template with parameters in {curly} braces
+     * @returns the list of parameter names
+     *
+     * @private within the library
+     */
+    function extractParameters(template) {
+        var e_1, _a;
+        var matches = template.matchAll(/{\w+}/g);
+        var parameterNames = [];
+        try {
+            for (var matches_1 = __values(matches), matches_1_1 = matches_1.next(); !matches_1_1.done; matches_1_1 = matches_1.next()) {
+                var match = matches_1_1.value;
+                var parameterName = match[0].slice(1, -1);
+                if (!parameterNames.includes(parameterName)) {
+                    parameterNames.push(parameterName);
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (matches_1_1 && !matches_1_1.done && (_a = matches_1.return)) _a.call(matches_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return parameterNames;
+    }
+
+    /**
+     * Computes the deepness of the markdown structure.
+     *
+     * @private within the library
+     */
+    function countMarkdownStructureDeepness(markdownStructure) {
+        var e_1, _a;
+        var maxDeepness = 0;
+        try {
+            for (var _b = __values(markdownStructure.sections), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var section = _c.value;
+                maxDeepness = Math.max(maxDeepness, countMarkdownStructureDeepness(section));
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
             }
             finally { if (e_1) throw e_1.error; }
         }
-        normalizedName = normalizedName.replace(/_+/g, '_');
-        normalizedName = normalizedName.replace(/_?\/_?/g, '/');
-        normalizedName = normalizedName.replace(/^_/, '');
-        normalizedName = normalizedName.replace(/_$/, '');
-        return normalizedName;
+        return maxDeepness + 1;
     }
+
     /**
-     * TODO: [🌺] Use some intermediate util splitWords
+     * Parse a markdown string into a MarkdownStructure object.
+     *
+     * Note: This function does work with code blocks
+     * Note: This function does not work with markdown comments
+     *
+     * @param markdown The markdown string to parse.
+     * @returns The MarkdownStructure object.
+     *
+     * @private within the library
      */
-
-    /* tslint:disable */
-    function normalizeTo_camelCase(sentence, __firstLetterCapital) {
+    function markdownToMarkdownStructure(markdown) {
         var e_1, _a;
-        if (__firstLetterCapital === void 0) { __firstLetterCapital = false; }
-        var charType;
-        var lastCharType = null;
-        var normalizedName = '';
+        var lines = markdown.split('\n');
+        var root = { level: 0, title: '', contentLines: [], sections: [], parent: null };
+        var current = root;
+        var isInsideCodeBlock = false;
         try {
-            for (var sentence_1 = __values(sentence), sentence_1_1 = sentence_1.next(); !sentence_1_1.done; sentence_1_1 = sentence_1.next()) {
-                var char = sentence_1_1.value;
-                var normalizedChar = void 0;
-                if (/^[a-z]$/.test(char)) {
-                    charType = 'LOWERCASE';
-                    normalizedChar = char;
-                }
-                else if (/^[A-Z]$/.test(char)) {
-                    charType = 'UPPERCASE';
-                    normalizedChar = char.toLowerCase();
-                }
-                else if (/^[0-9]$/.test(char)) {
-                    charType = 'NUMBER';
-                    normalizedChar = char;
+            for (var lines_1 = __values(lines), lines_1_1 = lines_1.next(); !lines_1_1.done; lines_1_1 = lines_1.next()) {
+                var line = lines_1_1.value;
+                var headingMatch = line.match(/^(?<mark>#{1,6})\s(?<title>.*)/);
+                if (isInsideCodeBlock || !headingMatch) {
+                    if (line.startsWith('```')) {
+                        isInsideCodeBlock = !isInsideCodeBlock;
+                    }
+                    current.contentLines.push(line);
                 }
                 else {
-                    charType = 'OTHER';
-                    normalizedChar = '';
-                }
-                if (!lastCharType) {
-                    if (__firstLetterCapital) {
-                        normalizedChar = normalizedChar.toUpperCase(); //TODO: DRY
+                    var level = headingMatch.groups.mark.length;
+                    var title = headingMatch.groups.title.trim();
+                    var parent_1 = void 0;
+                    if (level > current.level) {
+                        // Note: Going deeper (next section is child of current)
+                        parent_1 = current;
                     }
+                    else {
+                        // Note: Going up or staying at the same level (next section is sibling or parent or grandparent,... of current)
+                        parent_1 = current;
+                        var loopLimit = LOOP_LIMIT;
+                        while (parent_1.level !== level - 1) {
+                            if (loopLimit-- < 0) {
+                                throw new UnexpectedError('Loop limit reached during parsing of markdown structure in `markdownToMarkdownStructure`');
+                            }
+                            if (parent_1.parent === null /* <- Note: We are in root */) {
+                                // [🌻]
+                                throw new Error(spaceTrim__default["default"]("\n                                The file has an invalid structure.\n                                The markdown file must have exactly one top-level section.\n                            "));
+                            }
+                            parent_1 = parent_1.parent;
+                        }
+                    }
+                    var section = { level: level, title: title, contentLines: [], sections: [], parent: parent_1 };
+                    parent_1.sections.push(section);
+                    current = section;
                 }
-                else if (charType !== lastCharType &&
-                    !(charType === 'LOWERCASE' && lastCharType === 'UPPERCASE') &&
-                    !(lastCharType === 'NUMBER') &&
-                    !(charType === 'NUMBER')) {
-                    normalizedChar = normalizedChar.toUpperCase(); //TODO: [🌺] DRY
-                }
-                normalizedName += normalizedChar;
-                lastCharType = charType;
             }
         }
         catch (e_1_1) { e_1 = { error: e_1_1 }; }
         finally {
             try {
-                if (sentence_1_1 && !sentence_1_1.done && (_a = sentence_1.return)) _a.call(sentence_1);
+                if (lines_1_1 && !lines_1_1.done && (_a = lines_1.return)) _a.call(lines_1);
             }
             finally { if (e_1) throw e_1.error; }
         }
-        return normalizedName;
+        if (root.sections.length === 1) {
+            var markdownStructure = parsingMarkdownStructureToMarkdownStructure(root.sections[0]);
+            return markdownStructure;
+        }
+        // [🌻]
+        throw new Error('The markdown file must have exactly one top-level section.');
+        // return root;
     }
     /**
-     * TODO: [🌺] Use some intermediate util splitWords
+     * @private
      */
+    function parsingMarkdownStructureToMarkdownStructure(parsingMarkdownStructure) {
+        var level = parsingMarkdownStructure.level, title = parsingMarkdownStructure.title, contentLines = parsingMarkdownStructure.contentLines, sections = parsingMarkdownStructure.sections;
+        return {
+            level: level,
+            title: title,
+            content: spaceTrim__default["default"](contentLines.join('\n')),
+            sections: sections.map(parsingMarkdownStructureToMarkdownStructure),
+        };
+    }
 
-    function normalizeTo_PascalCase(sentence) {
-        return normalizeTo_camelCase(sentence, true);
+    /**
+     * The version of the Promptbook library
+     */
+    var PROMPTBOOK_VERSION = '0.44.0-9';
+
+    /**
+     * Parses the given script and returns the list of all used variables that are not defined in the script
+     *
+     * @param script from which to extract the variables
+     * @returns the list of variable names
+     * @throws {PromptbookSyntaxError} if the script is invalid
+     *
+     * @private within the promptbookStringToJson
+     */
+    function extractVariables(script) {
+        var variables = [];
+        script = "(()=>{".concat(script, "})()");
+        try {
+            for (var i = 0; i < 100 /* <- TODO: This limit to configuration */; i++)
+                try {
+                    eval(script);
+                }
+                catch (error) {
+                    if (!(error instanceof ReferenceError)) {
+                        throw error;
+                    }
+                    var undefinedName = error.message.split(' ')[0];
+                    /*
+                    Note: Remapping error
+                          From: [ReferenceError: thing is not defined],
+                          To:   [Error: Parameter {thing} is not defined],
+                    */
+                    if (!undefinedName) {
+                        throw error;
+                    }
+                    if (script.includes(undefinedName + '(')) {
+                        script = "const ".concat(undefinedName, " = ()=>'';") + script;
+                    }
+                    else {
+                        variables.push(undefinedName);
+                        script = "const ".concat(undefinedName, " = '';") + script;
+                    }
+                }
+        }
+        catch (error) {
+            if (!(error instanceof Error)) {
+                throw error;
+            }
+            throw new PromptbookSyntaxError(spaceTrim__default["default"](function (block) { return "\n                    Can not extract variables from the script\n\n                    ".concat(block(error.name), ": ").concat(block(error.message), "\n                "); }));
+        }
+        return variables;
     }
 
+    /**
+     * Execution type describes the way how the block is executed
+     *
+     * @see https://github.com/webgptorg/promptbook#execution-type
+     */
+    var ExecutionTypes = [
+        'PROMPT_TEMPLATE',
+        'SIMPLE_TEMPLATE',
+        'SCRIPT',
+        'PROMPT_DIALOG',
+        // <- [🥻] Insert here when making new command
+    ];
+
+    /**
+     * Units of text measurement
+     */
+    var EXPECTATION_UNITS = ['CHARACTERS', 'WORDS', 'SENTENCES', 'PARAGRAPHS', 'LINES', 'PAGES'];
+    /**
+     * TODO: [💝] Unite object for expecting amount and format - remove expectFormat
+     * TODO: use one helper type> (string_prompt | string_javascript | string_markdown) & string_template
+     */
+
     /**
      * Parses one line of ul/ol to command
      *
@@ -1651,7 +1730,7 @@
                 executionType: executionType,
                 jokers: jokers,
                 postprocessing: postprocessing,
-                expectAmount: expectAmount,
+                expectations: expectAmount,
                 expectFormat: expectFormat,
                 modelRequirements: templateModelRequirements,
                 contentLanguage: executionType === 'SCRIPT' ? language : undefined,
@@ -1793,7 +1872,7 @@
                 }
                 if (template.jokers && template.jokers.length > 0) {
                     if (!template.expectFormat &&
-                        !template.expectAmount /* <- TODO: Require at least 1 -> min <- expectation to use jokers */) {
+                        !template.expectations /* <- TODO: Require at least 1 -> min <- expectation to use jokers */) {
                         throw new PromptbookLogicError("Joker parameters are used for {".concat(template.resultingParameterName, "} but no expectations are defined"));
                     }
                     try {
@@ -1812,9 +1891,9 @@
                         finally { if (e_3) throw e_3.error; }
                     }
                 }
-                if (template.expectAmount) {
+                if (template.expectations) {
                     try {
-                        for (var _l = (e_4 = void 0, __values(Object.entries(template.expectAmount))), _m = _l.next(); !_m.done; _m = _l.next()) {
+                        for (var _l = (e_4 = void 0, __values(Object.entries(template.expectations))), _m = _l.next(); !_m.done; _m = _l.next()) {
                             var _o = __read(_m.value, 2), unit = _o[0], _p = _o[1], min = _p.min, max = _p.max;
                             if (min !== undefined && max !== undefined && min > max) {
                                 throw new PromptbookLogicError("Min expectation (=".concat(min, ") of ").concat(unit, " is higher than max expectation (=").concat(max, ")"));
@@ -1895,23 +1974,6 @@
      *     >  ex port function validatePromptbookJson(promptbook: unknown): asserts promptbook is PromptbookJson {
      */
 
-    /**
-     * This error occurs when some expectation is not met in the execution of the pipeline
-     *
-     * @private Always catched and rethrown as `PromptbookExecutionError`
-     * Note: This is a kindof subtype of PromptbookExecutionError
-     */
-    var ExpectError = /** @class */ (function (_super) {
-        __extends(ExpectError, _super);
-        function ExpectError(message) {
-            var _this = _super.call(this, message) || this;
-            _this.name = 'ExpectError';
-            Object.setPrototypeOf(_this, ExpectError.prototype);
-            return _this;
-        }
-        return ExpectError;
-    }(Error));
-
     /**
      * Creates executor function from promptbook and execution tools.
      *
@@ -1926,10 +1988,10 @@
         var promptbookExecutor = function (inputParameters, onProgress) { return __awaiter(_this, void 0, void 0, function () {
             function executeSingleTemplate(currentTemplate) {
                 return __awaiter(this, void 0, void 0, function () {
-                    var name, title, priority, prompt, chatThread, completionResult, result, resultString, expectError, scriptExecutionErrors, maxAttempts, jokers, attempt, isJokerAttempt, joker, _a, _b, _c, _d, scriptTools, error_2, e_2_1, _e, _f, functionName, postprocessingError, _g, _h, scriptTools, error_3, e_3_1, e_4_1, _j, _k, _l, unit, _m, max, min, amount, error_4;
-                    var e_2, _o, e_4, _p, e_3, _q, e_5, _r, _s;
-                    return __generator(this, function (_t) {
-                        switch (_t.label) {
+                    var name, title, priority, prompt, chatThread, completionResult, result, resultString, expectError, scriptExecutionErrors, maxAttempts, jokers, attempt, isJokerAttempt, joker, _a, _b, _c, _d, scriptTools, error_2, e_2_1, _e, _f, functionName, postprocessingError, _g, _h, scriptTools, error_3, e_3_1, e_4_1, error_4;
+                    var e_2, _j, e_4, _k, e_3, _l, _m;
+                    return __generator(this, function (_o) {
+                        switch (_o.label) {
                             case 0:
                                 name = "promptbook-executor-frame-".concat(currentTemplate.name);
                                 title = currentTemplate.title;
@@ -1946,8 +2008,8 @@
                                         // <- [3]
                                     })];
                             case 1:
-                                _t.sent();
-                                _t.label = 2;
+                                _o.sent();
+                                _o.label = 2;
                             case 2:
                                 result = null;
                                 resultString = null;
@@ -1955,7 +2017,7 @@
                                 maxAttempts = currentTemplate.executionType === 'PROMPT_DIALOG' ? Infinity : maxExecutionAttempts;
                                 jokers = currentTemplate.jokers || [];
                                 attempt = -jokers.length;
-                                _t.label = 3;
+                                _o.label = 3;
                             case 3:
                                 if (!(attempt < maxAttempts)) return [3 /*break*/, 49];
                                 isJokerAttempt = attempt < 0;
@@ -1972,9 +2034,9 @@
                                     }
                                     resultString = parametersToPass[joker];
                                 }
-                                _t.label = 4;
+                                _o.label = 4;
                             case 4:
-                                _t.trys.push([4, 45, 46, 47]);
+                                _o.trys.push([4, 45, 46, 47]);
                                 if (!!isJokerAttempt) return [3 /*break*/, 27];
                                 _a = currentTemplate.executionType;
                                 switch (_a) {
@@ -1996,6 +2058,7 @@
                                     parameters: parametersToPass,
                                     content: replaceParameters(currentTemplate.content, parametersToPass) /* <- [2] */,
                                     modelRequirements: currentTemplate.modelRequirements,
+                                    expectations: currentTemplate.expectations,
                                 };
                                 _b = currentTemplate.modelRequirements.modelVariant;
                                 switch (_b) {
@@ -2005,14 +2068,14 @@
                                 return [3 /*break*/, 11];
                             case 7: return [4 /*yield*/, tools.natural.gptChat(prompt)];
                             case 8:
-                                chatThread = _t.sent();
+                                chatThread = _o.sent();
                                 // TODO: [🍬] Destroy chatThread
                                 result = chatThread;
                                 resultString = chatThread.content;
                                 return [3 /*break*/, 12];
                             case 9: return [4 /*yield*/, tools.natural.gptComplete(prompt)];
                             case 10:
-                                completionResult = _t.sent();
+                                completionResult = _o.sent();
                                 result = completionResult;
                                 resultString = completionResult.content;
                                 return [3 /*break*/, 12];
@@ -2027,27 +2090,27 @@
                                 }
                                 // TODO: DRY [1]
                                 scriptExecutionErrors = [];
-                                _t.label = 14;
+                                _o.label = 14;
                             case 14:
-                                _t.trys.push([14, 21, 22, 23]);
+                                _o.trys.push([14, 21, 22, 23]);
                                 _c = (e_2 = void 0, __values(tools.script)), _d = _c.next();
-                                _t.label = 15;
+                                _o.label = 15;
                             case 15:
                                 if (!!_d.done) return [3 /*break*/, 20];
                                 scriptTools = _d.value;
-                                _t.label = 16;
+                                _o.label = 16;
                             case 16:
-                                _t.trys.push([16, 18, , 19]);
+                                _o.trys.push([16, 18, , 19]);
                                 return [4 /*yield*/, scriptTools.execute({
                                         scriptLanguage: currentTemplate.contentLanguage,
                                         script: currentTemplate.content,
                                         parameters: parametersToPass,
                                     })];
                             case 17:
-                                resultString = _t.sent();
+                                resultString = _o.sent();
                                 return [3 /*break*/, 20];
                             case 18:
-                                error_2 = _t.sent();
+                                error_2 = _o.sent();
                                 if (!(error_2 instanceof Error)) {
                                     throw error_2;
                                 }
@@ -2058,12 +2121,12 @@
                                 return [3 /*break*/, 15];
                             case 20: return [3 /*break*/, 23];
                             case 21:
-                                e_2_1 = _t.sent();
+                                e_2_1 = _o.sent();
                                 e_2 = { error: e_2_1 };
                                 return [3 /*break*/, 23];
                             case 22:
                                 try {
-                                    if (_d && !_d.done && (_o = _c.return)) _o.call(_c);
+                                    if (_d && !_d.done && (_j = _c.return)) _j.call(_c);
                                 }
                                 finally { if (e_2) throw e_2.error; }
                                 return [7 /*endfinally*/];
@@ -2089,46 +2152,46 @@
                                 })];
                             case 25:
                                 // TODO: [🌹] When making next attempt for `PROMPT DIALOG`, preserve the previous user input
-                                resultString = _t.sent();
+                                resultString = _o.sent();
                                 return [3 /*break*/, 27];
                             case 26: throw new PromptbookExecutionError(
                             // eslint-disable-next-line @typescript-eslint/no-explicit-any
                             "Unknown execution type \"".concat(currentTemplate.executionType, "\""));
                             case 27:
                                 if (!(!isJokerAttempt && currentTemplate.postprocessing)) return [3 /*break*/, 44];
-                                _t.label = 28;
+                                _o.label = 28;
                             case 28:
-                                _t.trys.push([28, 42, 43, 44]);
+                                _o.trys.push([28, 42, 43, 44]);
                                 _e = (e_4 = void 0, __values(currentTemplate.postprocessing)), _f = _e.next();
-                                _t.label = 29;
+                                _o.label = 29;
                             case 29:
                                 if (!!_f.done) return [3 /*break*/, 41];
                                 functionName = _f.value;
                                 // TODO: DRY [1]
                                 scriptExecutionErrors = [];
                                 postprocessingError = null;
-                                _t.label = 30;
+                                _o.label = 30;
                             case 30:
-                                _t.trys.push([30, 37, 38, 39]);
+                                _o.trys.push([30, 37, 38, 39]);
                                 _g = (e_3 = void 0, __values(tools.script)), _h = _g.next();
-                                _t.label = 31;
+                                _o.label = 31;
                             case 31:
                                 if (!!_h.done) return [3 /*break*/, 36];
                                 scriptTools = _h.value;
-                                _t.label = 32;
+                                _o.label = 32;
                             case 32:
-                                _t.trys.push([32, 34, , 35]);
+                                _o.trys.push([32, 34, , 35]);
                                 return [4 /*yield*/, scriptTools.execute({
                                         scriptLanguage: "javascript" /* <- TODO: Try it in each languages; In future allow postprocessing with arbitrary combination of languages to combine */,
                                         script: "".concat(functionName, "(resultString)"),
                                         parameters: __assign(__assign({}, parametersToPass), { resultString: resultString || '' }),
                                     })];
                             case 33:
-                                resultString = _t.sent();
+                                resultString = _o.sent();
                                 postprocessingError = null;
                                 return [3 /*break*/, 36];
                             case 34:
-                                error_3 = _t.sent();
+                                error_3 = _o.sent();
                                 if (!(error_3 instanceof Error)) {
                                     throw error_3;
                                 }
@@ -2140,12 +2203,12 @@
                                 return [3 /*break*/, 31];
                             case 36: return [3 /*break*/, 39];
                             case 37:
-                                e_3_1 = _t.sent();
+                                e_3_1 = _o.sent();
                                 e_3 = { error: e_3_1 };
                                 return [3 /*break*/, 39];
                             case 38:
                                 try {
-                                    if (_h && !_h.done && (_q = _g.return)) _q.call(_g);
+                                    if (_h && !_h.done && (_l = _g.return)) _l.call(_g);
                                 }
                                 finally { if (e_3) throw e_3.error; }
                                 return [7 /*endfinally*/];
@@ -2153,22 +2216,23 @@
                                 if (postprocessingError) {
                                     throw postprocessingError;
                                 }
-                                _t.label = 40;
+                                _o.label = 40;
                             case 40:
                                 _f = _e.next();
                                 return [3 /*break*/, 29];
                             case 41: return [3 /*break*/, 44];
                             case 42:
-                                e_4_1 = _t.sent();
+                                e_4_1 = _o.sent();
                                 e_4 = { error: e_4_1 };
                                 return [3 /*break*/, 44];
                             case 43:
                                 try {
-                                    if (_f && !_f.done && (_p = _e.return)) _p.call(_e);
+                                    if (_f && !_f.done && (_k = _e.return)) _k.call(_e);
                                 }
                                 finally { if (e_4) throw e_4.error; }
                                 return [7 /*endfinally*/];
                             case 44:
+                                // TODO: [💝] Unite object for expecting amount and format
                                 if (currentTemplate.expectFormat) {
                                     if (currentTemplate.expectFormat === 'JSON') {
                                         if (!isValidJsonString(resultString || '')) {
@@ -2176,30 +2240,13 @@
                                         }
                                     }
                                 }
-                                if (currentTemplate.expectAmount) {
-                                    try {
-                                        for (_j = (e_5 = void 0, __values(Object.entries(currentTemplate.expectAmount))), _k = _j.next(); !_k.done; _k = _j.next()) {
-                                            _l = __read(_k.value, 2), unit = _l[0], _m = _l[1], max = _m.max, min = _m.min;
-                                            amount = CountUtils[unit.toUpperCase()](resultString || '');
-                                            if (min && amount < min) {
-                                                throw new ExpectError("Expected at least ".concat(min, " ").concat(unit, " but got ").concat(amount));
-                                            } /* not else */
-                                            if (max && amount > max) {
-                                                throw new ExpectError("Expected at most ".concat(max, " ").concat(unit, " but got ").concat(amount));
-                                            }
-                                        }
-                                    }
-                                    catch (e_5_1) { e_5 = { error: e_5_1 }; }
-                                    finally {
-                                        try {
-                                            if (_k && !_k.done && (_r = _j.return)) _r.call(_j);
-                                        }
-                                        finally { if (e_5) throw e_5.error; }
-                                    }
+                                // TODO: [💝] Unite object for expecting amount and format
+                                if (currentTemplate.expectations) {
+                                    checkExpectations(currentTemplate.expectations, resultString || '');
                                 }
                                 return [3 /*break*/, 49];
                             case 45:
-                                error_4 = _t.sent();
+                                error_4 = _o.sent();
                                 if (!(error_4 instanceof ExpectError)) {
                                     throw error_4;
                                 }
@@ -2218,6 +2265,7 @@
                                             title: currentTemplate.title /* <- Note: If title in promptbook contains emojis, pass it innto report */,
                                             content: prompt.content,
                                             modelRequirements: prompt.modelRequirements,
+                                            expectations: prompt.expectations,
                                             // <- Note: Do want to pass ONLY wanted information to the report
                                         },
                                         result: result || undefined,
@@ -2227,9 +2275,9 @@
                                 return [7 /*endfinally*/];
                             case 47:
                                 if (expectError !== null && attempt === maxAttempts - 1) {
-                                    throw new PromptbookExecutionError(spaceTrim__default["default"](function (block) { return "\n                              Natural execution failed ".concat(maxExecutionAttempts, "x\n\n                              ").concat(block((expectError === null || expectError === void 0 ? void 0 : expectError.message) || ''), "\n                          "); }));
+                                    throw new PromptbookExecutionError(spaceTrim__default["default"](function (block) { return "\n                              Natural execution failed ".concat(maxExecutionAttempts, "x\n\n                              Last error ").concat((expectError === null || expectError === void 0 ? void 0 : expectError.name) || '', ":\n                              ").concat(block((expectError === null || expectError === void 0 ? void 0 : expectError.message) || ''), "\n\n                              Last result:\n                              ").concat(resultString, "\n                          "); }));
                                 }
-                                _t.label = 48;
+                                _o.label = 48;
                             case 48:
                                 attempt++;
                                 return [3 /*break*/, 3];
@@ -2249,7 +2297,7 @@
                                         // <- [3]
                                     });
                                 }
-                                parametersToPass = __assign(__assign({}, parametersToPass), (_s = {}, _s[currentTemplate.resultingParameterName] = resultString /* <- Note: Not need to detect parameter collision here because Promptbook checks logic consistency during construction */, _s));
+                                parametersToPass = __assign(__assign({}, parametersToPass), (_m = {}, _m[currentTemplate.resultingParameterName] = resultString /* <- Note: Not need to detect parameter collision here because Promptbook checks logic consistency during construction */, _m));
                                 return [2 /*return*/];
                         }
                     });
@@ -2453,8 +2501,94 @@
         return MockedEchoNaturalExecutionTools;
     }());
     /**
-     * TODO: Allow in spaceTrim: nesting with > ${block(prompt.request)}
+     * TODO: Allow in spaceTrim: nesting with > ${block(prompt.request)}, same as replace params
+     */
+
+    /**
+     * Gets the expectations and creates a fake text that meets the expectations
+     *
+     * @private internal util for MockedFackedNaturalExecutionTools
+     */
+    function $fakeTextToExpectations(expectations) {
+        var lorem = new loremIpsum.LoremIpsum({
+            wordsPerSentence: { min: 5, max: 15 },
+            sentencesPerParagraph: { min: 5, max: 15 },
+        });
+        var loremText = '';
+        var text = '';
+        for (var loopLimit = CHARACTER_LOOP_LIMIT; loopLimit-- > 0;) {
+            if (isPassingExpectations(expectations, text)) {
+                return text;
+            }
+            if (loremText === '') {
+                loremText = lorem.generateParagraphs(1) + '\n\n';
+            }
+            text += loremText.substring(0, 1);
+            loremText = loremText.substring(1);
+        }
+        throw new Error(spaceTrim__default["default"](function (block) { return "\n                Can not generate fake text to met the expectations\n\n                Loop limit reached\n                The expectations:\n                ".concat(block(JSON.stringify(expectations, null, 4)), "\n\n                The draft text:\n                ").concat(block(text), "\n\n            "); }));
+    }
+    /**
+     * TODO: Implement better
+     * TODO: [💝] Unite object for expecting amount and format - use here also a format
+     */
+
+    /**
+     * Mocked execution Tools for just faking expected responses for testing purposes
      */
+    var MockedFackedNaturalExecutionTools = /** @class */ (function () {
+        function MockedFackedNaturalExecutionTools(options) {
+            this.options = options;
+        }
+        /**
+         * Fakes chat model
+         */
+        MockedFackedNaturalExecutionTools.prototype.gptChat = function (prompt) {
+            return __awaiter(this, void 0, void 0, function () {
+                var content, result;
+                return __generator(this, function (_a) {
+                    if (this.options.isVerbose) {
+                        console.info('💬 Mocked faked prompt', prompt);
+                    }
+                    content = $fakeTextToExpectations(prompt.expectations || {
+                        sentences: { min: 1, max: 1 },
+                    });
+                    result = {
+                        content: content,
+                        model: 'mocked-facked',
+                        timing: {
+                            start: getCurrentIsoDate(),
+                            complete: getCurrentIsoDate(),
+                        },
+                        usage: {
+                            price: 0,
+                            inputTokens: 0,
+                            outputTokens: 0,
+                        },
+                        rawResponse: {
+                            note: 'This is mocked echo',
+                        },
+                        // <- [🤹‍♂️]
+                    };
+                    if (this.options.isVerbose) {
+                        console.info('💬 Mocked faked result', result);
+                    }
+                    return [2 /*return*/, result];
+                });
+            });
+        };
+        /**
+         * Fakes completion model
+         */
+        MockedFackedNaturalExecutionTools.prototype.gptComplete = function (prompt) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    return [2 /*return*/, this.gptChat(prompt)];
+                });
+            });
+        };
+        return MockedFackedNaturalExecutionTools;
+    }());
 
     /**
      * Delagates the user interaction to a async callback function
@@ -2802,6 +2936,7 @@
     exports.CallbackInterfaceTools = CallbackInterfaceTools;
     exports.ExecutionTypes = ExecutionTypes;
     exports.MockedEchoNaturalExecutionTools = MockedEchoNaturalExecutionTools;
+    exports.MockedFackedNaturalExecutionTools = MockedFackedNaturalExecutionTools;
     exports.PROMPTBOOK_VERSION = PROMPTBOOK_VERSION;
     exports.SimplePromptInterfaceTools = SimplePromptInterfaceTools;
     exports.SimplePromptbookLibrary = SimplePromptbookLibrary;