@promptbook/fake-llm 0.66.0 → 0.67.0-0

package/esm/index.es.js

@@ -1,11 +1,14 @@
-import { spaceTrim } from 'spacetrim';
+import _spaceTrim, { spaceTrim } from 'spacetrim';
 import { LoremIpsum } from 'lorem-ipsum';
+import { format } from 'prettier';
+import parserHtml from 'prettier/parser-html';
+import { forTime } from 'waitasecond';
 
 // ⚠️ WARNING: This code has been generated so that any manual changes will be overwritten
 /**
  * The version of the Promptbook library
  */
-var PROMPTBOOK_VERSION = '0.66.0-9';
+var PROMPTBOOK_VERSION = '0.66.0';
 // TODO: !!!! List here all the versions and annotate + put into script
 
 /*! *****************************************************************************
@@ -187,6 +190,165 @@ function getCurrentIsoDate() {
     return new Date().toISOString();
 }
 
+/**
+ * This error type indicates that the error should not happen and its last check before crashing with some other error
+ *
+ * @public exported from `@promptbook/core`
+ */
+var UnexpectedError = /** @class */ (function (_super) {
+    __extends(UnexpectedError, _super);
+    function UnexpectedError(message) {
+        var _this = _super.call(this, spaceTrim(function (block) { return "\n                    ".concat(block(message), "\n\n                    Note: This error should not happen.\n                    It's probbably a bug in the pipeline collection\n\n                    Please report issue:\n                    https://github.com/webgptorg/promptbook/issues\n\n                    Or contact us on me@pavolhejny.com\n\n                "); })) || this;
+        _this.name = 'UnexpectedError';
+        Object.setPrototypeOf(_this, UnexpectedError.prototype);
+        return _this;
+    }
+    return UnexpectedError;
+}(Error));
+
+/**
+ * Checks if the value is [🚉] serializable as JSON
+ * If not, throws an UnexpectedError with a rich error message and tracking
+ *
+ * - Almost all primitives are serializable BUT:
+ * - `undefined` is not serializable
+ * - `NaN` is not serializable
+ * - Objects and arrays are serializable if all their properties are serializable
+ * - Functions are not serializable
+ * - Circular references are not serializable
+ * - `Date` objects are not serializable
+ * - `Map` and `Set` objects are not serializable
+ * - `RegExp` objects are not serializable
+ * - `Error` objects are not serializable
+ * - `Symbol` objects are not serializable
+ * - And much more...
+ *
+ * @throws UnexpectedError if the value is not serializable as JSON
+ * @public exported from `@promptbook/utils`
+ */
+function checkSerializableAsJson(name, value) {
+    var e_1, _a;
+    if (value === undefined) {
+        throw new UnexpectedError("".concat(name, " is undefined"));
+    }
+    else if (value === null) {
+        return;
+    }
+    else if (typeof value === 'boolean') {
+        return;
+    }
+    else if (typeof value === 'number' && !isNaN(value)) {
+        return;
+    }
+    else if (typeof value === 'string') {
+        return;
+    }
+    else if (typeof value === 'symbol') {
+        throw new UnexpectedError("".concat(name, " is symbol"));
+    }
+    else if (typeof value === 'function') {
+        throw new UnexpectedError("".concat(name, " is function"));
+    }
+    else if (typeof value === 'object' && Array.isArray(value)) {
+        for (var i = 0; i < value.length; i++) {
+            checkSerializableAsJson("".concat(name, "[").concat(i, "]"), value[i]);
+        }
+    }
+    else if (typeof value === 'object') {
+        if (value instanceof Date) {
+            throw new UnexpectedError(_spaceTrim("\n                    ".concat(name, " is Date\n\n                    Use `string_date_iso8601` instead\n                ")));
+        }
+        else if (value instanceof Map) {
+            throw new UnexpectedError("".concat(name, " is Map"));
+        }
+        else if (value instanceof Set) {
+            throw new UnexpectedError("".concat(name, " is Set"));
+        }
+        else if (value instanceof RegExp) {
+            throw new UnexpectedError("".concat(name, " is RegExp"));
+        }
+        else if (value instanceof Error) {
+            throw new UnexpectedError(_spaceTrim("\n                    ".concat(name, " is unserialized Error\n\n                    Use function `serializeError`\n                ")));
+        }
+        else {
+            try {
+                for (var _b = __values(Object.entries(value)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var _d = __read(_c.value, 2), subName = _d[0], subValue = _d[1];
+                    if (subValue === undefined) {
+                        // Note: undefined in object is serializable - it is just omited
+                        continue;
+                    }
+                    checkSerializableAsJson("".concat(name, ".").concat(subName), subValue);
+                }
+            }
+            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; }
+            }
+            try {
+                JSON.stringify(value); // <- TODO: [0]
+            }
+            catch (error) {
+                if (!(error instanceof Error)) {
+                    throw error;
+                }
+                throw new UnexpectedError(_spaceTrim(function (block) { return "\n                            ".concat(name, " is not serializable\n\n                            ").concat(block(error.toString()), "\n                        "); }));
+            }
+            /*
+            TODO: [0] Is there some more elegant way to check circular references?
+            const seen = new Set();
+            const stack = [{ value }];
+            while (stack.length > 0) {
+                const { value } = stack.pop()!;
+                if (typeof value === 'object' && value !== null) {
+                    if (seen.has(value)) {
+                        throw new UnexpectedError(`${name} has circular reference`);
+                    }
+                    seen.add(value);
+                    if (Array.isArray(value)) {
+                        stack.push(...value.map((value) => ({ value })));
+                    } else {
+                        stack.push(...Object.values(value).map((value) => ({ value })));
+                    }
+                }
+            }
+            */
+            return;
+        }
+    }
+    else {
+        throw new UnexpectedError("".concat(name, " is unknown"));
+    }
+}
+/**
+ * TODO: [🧠][🛣] More elegant way to tracking than passing `name`
+ * TODO: [🧠] !!! In-memory cache of same values to prevent multiple checks
+ * Note: [🐠] This is how `checkSerializableAsJson` + `isSerializableAsJson` together can just retun true/false or rich error message
+ */
+
+/**
+ * @@@
+ * @@@
+ *
+ * Note: This function mutates the object and returns the original (but mutated-deep-freezed) object
+ *
+ * @param name - Name of the object for debugging purposes
+ * @param objectValue - Object to be deeply frozen
+ * @returns The same object as the input, but deeply frozen
+ * @private this is in comparison to `deepFreeze` a more specific utility and maybe not very good practice to use without specific reason and considerations
+ */
+function $asDeeplyFrozenSerializableJson(name, objectValue) {
+    checkSerializableAsJson(name, objectValue);
+    return $deepFreeze(objectValue);
+}
+/**
+ * TODO: [🧠][🛣] More elegant way to tracking than passing `name`
+ * TODO: [🧠] Is there a way how to meaningfully test this utility
+ */
+
 // <- TODO: [🧠] Better system for generator warnings - not always "code" and "by `@promptbook/cli`"
 /**
  * The maximum number of iterations for a loops
@@ -211,7 +373,7 @@ var REPLACING_NONCE = 'u$k42k%!V2zo34w7Fu#@QUHYPW';
  *
  * @public exported from `@promptbook/core`
  */
-$deepFreeze([
+$asDeeplyFrozenSerializableJson('RESERVED_PARAMETER_NAMES', [
     'content',
     'context',
     'knowledge',
@@ -269,22 +431,6 @@ var PipelineExecutionError = /** @class */ (function (_super) {
     return PipelineExecutionError;
 }(Error));
 
-/**
- * This error type indicates that the error should not happen and its last check before crashing with some other error
- *
- * @public exported from `@promptbook/core`
- */
-var UnexpectedError = /** @class */ (function (_super) {
-    __extends(UnexpectedError, _super);
-    function UnexpectedError(message) {
-        var _this = _super.call(this, spaceTrim(function (block) { return "\n                    ".concat(block(message), "\n\n                    Note: This error should not happen.\n                    It's probbably a bug in the pipeline collection\n\n                    Please report issue:\n                    https://github.com/webgptorg/promptbook/issues\n\n                    Or contact us on me@pavolhejny.com\n\n                "); })) || this;
-        _this.name = 'UnexpectedError';
-        Object.setPrototypeOf(_this, UnexpectedError.prototype);
-        return _this;
-    }
-    return UnexpectedError;
-}(Error));
-
 /**
  * Replaces parameters in template with values from parameters object
  *
@@ -424,7 +570,7 @@ var MockedEchoLlmExecutionTools = /** @class */ (function () {
                 rawPromptContent = replaceParameters(prompt.content, __assign(__assign({}, prompt.parameters), { modelName: modelName }));
                 usage = ZERO_USAGE;
                 //      <- TODO: [🧠] Compute here at least words, characters,... etc
-                return [2 /*return*/, {
+                return [2 /*return*/, $asDeeplyFrozenSerializableJson('MockedEchoLlmExecutionTools ChatPromptResult', {
                         content: spaceTrim(function (block) { return "\n                    You said:\n                    ".concat(block(rawPromptContent), "\n                "); }),
                         modelName: modelName,
                         timing: {
@@ -438,7 +584,7 @@ var MockedEchoLlmExecutionTools = /** @class */ (function () {
                             note: 'This is mocked echo',
                         },
                         // <- [🗯]
-                    }];
+                    })];
             });
         });
     };
@@ -456,7 +602,7 @@ var MockedEchoLlmExecutionTools = /** @class */ (function () {
                 rawPromptContent = replaceParameters(prompt.content, __assign(__assign({}, prompt.parameters), { modelName: modelName }));
                 usage = ZERO_USAGE;
                 //      <- TODO: [🧠] Compute here at least words, characters,... etc
-                return [2 /*return*/, {
+                return [2 /*return*/, $asDeeplyFrozenSerializableJson('MockedEchoLlmExecutionTools CompletionPromptResult', {
                         content: spaceTrim(function (block) { return "\n                    ".concat(block(rawPromptContent), "\n                    And so on...\n                "); }),
                         modelName: modelName,
                         timing: {
@@ -470,7 +616,7 @@ var MockedEchoLlmExecutionTools = /** @class */ (function () {
                             note: 'This is mocked echo',
                         },
                         // <- [🗯]
-                    }];
+                    })];
             });
         });
     };
@@ -482,86 +628,191 @@ var MockedEchoLlmExecutionTools = /** @class */ (function () {
  */
 
 /**
- * This error occurs when some expectation is not met in the execution of the pipeline
+ * This error indicates that the promptbook in a markdown format cannot be parsed into a valid promptbook object
  *
- * @private error of `checkExpectations` and `createPipelineExecutor`
- * Note: Always thrown in `checkExpectations` and catched in `createPipelineExecutor` and rethrown as `PipelineExecutionError`
- * Note: This is a kindof subtype of PipelineExecutionError
+ * @public exported from `@promptbook/core`
  */
-var ExpectError = /** @class */ (function (_super) {
-    __extends(ExpectError, _super);
-    function ExpectError(message) {
+var ParsingError = /** @class */ (function (_super) {
+    __extends(ParsingError, _super);
+    function ParsingError(message) {
         var _this = _super.call(this, message) || this;
-        _this.name = 'ExpectError';
-        Object.setPrototypeOf(_this, ExpectError.prototype);
+        _this.name = 'ParsingError';
+        Object.setPrototypeOf(_this, ParsingError.prototype);
         return _this;
     }
-    return ExpectError;
+    return ParsingError;
 }(Error));
 
 /**
- * Counts number of characters in the text
+ * Makes first letter of a string uppercase
  *
  * @public exported from `@promptbook/utils`
  */
-function countCharacters(text) {
-    // Remove null characters
-    text = text.replace(/\0/g, '');
-    // Replace emojis (and also ZWJ sequence) with hyphens
-    text = text.replace(/(\p{Extended_Pictographic})\p{Modifier_Symbol}/gu, '$1');
-    text = text.replace(/(\p{Extended_Pictographic})[\u{FE00}-\u{FE0F}]/gu, '$1');
-    text = text.replace(/\p{Extended_Pictographic}(\u{200D}\p{Extended_Pictographic})*/gu, '-');
-    return text.length;
+function capitalize(word) {
+    return word.substring(0, 1).toUpperCase() + word.substring(1);
 }
 
 /**
- * Counts number of lines in the text
+ * Extracts all code blocks from markdown.
  *
- * @public exported from `@promptbook/utils`
+ * 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
+ * @public exported from `@promptbook/markdown-utils`
  */
-function countLines(text) {
-    if (text === '') {
-        return 0;
+function extractAllBlocksFromMarkdown(markdown) {
+    var e_1, _a;
+    var codeBlocks = [];
+    var lines = markdown.split('\n');
+    // Note: [0] Ensure that the last block notated by gt > will be closed
+    lines.push('');
+    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('> ') || line === '>') {
+                if (currentCodeBlock === null) {
+                    currentCodeBlock = { blockNotation: '>', language: null, content: '' };
+                } /* not else */
+                if (currentCodeBlock.blockNotation === '>') {
+                    if (currentCodeBlock.content !== '') {
+                        currentCodeBlock.content += '\n';
+                    }
+                    currentCodeBlock.content += line.slice(2);
+                }
+            }
+            else if (currentCodeBlock !== null && currentCodeBlock.blockNotation === '>' /* <- Note: [0] */) {
+                codeBlocks.push(currentCodeBlock);
+                currentCodeBlock = null;
+            }
+            /* not else */
+            if (line.startsWith('```')) {
+                var language = line.slice(3).trim() || null;
+                if (currentCodeBlock === null) {
+                    currentCodeBlock = { blockNotation: '```', language: language, content: '' };
+                }
+                else {
+                    if (language !== null) {
+                        throw new ParsingError("".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 && currentCodeBlock.blockNotation === '```') {
+                if (currentCodeBlock.content !== '') {
+                    currentCodeBlock.content += '\n';
+                }
+                currentCodeBlock.content += line.split('\\`\\`\\`').join('```') /* <- TODO: Maybe make propper unescape */;
+            }
+        }
     }
-    return text.split('\n').length;
+    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 ParsingError("".concat(capitalize(currentCodeBlock.language || 'the'), " code block was not closed at the end of the markdown"));
+    }
+    return codeBlocks;
 }
+/**
+ * TODO: Maybe name for `blockNotation` instead of  '```' and '>'
+ */
 
 /**
- * Counts number of pages in the text
+ * Extracts exactly ONE code block from markdown.
  *
- * @public exported from `@promptbook/utils`
+ * 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
+ * @public exported from `@promptbook/markdown-utils`
  */
-function countPages(text) {
-    var sentencesPerPage = 5; // Assuming each page has 5 sentences
-    var sentences = text.split(/[.!?]+/).filter(function (sentence) { return sentence.trim() !== ''; });
-    var pageCount = Math.ceil(sentences.length / sentencesPerPage);
-    return pageCount;
+function extractOneBlockFromMarkdown(markdown) {
+    var codeBlocks = extractAllBlocksFromMarkdown(markdown);
+    if (codeBlocks.length !== 1) {
+        throw new ParsingError(_spaceTrim(function (block) { return "\n                    There should be exactly 1 code block, found ".concat(codeBlocks.length, " code blocks\n\n                    ").concat(block(codeBlocks.map(function (block, i) { return "Block ".concat(i + 1, ":\n").concat(block.content); }).join('\n\n\n')), "\n                "); }));
+    }
+    return codeBlocks[0];
 }
+/***
+ * TODO: [🍓][🌻] Decide of this is internal utility, external util OR validator/postprocessor
+ */
 
 /**
- * Counts number of paragraphs in the text
+ * Extracts 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
  *
  * @public exported from `@promptbook/utils`
  */
-function countParagraphs(text) {
-    return text.split(/\n\s*\n/).filter(function (paragraph) { return paragraph.trim() !== ''; }).length;
+function extractBlock(markdown) {
+    var content = extractOneBlockFromMarkdown(markdown).content;
+    return content;
 }
+/**
+ * TODO: [🧠][🌻] Maybe export through `@promptbook/markdown-utils` not `@promptbook/utils`
+ */
 
 /**
- * Split text into sentences
+ * Prettify the html code
  *
- * @public exported from `@promptbook/utils`
+ * @param content raw html code
+ * @returns formatted html code
+ * @private withing the package because of HUGE size of prettier dependency
  */
-function splitIntoSentences(text) {
-    return text.split(/[.!?]+/).filter(function (sentence) { return sentence.trim() !== ''; });
+function prettifyMarkdown(content) {
+    try {
+        return format(content, {
+            parser: 'markdown',
+            plugins: [parserHtml],
+            // TODO: DRY - make some import or auto-copy of .prettierrc
+            endOfLine: 'lf',
+            tabWidth: 4,
+            singleQuote: true,
+            trailingComma: 'all',
+            arrowParens: 'always',
+            printWidth: 120,
+            htmlWhitespaceSensitivity: 'ignore',
+            jsxBracketSameLine: false,
+            bracketSpacing: true,
+        });
+    }
+    catch (error) {
+        // TODO: [🟥] Detect browser / node and make it colorfull
+        console.error('There was an error with prettifying the markdown, using the original as the fallback', {
+            error: error,
+            html: content,
+        });
+        return content;
+    }
 }
+
 /**
- * Counts number of sentences in the text
+ * Makes first letter of a string uppercase
  *
  * @public exported from `@promptbook/utils`
  */
-function countSentences(text) {
-    return splitIntoSentences(text).length;
+function decapitalize(word) {
+    return word.substring(0, 1).toLowerCase() + word.substring(1);
 }
 
 var defaultDiacriticsRemovalMap = [
@@ -825,6 +1076,755 @@ function removeDiacritics(input) {
  * TODO: [Ж] Variant for cyrillic (and in general non-latin) letters
  */
 
+/**
+ * @@@
+ *
+ * @param name @@@
+ * @returns @@@
+ * @example @@@
+ * @public exported from `@promptbook/utils`
+ */
+function nameToUriPart(name) {
+    var uriPart = name;
+    uriPart = uriPart.toLowerCase();
+    uriPart = removeDiacritics(uriPart);
+    uriPart = uriPart.replace(/[^a-zA-Z0-9]+/g, '-');
+    uriPart = uriPart.replace(/^-+/, '');
+    uriPart = uriPart.replace(/-+$/, '');
+    return uriPart;
+}
+
+/**
+ * @@@
+ *
+ * @param name @@@
+ * @returns @@@
+ * @example @@@
+ * @public exported from `@promptbook/utils`
+ */
+function nameToUriParts(name) {
+    return nameToUriPart(name)
+        .split('-')
+        .filter(function (value) { return value !== ''; });
+}
+
+/**
+ * @@@
+ *
+ * @param text @@@
+ * @returns @@@
+ * @example 'hello-world'
+ * @example 'i-love-promptbook'
+ * @public exported from `@promptbook/utils`
+ */
+function normalizeToKebabCase(text) {
+    var e_1, _a;
+    text = removeDiacritics(text);
+    var charType;
+    var lastCharType = 'OTHER';
+    var normalizedName = '';
+    try {
+        for (var text_1 = __values(text), text_1_1 = text_1.next(); !text_1_1.done; text_1_1 = text_1.next()) {
+            var char = text_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 if (/^\/$/.test(char)) {
+                charType = 'SLASH';
+                normalizedChar = char;
+            }
+            else {
+                charType = 'OTHER';
+                normalizedChar = '-';
+            }
+            if (charType !== lastCharType &&
+                !(lastCharType === 'UPPERCASE' && charType === 'LOWERCASE') &&
+                !(lastCharType === 'NUMBER') &&
+                !(charType === 'NUMBER')) {
+                normalizedName += '-';
+            }
+            normalizedName += normalizedChar;
+            lastCharType = charType;
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (text_1_1 && !text_1_1.done && (_a = text_1.return)) _a.call(text_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    normalizedName = normalizedName.split(/-+/g).join('-');
+    normalizedName = normalizedName.split(/-?\/-?/g).join('/');
+    normalizedName = normalizedName.replace(/^-/, '');
+    normalizedName = normalizedName.replace(/-$/, '');
+    return normalizedName;
+}
+
+/**
+ * @@@
+ *
+ * @param text @@@
+ * @param _isFirstLetterCapital @@@
+ * @returns @@@
+ * @example 'helloWorld'
+ * @example 'iLovePromptbook'
+ * @public exported from `@promptbook/utils`
+ */
+function normalizeTo_camelCase(text, _isFirstLetterCapital) {
+    var e_1, _a;
+    if (_isFirstLetterCapital === void 0) { _isFirstLetterCapital = false; }
+    var charType;
+    var lastCharType = null;
+    var normalizedName = '';
+    try {
+        for (var text_1 = __values(text), text_1_1 = text_1.next(); !text_1_1.done; text_1_1 = text_1.next()) {
+            var char = text_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 (_isFirstLetterCapital) {
+                    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 (text_1_1 && !text_1_1.done && (_a = text_1.return)) _a.call(text_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return normalizedName;
+}
+/**
+ * TODO: [🌺] Use some intermediate util splitWords
+ */
+
+/**
+ *
+ * @param text @public exported from `@promptbook/utils`
+ * @returns
+ * @example 'HelloWorld'
+ * @example 'ILovePromptbook'
+ * @public exported from `@promptbook/utils`
+ */
+function normalizeTo_PascalCase(text) {
+    return normalizeTo_camelCase(text, true);
+}
+
+/**
+ * @@@
+ *
+ * @param text @@@
+ * @returns @@@
+ * @example 'HELLO_WORLD'
+ * @example 'I_LOVE_PROMPTBOOK'
+ * @public exported from `@promptbook/utils`
+ */
+function normalizeTo_SCREAMING_CASE(text) {
+    var e_1, _a;
+    var charType;
+    var lastCharType = 'OTHER';
+    var normalizedName = '';
+    try {
+        for (var text_1 = __values(text), text_1_1 = text_1.next(); !text_1_1.done; text_1_1 = text_1.next()) {
+            var char = text_1_1.value;
+            var normalizedChar = void 0;
+            if (/^[a-z]$/.test(char)) {
+                charType = 'LOWERCASE';
+                normalizedChar = char.toUpperCase();
+            }
+            else if (/^[A-Z]$/.test(char)) {
+                charType = 'UPPERCASE';
+                normalizedChar = char;
+            }
+            else if (/^[0-9]$/.test(char)) {
+                charType = 'NUMBER';
+                normalizedChar = char;
+            }
+            else if (/^\/$/.test(char)) {
+                charType = 'SLASH';
+                normalizedChar = char;
+            }
+            else {
+                charType = 'OTHER';
+                normalizedChar = '_';
+            }
+            if (charType !== lastCharType &&
+                !(lastCharType === 'UPPERCASE' && charType === 'LOWERCASE') &&
+                !(lastCharType === 'NUMBER') &&
+                !(charType === 'NUMBER')) {
+                normalizedName += '_';
+            }
+            normalizedName += normalizedChar;
+            lastCharType = charType;
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (text_1_1 && !text_1_1.done && (_a = text_1.return)) _a.call(text_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: Tests
+ *     > expect(encodeRoutePath({ uriId: 'VtG7sR9rRJqwNEdM2', name: 'Moje tabule' })).toEqual('/VtG7sR9rRJqwNEdM2/Moje tabule');
+ *     > expect(encodeRoutePath({ uriId: 'VtG7sR9rRJqwNEdM2', name: 'ěščřžžýáíúů' })).toEqual('/VtG7sR9rRJqwNEdM2/escrzyaieuu');
+ *     > expect(encodeRoutePath({ uriId: 'VtG7sR9rRJqwNEdM2', name: '  ahoj  ' })).toEqual('/VtG7sR9rRJqwNEdM2/ahoj');
+ *     > expect(encodeRoutePath({ uriId: 'VtG7sR9rRJqwNEdM2', name: '  ahoj_ahojAhoj    ahoj  ' })).toEqual('/VtG7sR9rRJqwNEdM2/ahoj-ahoj-ahoj-ahoj');
+ * TODO: [🌺] Use some intermediate util splitWords
+ */
+
+/**
+ * @@@
+ *
+ * @param text @@@
+ * @returns @@@
+ * @example 'hello_world'
+ * @example 'i_love_promptbook'
+ * @public exported from `@promptbook/utils`
+ */
+function normalizeTo_snake_case(text) {
+    return normalizeTo_SCREAMING_CASE(text).toLowerCase();
+}
+
+/**
+ * Take every whitespace (space, new line, tab) and replace it with a single space
+ *
+ * @public exported from `@promptbook/utils`
+ */
+function normalizeWhitespaces(sentence) {
+    return sentence.replace(/\s+/gs, ' ').trim();
+}
+
+/**
+ * Parses keywords from a string
+ *
+ * @param {string} input
+ * @returns {Set} of keywords without diacritics in lowercase
+ * @public exported from `@promptbook/utils`
+ */
+function parseKeywordsFromString(input) {
+    var keywords = normalizeTo_SCREAMING_CASE(removeDiacritics(input))
+        .toLowerCase()
+        .split(/[^a-z0-9]+/gs)
+        .filter(function (value) { return value; });
+    return new Set(keywords);
+}
+
+/**
+ * Removes emojis from a string and fix whitespaces
+ *
+ * @param text with emojis
+ * @returns text without emojis
+ * @public exported from `@promptbook/utils`
+ */
+function removeEmojis(text) {
+    // Replace emojis (and also ZWJ sequence) with hyphens
+    text = text.replace(/(\p{Extended_Pictographic})\p{Modifier_Symbol}/gu, '$1');
+    text = text.replace(/(\p{Extended_Pictographic})[\u{FE00}-\u{FE0F}]/gu, '$1');
+    text = text.replace(/(\p{Extended_Pictographic})(\u{200D}\p{Extended_Pictographic})*/gu, '$1');
+    text = text.replace(/\p{Extended_Pictographic}/gu, '');
+    return text;
+}
+
+/**
+ * Removes quotes from a string
+ *
+ * Tip: This is very usefull for post-processing of the result of the LLM model
+ * Note: This function removes only the same quotes from the beginning and the end of the string
+ * Note: There are two simmilar functions:
+ * - `removeQuotes` which removes only bounding quotes
+ * - `unwrapResult` which removes whole introduce sentence
+ *
+ * @param text optionally quoted text
+ * @returns text without quotes
+ * @public exported from `@promptbook/utils`
+ */
+function removeQuotes(text) {
+    if (text.startsWith('"') && text.endsWith('"')) {
+        return text.slice(1, -1);
+    }
+    if (text.startsWith('\'') && text.endsWith('\'')) {
+        return text.slice(1, -1);
+    }
+    return text;
+}
+
+/**
+ * Function trimCodeBlock will trim starting and ending code block from the string if it is present.
+ *
+ * Note: This is usefull for post-processing of the result of the chat LLM model
+ *       when the model wraps the result in the (markdown) code block.
+ *
+ * @public exported from `@promptbook/utils`
+ */
+function trimCodeBlock(value) {
+    value = spaceTrim(value);
+    if (!/^```[a-z]*(.*)```$/is.test(value)) {
+        return value;
+    }
+    value = value.replace(/^```[a-z]*/i, '');
+    value = value.replace(/```$/i, '');
+    value = spaceTrim(value);
+    return value;
+}
+
+/**
+ * Function trimEndOfCodeBlock will remove ending code block from the string if it is present.
+ *
+ * Note: This is usefull for post-processing of the result of the completion LLM model
+ *       if you want to start code block in the prompt but you don't want to end it in the result.
+ *
+ * @public exported from `@promptbook/utils`
+ */
+function trimEndOfCodeBlock(value) {
+    value = spaceTrim(value);
+    value = value.replace(/```$/g, '');
+    value = spaceTrim(value);
+    return value;
+}
+
+/**
+ * Removes quotes and optional introduce text from a string
+ *
+ * Tip: This is very usefull for post-processing of the result of the LLM model
+ * Note: This function trims the text and removes whole introduce sentence if it is present
+ * Note: There are two simmilar functions:
+ * - `removeQuotes` which removes only bounding quotes
+ * - `unwrapResult` which removes whole introduce sentence
+ *
+ * @param text optionally quoted text
+ * @returns text without quotes
+ * @public exported from `@promptbook/utils`
+ */
+function unwrapResult(text, options) {
+    var _a = options || {}, _b = _a.isTrimmed, isTrimmed = _b === void 0 ? true : _b, _c = _a.isIntroduceSentenceRemoved, isIntroduceSentenceRemoved = _c === void 0 ? true : _c;
+    var trimmedText = text;
+    // Remove leading and trailing spaces and newlines
+    if (isTrimmed) {
+        trimmedText = spaceTrim(trimmedText);
+    }
+    var processedText = trimmedText;
+    if (isIntroduceSentenceRemoved) {
+        var introduceSentenceRegex = /^[a-zěščřžýáíéúů:\s]*:\s*/i;
+        if (introduceSentenceRegex.test(text)) {
+            // Remove the introduce sentence and quotes by replacing it with an empty string
+            processedText = processedText.replace(introduceSentenceRegex, '');
+        }
+        processedText = spaceTrim(processedText);
+    }
+    if (processedText.length < 3) {
+        return trimmedText;
+    }
+    if (processedText.includes('\n')) {
+        return trimmedText;
+    }
+    // Remove the quotes by extracting the substring without the first and last characters
+    var unquotedText = processedText.slice(1, -1);
+    // Check if the text starts and ends with quotes
+    if ([
+        ['"', '"'],
+        ["'", "'"],
+        ['`', '`'],
+        ['*', '*'],
+        ['_', '_'],
+        ['„', '“'],
+        ['«', '»'] /* <- QUOTES to config */,
+    ].some(function (_a) {
+        var _b = __read(_a, 2), startQuote = _b[0], endQuote = _b[1];
+        if (!processedText.startsWith(startQuote)) {
+            return false;
+        }
+        if (!processedText.endsWith(endQuote)) {
+            return false;
+        }
+        if (unquotedText.includes(startQuote) && !unquotedText.includes(endQuote)) {
+            return false;
+        }
+        if (!unquotedText.includes(startQuote) && unquotedText.includes(endQuote)) {
+            return false;
+        }
+        return true;
+    })) {
+        return unwrapResult(unquotedText, { isTrimmed: false, isIntroduceSentenceRemoved: false });
+    }
+    else {
+        return processedText;
+    }
+}
+/**
+ * TODO: [🧠] Should this also unwrap the (parenthesis)
+ */
+
+/**
+ * Does nothing, but preserves the function in the bundle
+ * Compiler is tricked into thinking the function is used
+ *
+ * @param value any function to preserve
+ * @returns nothing
+ * @private internal function of `JavascriptExecutionTools` and `JavascriptEvalExecutionTools`
+ */
+function preserve(func) {
+    // Note: NOT calling the function
+    var _this = this;
+    (function () { return __awaiter(_this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: 
+                // TODO: Change to `await forEver` or something better
+                return [4 /*yield*/, forTime(100000000)];
+                case 1:
+                    // TODO: Change to `await forEver` or something better
+                    _a.sent();
+                    _a.label = 2;
+                case 2:
+                    _a.trys.push([2, , 4, 5]);
+                    return [4 /*yield*/, func()];
+                case 3:
+                    _a.sent();
+                    return [3 /*break*/, 5];
+                case 4: return [7 /*endfinally*/];
+                case 5: return [2 /*return*/];
+            }
+        });
+    }); })();
+}
+/**
+ * TODO: !! [1] This maybe does memory leak
+ */
+
+/**
+ * Converts anything to string that can be used for debugging and logging
+ *
+ * @param value String value for logging
+ * @private internal util
+ */
+function unknownToString(value) {
+    if (value === undefined) {
+        return 'undefined';
+    }
+    else if (value === null) {
+        return 'null';
+    }
+    else if (['number', 'string', 'boolean'].includes(typeof value)) {
+        return typeof value + ' ' + value.toString();
+    }
+    else if (typeof value === 'object' && Array.isArray(value)) {
+        return 'array containing [' + value.map(function (item) { return unknownToString(item); }).join(', ') + ']';
+    }
+    else if (typeof value === 'object') {
+        // TODO: Maybe serialize the object
+        return 'object';
+    }
+    else {
+        return 'unknown (Search in promptbook code for [🔹])';
+    }
+}
+
+/**
+ * ScriptExecutionTools for JavaScript implemented via eval
+ *
+ * Warning: It is used for testing and mocking
+ *          **NOT intended to use in the production** due to its unsafe nature, use `JavascriptExecutionTools` instead.
+ *
+ * @public exported from `@promptbook/execute-javascript`
+ */
+var JavascriptEvalExecutionTools = /** @class */ (function () {
+    function JavascriptEvalExecutionTools(options) {
+        this.options = options || {};
+    }
+    /**
+     * Executes a JavaScript
+     */
+    JavascriptEvalExecutionTools.prototype.execute = function (options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var scriptLanguage, parameters, script, spaceTrim, removeQuotes$1, unwrapResult$1, trimEndOfCodeBlock$1, trimCodeBlock$1, trim, reverse, removeEmojis$1, prettifyMarkdown$1, capitalize$1, decapitalize$1, nameToUriPart$1, nameToUriParts$1, removeDiacritics$1, normalizeWhitespaces$1, normalizeToKebabCase$1, normalizeTo_camelCase$1, normalizeTo_snake_case$1, normalizeTo_PascalCase$1, parseKeywords, normalizeTo_SCREAMING_CASE$1, buildinFunctions, buildinFunctionsStatement, customFunctions, customFunctionsStatement, statementToEvaluate, result, error_1, undefinedName_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        scriptLanguage = options.scriptLanguage, parameters = options.parameters;
+                        script = options.script;
+                        if (scriptLanguage !== 'javascript') {
+                            throw new PipelineExecutionError("Script language ".concat(scriptLanguage, " not supported to be executed by JavascriptEvalExecutionTools"));
+                        }
+                        spaceTrim = function (_) { return _spaceTrim(_); };
+                        preserve(spaceTrim);
+                        removeQuotes$1 = removeQuotes;
+                        preserve(removeQuotes$1);
+                        unwrapResult$1 = unwrapResult;
+                        preserve(unwrapResult$1);
+                        trimEndOfCodeBlock$1 = trimEndOfCodeBlock;
+                        preserve(trimEndOfCodeBlock$1);
+                        trimCodeBlock$1 = trimCodeBlock;
+                        preserve(trimCodeBlock$1);
+                        trim = function (str) { return str.trim(); };
+                        preserve(trim);
+                        reverse = function (str) { return str.split('').reverse().join(''); };
+                        preserve(reverse);
+                        removeEmojis$1 = removeEmojis;
+                        preserve(removeEmojis$1);
+                        prettifyMarkdown$1 = prettifyMarkdown;
+                        preserve(prettifyMarkdown$1);
+                        capitalize$1 = capitalize;
+                        decapitalize$1 = decapitalize;
+                        nameToUriPart$1 = nameToUriPart;
+                        nameToUriParts$1 = nameToUriParts;
+                        removeDiacritics$1 = removeDiacritics;
+                        normalizeWhitespaces$1 = normalizeWhitespaces;
+                        normalizeToKebabCase$1 = normalizeToKebabCase;
+                        normalizeTo_camelCase$1 = normalizeTo_camelCase;
+                        normalizeTo_snake_case$1 = normalizeTo_snake_case;
+                        normalizeTo_PascalCase$1 = normalizeTo_PascalCase;
+                        parseKeywords = function (input) {
+                            // TODO: DRY [🍯]
+                            return Array.from(parseKeywordsFromString(input)).join(', ');
+                        };
+                        normalizeTo_SCREAMING_CASE$1 = normalizeTo_SCREAMING_CASE;
+                        preserve(capitalize$1);
+                        preserve(decapitalize$1);
+                        preserve(nameToUriPart$1);
+                        preserve(nameToUriParts$1);
+                        preserve(removeDiacritics$1);
+                        preserve(normalizeWhitespaces$1);
+                        preserve(normalizeToKebabCase$1);
+                        preserve(normalizeTo_camelCase$1);
+                        preserve(normalizeTo_snake_case$1);
+                        preserve(normalizeTo_PascalCase$1);
+                        preserve(parseKeywords);
+                        preserve(normalizeTo_SCREAMING_CASE$1);
+                        //-------[/n12]---
+                        if (!script.includes('return')) {
+                            script = "return ".concat(script);
+                        }
+                        buildinFunctions = {
+                            // TODO: [🍯] DRY all these functions across the file
+                            spaceTrim: spaceTrim,
+                            removeQuotes: removeQuotes$1,
+                            unwrapResult: unwrapResult$1,
+                            trimEndOfCodeBlock: trimEndOfCodeBlock$1,
+                            trimCodeBlock: trimCodeBlock$1,
+                            trim: trim,
+                            reverse: reverse,
+                            removeEmojis: removeEmojis$1,
+                            prettifyMarkdown: prettifyMarkdown$1,
+                            capitalize: capitalize$1,
+                            decapitalize: decapitalize$1,
+                            nameToUriPart: nameToUriPart$1,
+                            nameToUriParts: nameToUriParts$1,
+                            removeDiacritics: removeDiacritics$1,
+                            normalizeWhitespaces: normalizeWhitespaces$1,
+                            normalizeToKebabCase: normalizeToKebabCase$1,
+                            normalizeTo_camelCase: normalizeTo_camelCase$1,
+                            normalizeTo_snake_case: normalizeTo_snake_case$1,
+                            normalizeTo_PascalCase: normalizeTo_PascalCase$1,
+                            parseKeywords: parseKeywords,
+                            normalizeTo_SCREAMING_CASE: normalizeTo_SCREAMING_CASE$1,
+                            extractBlock: extractBlock,
+                        };
+                        buildinFunctionsStatement = Object.keys(buildinFunctions)
+                            .map(function (functionName) {
+                            // Note: Custom functions are exposed to the current scope as variables
+                            return "const ".concat(functionName, " = buildinFunctions.").concat(functionName, ";");
+                        })
+                            .join('\n');
+                        customFunctions = this.options.functions || {};
+                        customFunctionsStatement = Object.keys(customFunctions)
+                            .map(function (functionName) {
+                            // Note: Custom functions are exposed to the current scope as variables
+                            return "const ".concat(functionName, " = customFunctions.").concat(functionName, ";");
+                        })
+                            .join('\n');
+                        statementToEvaluate = _spaceTrim(function (block) { return "\n\n                // Build-in functions:\n                ".concat(block(buildinFunctionsStatement), "\n\n                // Custom functions:\n                ").concat(block(customFunctionsStatement || '// -- No custom functions --'), "\n\n                // The script:\n                ").concat(block(Object.entries(parameters)
+                            .map(function (_a) {
+                            var _b = __read(_a, 2), key = _b[0], value = _b[1];
+                            return "const ".concat(key, " = ").concat(JSON.stringify(value), ";");
+                        })
+                            .join('\n')), "\n                (()=>{ ").concat(script, " })()\n            "); });
+                        if (this.options.isVerbose) {
+                            console.info(_spaceTrim(function (block) { return "\n                        \uD83D\uDE80 Evaluating ".concat(scriptLanguage, " script:\n\n                        ").concat(block(statementToEvaluate)); }));
+                        }
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, eval(statementToEvaluate)];
+                    case 2:
+                        result = _a.sent();
+                        if (typeof result !== 'string') {
+                            throw new PipelineExecutionError("Script must return a string, but returned ".concat(unknownToString(result)));
+                        }
+                        return [3 /*break*/, 4];
+                    case 3:
+                        error_1 = _a.sent();
+                        if (!(error_1 instanceof Error)) {
+                            throw error_1;
+                        }
+                        if (error_1 instanceof ReferenceError) {
+                            undefinedName_1 = error_1.message.split(' ')[0];
+                            /*
+                            Note: Remapping error
+                                  From: [PipelineUrlError: thing is not defined],
+                                  To:   [PipelineExecutionError: Parameter {thing} is not defined],
+                            */
+                            if (!statementToEvaluate.includes(undefinedName_1 + '(')) {
+                                throw new PipelineExecutionError(_spaceTrim(function (block) { return "\n\n                                Parameter {".concat(undefinedName_1, "} is not defined\n\n                                This happen during evaluation of the javascript, which has access to the following parameters as javascript variables:\n\n                                ").concat(block(Object.keys(parameters)
+                                    .map(function (key) { return "  - ".concat(key, "\n"); })
+                                    .join('')), "\n\n                                The script is:\n                                ```javascript\n                                ").concat(block(script), "\n                                ```\n\n                                Original error message:\n                                ").concat(block(error_1.message), "\n\n\n                            "); }));
+                            }
+                            else {
+                                throw new PipelineExecutionError(_spaceTrim(function (block) { return "\n                                  Function ".concat(undefinedName_1, "() is not defined\n\n                                  -  Make sure that the function is one of built-in functions\n                                  -  Or you have to defined the function during construction of JavascriptEvalExecutionTools\n\n                                  Original error message:\n                                  ").concat(block(error_1.message), "\n\n                            "); }));
+                            }
+                        }
+                        throw error_1;
+                    case 4:
+                        if (typeof result !== 'string') {
+                            throw new PipelineExecutionError("Script must return a string, but ".concat(unknownToString(result)));
+                        }
+                        return [2 /*return*/, result];
+                }
+            });
+        });
+    };
+    return JavascriptEvalExecutionTools;
+}());
+/**
+ * TODO: Put predefined functions (like removeQuotes, spaceTrim, etc.) into annotation OR pass into constructor
+ * TODO: [🧠][💙] Distinct between options passed into ExecutionTools and to ExecutionTools.execute
+ */
+
+/**
+ * Placeholder for better implementation of JavascriptExecutionTools - some propper sandboxing
+ *
+ * @alias JavascriptExecutionTools
+ * @public exported from `@promptbook/execute-javascript`
+ */
+var JavascriptExecutionTools = JavascriptEvalExecutionTools;
+
+/**
+ * This error occurs when some expectation is not met in the execution of the pipeline
+ *
+ * @private error of `checkExpectations` and `createPipelineExecutor`
+ * Note: Always thrown in `checkExpectations` and catched in `createPipelineExecutor` and rethrown as `PipelineExecutionError`
+ * Note: This is a kindof subtype of PipelineExecutionError
+ */
+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
+ *
+ * @public exported from `@promptbook/utils`
+ */
+function countCharacters(text) {
+    // Remove null characters
+    text = text.replace(/\0/g, '');
+    // Replace emojis (and also ZWJ sequence) with hyphens
+    text = text.replace(/(\p{Extended_Pictographic})\p{Modifier_Symbol}/gu, '$1');
+    text = text.replace(/(\p{Extended_Pictographic})[\u{FE00}-\u{FE0F}]/gu, '$1');
+    text = text.replace(/\p{Extended_Pictographic}(\u{200D}\p{Extended_Pictographic})*/gu, '-');
+    return text.length;
+}
+
+/**
+ * Counts number of lines in the text
+ *
+ * @public exported from `@promptbook/utils`
+ */
+function countLines(text) {
+    if (text === '') {
+        return 0;
+    }
+    return text.split('\n').length;
+}
+
+/**
+ * Counts number of pages in the text
+ *
+ * @public exported from `@promptbook/utils`
+ */
+function countPages(text) {
+    var sentencesPerPage = 5; // Assuming each page has 5 sentences
+    var sentences = text.split(/[.!?]+/).filter(function (sentence) { return sentence.trim() !== ''; });
+    var pageCount = Math.ceil(sentences.length / sentencesPerPage);
+    return pageCount;
+}
+
+/**
+ * Counts number of paragraphs in the text
+ *
+ * @public exported from `@promptbook/utils`
+ */
+function countParagraphs(text) {
+    return text.split(/\n\s*\n/).filter(function (paragraph) { return paragraph.trim() !== ''; }).length;
+}
+
+/**
+ * Split text into sentences
+ *
+ * @public exported from `@promptbook/utils`
+ */
+function splitIntoSentences(text) {
+    return text.split(/[.!?]+/).filter(function (sentence) { return sentence.trim() !== ''; });
+}
+/**
+ * Counts number of sentences in the text
+ *
+ * @public exported from `@promptbook/utils`
+ */
+function countSentences(text) {
+    return splitIntoSentences(text).length;
+}
+
 /**
  * Counts number of words in the text
  *
@@ -918,9 +1918,9 @@ function isPassingExpectations(expectations, value) {
  *
  * @private internal utility for MockedFackedLlmExecutionTools
  */
-function $fakeTextToExpectations(expectations, postprocessing) {
+function $fakeTextToExpectations(expectations, postprocessingFunctionNames) {
     return __awaiter(this, void 0, void 0, function () {
-        var lorem, loremText, text, loopLimit, textToCheck, _a, _b, func, e_1_1;
+        var lorem, loremText, text, loopLimit, textToCheck, scriptTools, _a, _b, postprocessingFunctionName, e_1_1;
         var e_1, _c;
         return __generator(this, function (_d) {
             switch (_d.label) {
@@ -938,15 +1938,26 @@ function $fakeTextToExpectations(expectations, postprocessing) {
                 case 1:
                     if (!(loopLimit-- > 0)) return [3 /*break*/, 11];
                     textToCheck = text;
+                    scriptTools = null;
                     _d.label = 2;
                 case 2:
                     _d.trys.push([2, 7, 8, 9]);
-                    _a = (e_1 = void 0, __values(postprocessing || [])), _b = _a.next();
+                    _a = (e_1 = void 0, __values(postprocessingFunctionNames || [])), _b = _a.next();
                     _d.label = 3;
                 case 3:
                     if (!!_b.done) return [3 /*break*/, 6];
-                    func = _b.value;
-                    return [4 /*yield*/, func(textToCheck)];
+                    postprocessingFunctionName = _b.value;
+                    if (scriptTools === null) {
+                        scriptTools = new JavascriptExecutionTools();
+                    }
+                    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(postprocessingFunctionName, "(result)"),
+                            parameters: {
+                                result: textToCheck || '',
+                                // Note: No ...parametersForTemplate, because working with result only
+                            },
+                        })];
                 case 4:
                     textToCheck = _d.sent();
                     _d.label = 5;
@@ -1047,7 +2058,7 @@ var MockedFackedLlmExecutionTools = /** @class */ (function () {
                         usage = ZERO_USAGE;
                         return [4 /*yield*/, $fakeTextToExpectations(prompt.expectations || {
                                 sentences: { min: 1, max: 1 },
-                            }, prompt.postprocessing)];
+                            }, prompt.postprocessingFunctionNames)];
                     case 1:
                         content = _a.sent();
                         result = {
@@ -1068,7 +2079,7 @@ var MockedFackedLlmExecutionTools = /** @class */ (function () {
                         if (this.options.isVerbose) {
                             console.info('💬 Mocked faked result', result);
                         }
-                        return [2 /*return*/, result];
+                        return [2 /*return*/, $asDeeplyFrozenSerializableJson('MockedFackedLlmExecutionTools (ChatPromptResult or CompletionPromptResult)', result)];
                 }
             });
         });
@@ -1116,7 +2127,7 @@ var MockedFackedLlmExecutionTools = /** @class */ (function () {
                 if (this.options.isVerbose) {
                     console.info('💬 Mocked faked result', result);
                 }
-                return [2 /*return*/, result];
+                return [2 /*return*/, $asDeeplyFrozenSerializableJson('MockedFackedLlmExecutionTools EmbeddingPromptResult', result)];
             });
         });
     };