@promptbook/node 0.56.0-3

package/umd/index.umd.js

@@ -0,0 +1,2501 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('fs/promises'), require('path'), require('spacetrim'), require('prettier'), require('prettier/parser-html')) :
+    typeof define === 'function' && define.amd ? define(['exports', 'fs/promises', 'path', 'spacetrim', 'prettier', 'prettier/parser-html'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["promptbook-node"] = {}, global.promises, global.path, global.spaceTrim, global.prettier, global.parserHtml));
+})(this, (function (exports, promises, path, spaceTrim, prettier, parserHtml) { 'use strict';
+
+    function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+    var spaceTrim__default = /*#__PURE__*/_interopDefaultLegacy(spaceTrim);
+    var parserHtml__default = /*#__PURE__*/_interopDefaultLegacy(parserHtml);
+
+    /*! *****************************************************************************
+    Copyright (c) Microsoft Corporation.
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose with or without fee is hereby granted.
+
+    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+    PERFORMANCE OF THIS SOFTWARE.
+    ***************************************************************************** */
+    /* global Reflect, Promise */
+
+    var extendStatics = function(d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+
+    function __extends(d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    }
+
+    var __assign = function() {
+        __assign = Object.assign || function __assign(t) {
+            for (var s, i = 1, n = arguments.length; i < n; i++) {
+                s = arguments[i];
+                for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+            }
+            return t;
+        };
+        return __assign.apply(this, arguments);
+    };
+
+    function __awaiter(thisArg, _arguments, P, generator) {
+        function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+        return new (P || (P = Promise))(function (resolve, reject) {
+            function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+            function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+            function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+            step((generator = generator.apply(thisArg, _arguments || [])).next());
+        });
+    }
+
+    function __generator(thisArg, body) {
+        var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+        return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+        function verb(n) { return function (v) { return step([n, v]); }; }
+        function step(op) {
+            if (f) throw new TypeError("Generator is already executing.");
+            while (_) try {
+                if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+                if (y = 0, t) op = [op[0] & 2, t.value];
+                switch (op[0]) {
+                    case 0: case 1: t = op; break;
+                    case 4: _.label++; return { value: op[1], done: false };
+                    case 5: _.label++; y = op[1]; op = [0]; continue;
+                    case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                    default:
+                        if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                        if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                        if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                        if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                        if (t[2]) _.ops.pop();
+                        _.trys.pop(); continue;
+                }
+                op = body.call(thisArg, _);
+            } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+            if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+        }
+    }
+
+    function __values(o) {
+        var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+        if (m) return m.call(o);
+        if (o && typeof o.length === "number") return {
+            next: function () {
+                if (o && i >= o.length) o = void 0;
+                return { value: o && o[i++], done: !o };
+            }
+        };
+        throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+    }
+
+    function __read(o, n) {
+        var m = typeof Symbol === "function" && o[Symbol.iterator];
+        if (!m) return o;
+        var i = m.call(o), r, ar = [], e;
+        try {
+            while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+        }
+        catch (error) { e = { error: error }; }
+        finally {
+            try {
+                if (r && !r.done && (m = i["return"])) m.call(i);
+            }
+            finally { if (e) throw e.error; }
+        }
+        return ar;
+    }
+
+    function __spreadArray(to, from, pack) {
+        if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+            if (ar || !(i in from)) {
+                if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+                ar[i] = from[i];
+            }
+        }
+        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'];
+
+    /**
+     * 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
+     */
+    var UnexpectedError = /** @class */ (function (_super) {
+        __extends(UnexpectedError, _super);
+        function UnexpectedError(message) {
+            var _this = _super.call(this, spaceTrim.spaceTrim(function (block) { return "\n                    ".concat(block(message), "\n\n                    Note: This error should not happen.\n                    It's probbably a bug in the promptbook library\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));
+
+    /**
+     * 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.spaceTrim("\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.spaceTrim(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.
+     *
+     * @param {string} content - The string to remove comments from.
+     * @returns {string} The input string with all comments removed.
+     */
+    function removeContentComments(content) {
+        return spaceTrim.spaceTrim(content.replace(/<!--(.*?)-->/gs, ''));
+    }
+
+    /**
+     * Creates a new set with all elements that are present in either set
+     */
+    function union() {
+        var e_1, _a, e_2, _b;
+        var sets = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            sets[_i] = arguments[_i];
+        }
+        var union = new Set();
+        try {
+            for (var sets_1 = __values(sets), sets_1_1 = sets_1.next(); !sets_1_1.done; sets_1_1 = sets_1.next()) {
+                var set = sets_1_1.value;
+                try {
+                    for (var _c = (e_2 = void 0, __values(Array.from(set))), _d = _c.next(); !_d.done; _d = _c.next()) {
+                        var item = _d.value;
+                        union.add(item);
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (sets_1_1 && !sets_1_1.done && (_a = sets_1.return)) _a.call(sets_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return union;
+    }
+
+    /**
+     * The version of the Promptbook library
+     */
+    var PROMPTBOOK_VERSION = '0.56.0-2';
+
+    /**
+     * 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
+     */
+    function extractParameters(template) {
+        var e_1, _a;
+        var matches = template.matchAll(/{\w+}/g);
+        var parameterNames = new Set();
+        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);
+                parameterNames.add(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;
+    }
+
+    /**
+     * 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
+     */
+    function extractVariables(script) {
+        var variables = new Set();
+        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.add(undefinedName);
+                        script = "const ".concat(undefinedName, " = '';") + script;
+                    }
+                }
+        }
+        catch (error) {
+            if (!(error instanceof Error)) {
+                throw error;
+            }
+            throw new PromptbookSyntaxError(spaceTrim.spaceTrim(function (block) { return "\n                    Can not extract variables from the script\n\n                    ".concat(block(error.name), ": ").concat(block(error.message), "\n                "); }));
+        }
+        return variables;
+    }
+    /**
+     * TODO: [🔣] Support for multiple languages - python, java,...
+     */
+
+    /**
+     * Parses the prompt template and returns the set of all used parameters
+     *
+     * @param promptTemplate the template with used parameters
+     * @returns the set of parameter names
+     * @throws {PromptbookSyntaxError} if the script is invalid
+     */
+    function extractParametersFromPromptTemplate(promptTemplate) {
+        var e_1, _a, e_2, _b;
+        var parameterNames = new Set();
+        try {
+            for (var _c = __values(__spreadArray(__spreadArray(__spreadArray([], __read(extractParameters(promptTemplate.title)), false), __read(extractParameters(promptTemplate.description || '')), false), __read(extractParameters(promptTemplate.content)), false)), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var parameterName = _d.value;
+                parameterNames.add(parameterName);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        if (promptTemplate.executionType === 'SCRIPT') {
+            try {
+                for (var _e = __values(extractVariables(promptTemplate.content)), _f = _e.next(); !_f.done; _f = _e.next()) {
+                    var parameterName = _f.value;
+                    parameterNames.add(parameterName);
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+        }
+        return parameterNames;
+    }
+    /**
+     * TODO: [🔣] If script require contentLanguage
+     */
+
+    /* tslint:disable */
+    /*
+    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');
+    */
+    function normalizeTo_SCREAMING_CASE(sentence) {
+        var e_1, _a;
+        var charType;
+        var lastCharType = 'OTHER';
+        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.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 (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
+     */
+
+    /**
+     * 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', 'LINES', 'PARAGRAPHS', 'PAGES'];
+    /**
+     * TODO: [💝] Unite object for expecting amount and format - remove expectFormat
+     * TODO: use one helper type> (string_prompt | string_javascript | string_markdown) & string_template
+     * TODO: [👙][🧠] Just selecting gpt3 or gpt4 level of model
+     */
+
+    /**
+     * 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;
+    }
+
+    /**
+     * Function parseNumber will parse number from string
+     *
+     * Unlike Number.parseInt, Number.parseFloat it will never ever result in NaN
+     * Note: it also works only with decimal numbers
+     *
+     * @returns parsed number
+     * @throws {PromptbookSyntaxError} if the value is not a number
+     *
+     * @private within the parseCommand
+     */
+    function parseNumber(value) {
+        var originalValue = value;
+        if (typeof value === 'number') {
+            value = value.toString(); // <- TODO: Maybe more efficient way to do this
+        }
+        if (typeof value !== 'string') {
+            return 0;
+        }
+        value = value.trim();
+        if (value.startsWith('+')) {
+            return parseNumber(value.substring(1));
+        }
+        if (value.startsWith('-')) {
+            var number = parseNumber(value.substring(1));
+            if (number === 0) {
+                return 0; // <- Note: To prevent -0
+            }
+            return -number;
+        }
+        value = value.replace(/,/g, '.');
+        value = value.toUpperCase();
+        if (value === '') {
+            return 0;
+        }
+        if (value === '♾' || value.startsWith('INF')) {
+            return Infinity;
+        }
+        if (value.includes('/')) {
+            var _a = __read(value.split('/'), 2), numerator_ = _a[0], denominator_ = _a[1];
+            var numerator = parseNumber(numerator_);
+            var denominator = parseNumber(denominator_);
+            if (denominator === 0) {
+                throw new PromptbookSyntaxError("Unable to parse number from \"".concat(originalValue, "\" because denominator is zero"));
+            }
+            return numerator / denominator;
+        }
+        if (/^(NAN|NULL|NONE|UNDEFINED|ZERO|NO.*)$/.test(value)) {
+            return 0;
+        }
+        if (value.includes('E')) {
+            var _b = __read(value.split('E'), 2), significand = _b[0], exponent = _b[1];
+            return parseNumber(significand) * Math.pow(10, parseNumber(exponent));
+        }
+        if (!/^[0-9.]+$/.test(value) || value.split('.').length > 2) {
+            throw new PromptbookSyntaxError("Unable to parse number from \"".concat(originalValue, "\""));
+        }
+        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
+     */
+
+    /**
+     * Parses one line of ul/ol to command
+     *
+     * @returns parsed command object
+     * @throws {PromptbookSyntaxError} if the command is invalid
+     *
+     * @private within the promptbookStringToJson
+     */
+    function parseCommand(listItem) {
+        var e_1, _a;
+        if (listItem.includes('\n') || listItem.includes('\r')) {
+            throw new PromptbookSyntaxError('Command can not contain new line characters:');
+        }
+        var type = listItem.trim();
+        type = type.split('`').join('');
+        type = type.split('"').join('');
+        type = type.split("'").join('');
+        type = type.split('~').join('');
+        type = type.split('[').join('');
+        type = type.split(']').join('');
+        type = type.split('(').join('');
+        type = type.split(')').join('');
+        type = normalizeTo_SCREAMING_CASE(type);
+        type = type.split('DIALOGUE').join('DIALOG');
+        var listItemParts = listItem
+            .split(' ')
+            .map(function (part) { return part.trim(); })
+            .filter(function (item) { return item !== ''; })
+            .filter(function (item) { return !/^PTBK$/i.test(item); })
+            .filter(function (item) { return !/^PROMPTBOOK$/i.test(item); })
+            .map(removeMarkdownFormatting);
+        if (type.startsWith('URL') ||
+            type.startsWith('PTBK_URL') ||
+            type.startsWith('PTBKURL') ||
+            type.startsWith('PROMPTBOOK_URL') ||
+            type.startsWith('PROMPTBOOKURL') ||
+            type.startsWith('HTTPS')) {
+            if (!(listItemParts.length === 2 || (listItemParts.length === 1 && type.startsWith('HTTPS')))) {
+                throw new PromptbookSyntaxError(spaceTrim.spaceTrim("\n                        Invalid PROMPTBOOK_URL command:\n\n                        - ".concat(listItem, "\n                    ")));
+            }
+            var promptbookUrlString = listItemParts.pop();
+            var promptbookUrl = new URL(promptbookUrlString);
+            if (promptbookUrl.protocol !== 'https:') {
+                throw new PromptbookSyntaxError(spaceTrim.spaceTrim("\n                        Invalid PROMPTBOOK_URL command:\n\n                        - ".concat(listItem, "\n\n                        Protocol must be HTTPS\n                    ")));
+            }
+            if (promptbookUrl.hash !== '') {
+                throw new PromptbookSyntaxError(spaceTrim.spaceTrim("\n                        Invalid PROMPTBOOK_URL command:\n\n                        - ".concat(listItem, "\n\n                        URL must not contain hash\n                        Hash is used for identification of the prompt template in the pipeline\n                    ")));
+            }
+            return {
+                type: 'PROMPTBOOK_URL',
+                promptbookUrl: promptbookUrl,
+            };
+        }
+        else if (type.startsWith('PROMPTBOOK_VERSION') || type.startsWith('PTBK_VERSION')) {
+            if (listItemParts.length !== 2) {
+                throw new PromptbookSyntaxError(spaceTrim.spaceTrim("\n                        Invalid PROMPTBOOK_VERSION command:\n\n                        - ".concat(listItem, "\n                    ")));
+            }
+            var promptbookVersion = listItemParts.pop();
+            // TODO: Validate version
+            return {
+                type: 'PROMPTBOOK_VERSION',
+                promptbookVersion: promptbookVersion,
+            };
+        }
+        else if (type.startsWith('EXECUTE') ||
+            type.startsWith('EXEC') ||
+            type.startsWith('PROMPT_DIALOG') ||
+            type.startsWith('SIMPLE_TEMPLATE')) {
+            var executionTypes = ExecutionTypes.filter(function (executionType) { return type.includes(executionType); });
+            if (executionTypes.length !== 1) {
+                throw new PromptbookSyntaxError(spaceTrim.spaceTrim(function (block) { return "\n                        Unknown execution type in command:\n\n                        - ".concat(listItem, "\n\n                        Supported execution types are:\n                        ").concat(block(ExecutionTypes.join(', ')), "\n                    "); }));
+            }
+            return {
+                type: 'EXECUTE',
+                executionType: executionTypes[0],
+            };
+        }
+        else if (type.startsWith('MODEL')) {
+            // TODO: Make this more elegant and dynamically
+            if (type.startsWith('MODEL_VARIANT')) {
+                if (type === 'MODEL_VARIANT_CHAT') {
+                    return {
+                        type: 'MODEL',
+                        key: 'modelVariant',
+                        value: 'CHAT',
+                    };
+                }
+                else if (type === 'MODEL_VARIANT_COMPLETION') {
+                    return {
+                        type: 'MODEL',
+                        key: 'modelVariant',
+                        value: 'COMPLETION',
+                    };
+                }
+                else {
+                    throw new PromptbookSyntaxError(spaceTrim.spaceTrim(function (block) { return "\n                            Unknown model variant in command:\n\n                            - ".concat(listItem, "\n\n                            Supported variants are:\n                            ").concat(block(['CHAT', 'COMPLETION'].join(', ')), "\n                        "); }));
+                }
+            }
+            if (type.startsWith('MODEL_NAME')) {
+                return {
+                    type: 'MODEL',
+                    key: 'modelName',
+                    value: listItemParts.pop(),
+                };
+            }
+            else {
+                throw new PromptbookSyntaxError(spaceTrim.spaceTrim(function (block) { return "\n                          Unknown model key in command:\n\n                          - ".concat(listItem, "\n\n                          Supported model keys are:\n                          ").concat(block(['variant', 'name'].join(', ')), "\n\n                          Example:\n\n                          - MODEL VARIANT Chat\n                          - MODEL NAME gpt-4\n                    "); }));
+            }
+        }
+        else if (type.startsWith('PARAM') ||
+            type.startsWith('INPUT_PARAM') ||
+            type.startsWith('OUTPUT_PARAM') ||
+            listItem.startsWith('{') ||
+            listItem.startsWith('> {') /* <- Note: This is a bit hack to parse return parameters defined at the end of each section */) {
+            var parametersMatch = listItem.match(/\{(?<parameterName>[a-z0-9_]+)\}[^\S\r\n]*(?<parameterDescription>.*)$/im);
+            if (!parametersMatch || !parametersMatch.groups || !parametersMatch.groups.parameterName) {
+                throw new PromptbookSyntaxError(spaceTrim.spaceTrim("\n                        Invalid parameter in command:\n\n                        - ".concat(listItem, "\n                    ")));
+            }
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            var _b = parametersMatch.groups, parameterName = _b.parameterName, parameterDescription = _b.parameterDescription;
+            if (parameterDescription && parameterDescription.match(/\{(?<parameterName>[a-z0-9_]+)\}/im)) {
+                throw new PromptbookSyntaxError(spaceTrim.spaceTrim("\n                        Parameter {".concat(parameterName, "} can not contain another parameter in description:\n\n                        - ").concat(listItem, "\n                    ")));
+            }
+            var isInput = type.startsWith('INPUT');
+            var isOutput = type.startsWith('OUTPUT');
+            if (listItem.startsWith('> {')) {
+                isInput = false;
+                isOutput = false;
+            }
+            return {
+                type: 'PARAMETER',
+                parameterName: parameterName,
+                parameterDescription: parameterDescription.trim() || null,
+                isInput: isInput,
+                isOutput: isOutput,
+            };
+        }
+        else if (type.startsWith('JOKER')) {
+            if (listItemParts.length !== 2) {
+                throw new PromptbookSyntaxError(spaceTrim.spaceTrim("\n                Invalid JOKER command:\n\n                - ".concat(listItem, "\n            ")));
+            }
+            var parametersMatch = (listItemParts.pop() || '').match(/^\{(?<parameterName>[a-z0-9_]+)\}$/im);
+            if (!parametersMatch || !parametersMatch.groups || !parametersMatch.groups.parameterName) {
+                throw new PromptbookSyntaxError(spaceTrim.spaceTrim("\n                      Invalid parameter in command:\n\n                      - ".concat(listItem, "\n                  ")));
+            }
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            var parameterName = parametersMatch.groups.parameterName;
+            return {
+                type: 'JOKER',
+                parameterName: parameterName,
+            };
+        }
+        else if (type.startsWith('POSTPROCESS') || type.startsWith('POST_PROCESS')) {
+            if (listItemParts.length !== 2) {
+                throw new PromptbookSyntaxError(spaceTrim.spaceTrim("\n                Invalid POSTPROCESSING command:\n\n                - ".concat(listItem, "\n            ")));
+            }
+            var functionName = listItemParts.pop();
+            return {
+                type: 'POSTPROCESS',
+                functionName: functionName,
+            };
+        }
+        else if (type.startsWith('EXPECT_JSON')) {
+            return {
+                type: 'EXPECT_FORMAT',
+                format: 'JSON',
+            };
+            // [🥤]
+        }
+        else if (type.startsWith('EXPECT')) {
+            try {
+                listItemParts.shift();
+                var sign = void 0;
+                var signRaw = listItemParts.shift();
+                if (/^exact/i.test(signRaw)) {
+                    sign = 'EXACTLY';
+                }
+                else if (/^min/i.test(signRaw)) {
+                    sign = 'MINIMUM';
+                }
+                else if (/^max/i.test(signRaw)) {
+                    sign = 'MAXIMUM';
+                }
+                else {
+                    throw new PromptbookSyntaxError("Invalid sign \"".concat(signRaw, "\", expected EXACTLY, MIN or MAX"));
+                }
+                var amountRaw = listItemParts.shift();
+                var amount = parseNumber(amountRaw);
+                if (amount < 0) {
+                    throw new PromptbookSyntaxError('Amount must be positive number or zero');
+                }
+                if (amount !== Math.floor(amount)) {
+                    throw new PromptbookSyntaxError('Amount must be whole number');
+                }
+                var unitRaw = listItemParts.shift();
+                var unit = undefined;
+                try {
+                    for (var EXPECTATION_UNITS_1 = __values(EXPECTATION_UNITS), EXPECTATION_UNITS_1_1 = EXPECTATION_UNITS_1.next(); !EXPECTATION_UNITS_1_1.done; EXPECTATION_UNITS_1_1 = EXPECTATION_UNITS_1.next()) {
+                        var existingUnit = EXPECTATION_UNITS_1_1.value;
+                        var existingUnitText = existingUnit;
+                        existingUnitText = existingUnitText.substring(0, existingUnitText.length - 1);
+                        if (existingUnitText === 'CHARACTER') {
+                            existingUnitText = 'CHAR';
+                        }
+                        if (new RegExp("^".concat(existingUnitText.toLowerCase())).test(unitRaw.toLowerCase()) ||
+                            new RegExp("^".concat(unitRaw.toLowerCase())).test(existingUnitText.toLowerCase())) {
+                            if (unit !== undefined) {
+                                throw new PromptbookSyntaxError("Ambiguous unit \"".concat(unitRaw, "\""));
+                            }
+                            unit = existingUnit;
+                        }
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (EXPECTATION_UNITS_1_1 && !EXPECTATION_UNITS_1_1.done && (_a = EXPECTATION_UNITS_1.return)) _a.call(EXPECTATION_UNITS_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+                if (unit === undefined) {
+                    throw new PromptbookSyntaxError("Invalid unit \"".concat(unitRaw, "\""));
+                }
+                return {
+                    type: 'EXPECT_AMOUNT',
+                    sign: sign,
+                    unit: unit,
+                    amount: amount,
+                };
+            }
+            catch (error) {
+                if (!(error instanceof Error)) {
+                    throw error;
+                }
+                throw new PromptbookSyntaxError(spaceTrim.spaceTrim("\n                  Invalid EXPECT command; ".concat(error.message, ":\n\n                  - ").concat(listItem, "\n              ")));
+            }
+            /*
+        } else if (type.startsWith('__________________')) {
+            // <- [🥻] Insert here when making new command
+        */
+        }
+        else {
+            throw new PromptbookSyntaxError(spaceTrim.spaceTrim("\n                    Unknown command:\n\n                    - ".concat(listItem, "\n\n                    Supported commands are:\n                    - PROMPTBOOK_URL <url>\n                    - PROMPTBOOK_VERSION <version>\n                    - EXECUTE PROMPT TEMPLATE\n                    - EXECUTE SIMPLE TEMPLATE\n                    -         SIMPLE TEMPLATE\n                    - EXECUTE SCRIPT\n                    - EXECUTE PROMPT_DIALOG'\n                    -         PROMPT_DIALOG'\n                    - MODEL NAME <name>\n                    - MODEL VARIANT <\"Chat\"|\"Completion\">\n                    - INPUT  PARAM {<name>} <description>\n                    - OUTPUT PARAM {<name>} <description>\n                    - POSTPROCESS `{functionName}`\n                    - JOKER {<name>}\n                    - EXPECT JSON\n                    - EXPECT <\"Exactly\"|\"Min\"|\"Max\"> <number> <\"Chars\"|\"Words\"|\"Sentences\"|\"Paragraphs\"|\"Pages\">\n\n                ")));
+        }
+    }
+
+    var defaultDiacriticsRemovalMap = [
+        {
+            base: 'A',
+            letters: '\u0041\u24B6\uFF21\u00C0\u00C1\u00C2\u1EA6\u1EA4\u1EAA\u1EA8\u00C3\u0100\u0102\u1EB0\u1EAE\u1EB4\u1EB2\u0226\u01E0\u00C4\u01DE\u1EA2\u00C5\u01FA\u01CD\u0200\u0202\u1EA0\u1EAC\u1EB6\u1E00\u0104\u023A\u2C6F',
+        },
+        { base: 'AA', letters: '\uA732' },
+        { base: 'AE', letters: '\u00C6\u01FC\u01E2' },
+        { base: 'AO', letters: '\uA734' },
+        { base: 'AU', letters: '\uA736' },
+        { base: 'AV', letters: '\uA738\uA73A' },
+        { base: 'AY', letters: '\uA73C' },
+        {
+            base: 'B',
+            letters: '\u0042\u24B7\uFF22\u1E02\u1E04\u1E06\u0243\u0182\u0181',
+        },
+        {
+            base: 'C',
+            letters: '\u0043\u24B8\uFF23\u0106\u0108\u010A\u010C\u00C7\u1E08\u0187\u023B\uA73E',
+        },
+        {
+            base: 'D',
+            letters: '\u0044\u24B9\uFF24\u1E0A\u010E\u1E0C\u1E10\u1E12\u1E0E\u0110\u018B\u018A\u0189\uA779\u00D0',
+        },
+        { base: 'DZ', letters: '\u01F1\u01C4' },
+        { base: 'Dz', letters: '\u01F2\u01C5' },
+        {
+            base: 'E',
+            letters: '\u0045\u24BA\uFF25\u00C8\u00C9\u00CA\u1EC0\u1EBE\u1EC4\u1EC2\u1EBC\u0112\u1E14\u1E16\u0114\u0116\u00CB\u1EBA\u011A\u0204\u0206\u1EB8\u1EC6\u0228\u1E1C\u0118\u1E18\u1E1A\u0190\u018E',
+        },
+        { base: 'F', letters: '\u0046\u24BB\uFF26\u1E1E\u0191\uA77B' },
+        {
+            base: 'G',
+            letters: '\u0047\u24BC\uFF27\u01F4\u011C\u1E20\u011E\u0120\u01E6\u0122\u01E4\u0193\uA7A0\uA77D\uA77E',
+        },
+        {
+            base: 'H',
+            letters: '\u0048\u24BD\uFF28\u0124\u1E22\u1E26\u021E\u1E24\u1E28\u1E2A\u0126\u2C67\u2C75\uA78D',
+        },
+        {
+            base: 'I',
+            letters: '\u0049\u24BE\uFF29\u00CC\u00CD\u00CE\u0128\u012A\u012C\u0130\u00CF\u1E2E\u1EC8\u01CF\u0208\u020A\u1ECA\u012E\u1E2C\u0197',
+        },
+        { base: 'J', letters: '\u004A\u24BF\uFF2A\u0134\u0248' },
+        {
+            base: 'K',
+            letters: '\u004B\u24C0\uFF2B\u1E30\u01E8\u1E32\u0136\u1E34\u0198\u2C69\uA740\uA742\uA744\uA7A2',
+        },
+        {
+            base: 'L',
+            letters: '\u004C\u24C1\uFF2C\u013F\u0139\u013D\u1E36\u1E38\u013B\u1E3C\u1E3A\u0141\u023D\u2C62\u2C60\uA748\uA746\uA780',
+        },
+        { base: 'LJ', letters: '\u01C7' },
+        { base: 'Lj', letters: '\u01C8' },
+        { base: 'M', letters: '\u004D\u24C2\uFF2D\u1E3E\u1E40\u1E42\u2C6E\u019C' },
+        {
+            base: 'N',
+            letters: '\u004E\u24C3\uFF2E\u01F8\u0143\u00D1\u1E44\u0147\u1E46\u0145\u1E4A\u1E48\u0220\u019D\uA790\uA7A4',
+        },
+        { base: 'NJ', letters: '\u01CA' },
+        { base: 'Nj', letters: '\u01CB' },
+        {
+            base: 'O',
+            letters: '\u004F\u24C4\uFF2F\u00D2\u00D3\u00D4\u1ED2\u1ED0\u1ED6\u1ED4\u00D5\u1E4C\u022C\u1E4E\u014C\u1E50\u1E52\u014E\u022E\u0230\u00D6\u022A\u1ECE\u0150\u01D1\u020C\u020E\u01A0\u1EDC\u1EDA\u1EE0\u1EDE\u1EE2\u1ECC\u1ED8\u01EA\u01EC\u00D8\u01FE\u0186\u019F\uA74A\uA74C',
+        },
+        { base: 'OI', letters: '\u01A2' },
+        { base: 'OO', letters: '\uA74E' },
+        { base: 'OU', letters: '\u0222' },
+        { base: 'OE', letters: '\u008C\u0152' },
+        { base: 'oe', letters: '\u009C\u0153' },
+        {
+            base: 'P',
+            letters: '\u0050\u24C5\uFF30\u1E54\u1E56\u01A4\u2C63\uA750\uA752\uA754',
+        },
+        { base: 'Q', letters: '\u0051\u24C6\uFF31\uA756\uA758\u024A' },
+        {
+            base: 'R',
+            letters: '\u0052\u24C7\uFF32\u0154\u1E58\u0158\u0210\u0212\u1E5A\u1E5C\u0156\u1E5E\u024C\u2C64\uA75A\uA7A6\uA782',
+        },
+        {
+            base: 'S',
+            letters: '\u0053\u24C8\uFF33\u1E9E\u015A\u1E64\u015C\u1E60\u0160\u1E66\u1E62\u1E68\u0218\u015E\u2C7E\uA7A8\uA784',
+        },
+        {
+            base: 'T',
+            letters: '\u0054\u24C9\uFF34\u1E6A\u0164\u1E6C\u021A\u0162\u1E70\u1E6E\u0166\u01AC\u01AE\u023E\uA786',
+        },
+        { base: 'TZ', letters: '\uA728' },
+        {
+            base: 'U',
+            letters: '\u0055\u24CA\uFF35\u00D9\u00DA\u00DB\u0168\u1E78\u016A\u1E7A\u016C\u00DC\u01DB\u01D7\u01D5\u01D9\u1EE6\u016E\u0170\u01D3\u0214\u0216\u01AF\u1EEA\u1EE8\u1EEE\u1EEC\u1EF0\u1EE4\u1E72\u0172\u1E76\u1E74\u0244',
+        },
+        { base: 'V', letters: '\u0056\u24CB\uFF36\u1E7C\u1E7E\u01B2\uA75E\u0245' },
+        { base: 'VY', letters: '\uA760' },
+        {
+            base: 'W',
+            letters: '\u0057\u24CC\uFF37\u1E80\u1E82\u0174\u1E86\u1E84\u1E88\u2C72',
+        },
+        { base: 'X', letters: '\u0058\u24CD\uFF38\u1E8A\u1E8C' },
+        {
+            base: 'Y',
+            letters: '\u0059\u24CE\uFF39\u1EF2\u00DD\u0176\u1EF8\u0232\u1E8E\u0178\u1EF6\u1EF4\u01B3\u024E\u1EFE',
+        },
+        {
+            base: 'Z',
+            letters: '\u005A\u24CF\uFF3A\u0179\u1E90\u017B\u017D\u1E92\u1E94\u01B5\u0224\u2C7F\u2C6B\uA762',
+        },
+        {
+            base: 'a',
+            letters: '\u0061\u24D0\uFF41\u1E9A\u00E0\u00E1\u00E2\u1EA7\u1EA5\u1EAB\u1EA9\u00E3\u0101\u0103\u1EB1\u1EAF\u1EB5\u1EB3\u0227\u01E1\u00E4\u01DF\u1EA3\u00E5\u01FB\u01CE\u0201\u0203\u1EA1\u1EAD\u1EB7\u1E01\u0105\u2C65\u0250',
+        },
+        { base: 'aa', letters: '\uA733' },
+        { base: 'ae', letters: '\u00E6\u01FD\u01E3' },
+        { base: 'ao', letters: '\uA735' },
+        { base: 'au', letters: '\uA737' },
+        { base: 'av', letters: '\uA739\uA73B' },
+        { base: 'ay', letters: '\uA73D' },
+        {
+            base: 'b',
+            letters: '\u0062\u24D1\uFF42\u1E03\u1E05\u1E07\u0180\u0183\u0253',
+        },
+        {
+            base: 'c',
+            letters: '\u0063\u24D2\uFF43\u0107\u0109\u010B\u010D\u00E7\u1E09\u0188\u023C\uA73F\u2184',
+        },
+        {
+            base: 'd',
+            letters: '\u0064\u24D3\uFF44\u1E0B\u010F\u1E0D\u1E11\u1E13\u1E0F\u0111\u018C\u0256\u0257\uA77A',
+        },
+        { base: 'dz', letters: '\u01F3\u01C6' },
+        {
+            base: 'e',
+            letters: '\u0065\u24D4\uFF45\u00E8\u00E9\u00EA\u1EC1\u1EBF\u1EC5\u1EC3\u1EBD\u0113\u1E15\u1E17\u0115\u0117\u00EB\u1EBB\u011B\u0205\u0207\u1EB9\u1EC7\u0229\u1E1D\u0119\u1E19\u1E1B\u0247\u025B\u01DD',
+        },
+        { base: 'f', letters: '\u0066\u24D5\uFF46\u1E1F\u0192\uA77C' },
+        {
+            base: 'g',
+            letters: '\u0067\u24D6\uFF47\u01F5\u011D\u1E21\u011F\u0121\u01E7\u0123\u01E5\u0260\uA7A1\u1D79\uA77F',
+        },
+        {
+            base: 'h',
+            letters: '\u0068\u24D7\uFF48\u0125\u1E23\u1E27\u021F\u1E25\u1E29\u1E2B\u1E96\u0127\u2C68\u2C76\u0265',
+        },
+        { base: 'hv', letters: '\u0195' },
+        {
+            base: 'i',
+            letters: '\u0069\u24D8\uFF49\u00EC\u00ED\u00EE\u0129\u012B\u012D\u00EF\u1E2F\u1EC9\u01D0\u0209\u020B\u1ECB\u012F\u1E2D\u0268\u0131',
+        },
+        { base: 'j', letters: '\u006A\u24D9\uFF4A\u0135\u01F0\u0249' },
+        {
+            base: 'k',
+            letters: '\u006B\u24DA\uFF4B\u1E31\u01E9\u1E33\u0137\u1E35\u0199\u2C6A\uA741\uA743\uA745\uA7A3',
+        },
+        {
+            base: 'l',
+            letters: '\u006C\u24DB\uFF4C\u0140\u013A\u013E\u1E37\u1E39\u013C\u1E3D\u1E3B\u017F\u0142\u019A\u026B\u2C61\uA749\uA781\uA747',
+        },
+        { base: 'lj', letters: '\u01C9' },
+        { base: 'm', letters: '\u006D\u24DC\uFF4D\u1E3F\u1E41\u1E43\u0271\u026F' },
+        {
+            base: 'n',
+            letters: '\u006E\u24DD\uFF4E\u01F9\u0144\u00F1\u1E45\u0148\u1E47\u0146\u1E4B\u1E49\u019E\u0272\u0149\uA791\uA7A5',
+        },
+        { base: 'nj', letters: '\u01CC' },
+        {
+            base: 'o',
+            letters: '\u006F\u24DE\uFF4F\u00F2\u00F3\u00F4\u1ED3\u1ED1\u1ED7\u1ED5\u00F5\u1E4D\u022D\u1E4F\u014D\u1E51\u1E53\u014F\u022F\u0231\u00F6\u022B\u1ECF\u0151\u01D2\u020D\u020F\u01A1\u1EDD\u1EDB\u1EE1\u1EDF\u1EE3\u1ECD\u1ED9\u01EB\u01ED\u00F8\u01FF\u0254\uA74B\uA74D\u0275',
+        },
+        { base: 'oi', letters: '\u01A3' },
+        { base: 'ou', letters: '\u0223' },
+        { base: 'oo', letters: '\uA74F' },
+        {
+            base: 'p',
+            letters: '\u0070\u24DF\uFF50\u1E55\u1E57\u01A5\u1D7D\uA751\uA753\uA755',
+        },
+        { base: 'q', letters: '\u0071\u24E0\uFF51\u024B\uA757\uA759' },
+        {
+            base: 'r',
+            letters: '\u0072\u24E1\uFF52\u0155\u1E59\u0159\u0211\u0213\u1E5B\u1E5D\u0157\u1E5F\u024D\u027D\uA75B\uA7A7\uA783',
+        },
+        {
+            base: 's',
+            letters: '\u0073\u24E2\uFF53\u00DF\u015B\u1E65\u015D\u1E61\u0161\u1E67\u1E63\u1E69\u0219\u015F\u023F\uA7A9\uA785\u1E9B',
+        },
+        {
+            base: 't',
+            letters: '\u0074\u24E3\uFF54\u1E6B\u1E97\u0165\u1E6D\u021B\u0163\u1E71\u1E6F\u0167\u01AD\u0288\u2C66\uA787',
+        },
+        { base: 'tz', letters: '\uA729' },
+        {
+            base: 'u',
+            letters: '\u0075\u24E4\uFF55\u00F9\u00FA\u00FB\u0169\u1E79\u016B\u1E7B\u016D\u00FC\u01DC\u01D8\u01D6\u01DA\u1EE7\u016F\u0171\u01D4\u0215\u0217\u01B0\u1EEB\u1EE9\u1EEF\u1EED\u1EF1\u1EE5\u1E73\u0173\u1E77\u1E75\u0289',
+        },
+        { base: 'v', letters: '\u0076\u24E5\uFF56\u1E7D\u1E7F\u028B\uA75F\u028C' },
+        { base: 'vy', letters: '\uA761' },
+        {
+            base: 'w',
+            letters: '\u0077\u24E6\uFF57\u1E81\u1E83\u0175\u1E87\u1E85\u1E98\u1E89\u2C73',
+        },
+        { base: 'x', letters: '\u0078\u24E7\uFF58\u1E8B\u1E8D' },
+        {
+            base: 'y',
+            letters: '\u0079\u24E8\uFF59\u1EF3\u00FD\u0177\u1EF9\u0233\u1E8F\u00FF\u1EF7\u1E99\u1EF5\u01B4\u024F\u1EFF',
+        },
+        {
+            base: 'z',
+            letters: '\u007A\u24E9\uFF5A\u017A\u1E91\u017C\u017E\u1E93\u1E95\u01B6\u0225\u0240\u2C6C\uA763',
+        },
+    ];
+    /**
+     * Map of letters from diacritic variant to diacritless variant
+     * Contains lowercase and uppercase separatelly
+     *
+     * > "á" => "a"
+     * > "ě" => "e"
+     * > "Ă" => "A"
+     * > ...
+     */
+    var DIACRITIC_VARIANTS_LETTERS = {};
+    // tslint:disable-next-line: prefer-for-of
+    for (var i = 0; i < defaultDiacriticsRemovalMap.length; i++) {
+        var letters = defaultDiacriticsRemovalMap[i].letters;
+        // tslint:disable-next-line: prefer-for-of
+        for (var j = 0; j < letters.length; j++) {
+            DIACRITIC_VARIANTS_LETTERS[letters[j]] = defaultDiacriticsRemovalMap[i].base;
+        }
+    }
+    // <- TODO: [🍓] Put to maker function to save execution time if not needed
+    /*
+      @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;
+        });
+    }
+
+    /* tslint:disable */
+    function normalizeToKebabCase(sentence) {
+        var e_1, _a;
+        sentence = removeDiacritics(sentence);
+        var charType;
+        var lastCharType = 'OTHER';
+        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 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 (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.split(/-+/g).join('-');
+        normalizedName = normalizedName.split(/-?\/-?/g).join('/');
+        normalizedName = normalizedName.replace(/^-/, '');
+        normalizedName = normalizedName.replace(/-$/, '');
+        return normalizedName;
+    }
+
+    /**
+     * Removes emojis from a string and fix whitespaces
+     *
+     * @param text with emojis
+     * @returns text without emojis
+     */
+    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;
+    }
+
+    /**
+     * Function normalizes title to name which can be used as identifier
+     */
+    function titleToName(value) {
+        value = removeEmojis(value);
+        value = normalizeToKebabCase(value);
+        // TODO: [🧠] Maybe warn or add some padding to short name which are not good identifiers
+        return value;
+    }
+
+    /**
+     * Parse promptbook from string format to JSON format
+     *
+     * @throws {PromptbookSyntaxError} if the promptbook string is not valid
+     *
+     * Note: This function does not validate logic of the pipeline only the syntax
+     */
+    function promptbookStringToJson(promptbookString) {
+        var e_1, _a, e_2, _b;
+        var promptbookJson = {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            title: undefined /* <- Note: Putting here placeholder to keep `title` on top at final JSON */,
+            promptbookUrl: undefined /* <- Note: Putting here placeholder to keep `promptbookUrl` on top at final JSON */,
+            promptbookVersion: PROMPTBOOK_VERSION,
+            description: undefined /* <- Note: Putting here placeholder to keep `description` on top at final JSON */,
+            parameters: [],
+            promptTemplates: [],
+        };
+        // =============================================================
+        // Note: 1️⃣ Normalization of the PROMPTBOOK string
+        promptbookString = removeContentComments(promptbookString);
+        promptbookString = promptbookString.replaceAll(/`\{(?<parameterName>[a-z0-9_]+)\}`/gi, '{$<parameterName>}');
+        promptbookString = promptbookString.replaceAll(/`->\s+\{(?<parameterName>[a-z0-9_]+)\}`/gi, '-> {$<parameterName>}');
+        // =============================================================
+        ///Note: 2️⃣ Function for adding parameters
+        var addParam = function (parameterCommand) {
+            var parameterName = parameterCommand.parameterName, parameterDescription = parameterCommand.parameterDescription, isInput = parameterCommand.isInput, isOutput = parameterCommand.isOutput;
+            var existingParameter = promptbookJson.parameters.find(function (parameter) { return parameter.name === parameterName; });
+            if (existingParameter &&
+                existingParameter.description &&
+                existingParameter.description !== parameterDescription &&
+                parameterDescription) {
+                throw new PromptbookSyntaxError(spaceTrim.spaceTrim(function (block) { return "\n                        Parameter {".concat(parameterName, "} is defined multiple times with different description.\n\n                        First definition:\n                        ").concat(block(existingParameter.description || '[undefined]'), "\n\n                        Second definition:\n                        ").concat(block(parameterDescription || '[undefined]'), "\n                    "); }));
+            }
+            if (existingParameter) {
+                if (parameterDescription) {
+                    existingParameter.description = parameterDescription;
+                }
+            }
+            else {
+                promptbookJson.parameters.push({
+                    name: parameterName,
+                    description: parameterDescription || undefined,
+                    isInput: isInput,
+                    isOutput: isOutput,
+                });
+            }
+        };
+        // =============================================================
+        // Note: 3️⃣ Parse the dynamic part - the template pipeline
+        var markdownStructure = markdownToMarkdownStructure(promptbookString);
+        var markdownStructureDeepness = countMarkdownStructureDeepness(markdownStructure);
+        if (markdownStructureDeepness !== 2) {
+            throw new PromptbookSyntaxError(spaceTrim.spaceTrim("\n                Invalid markdown structure.\n                The markdown must have exactly 2 levels of headings (one top-level section and one section for each template).\n                Now it has ".concat(markdownStructureDeepness, " levels of headings.\n            ")));
+        }
+        promptbookJson.title = markdownStructure.title;
+        // TODO: [1] DRY description
+        var description = markdownStructure.content;
+        // Note: Remove codeblocks
+        description = description.split(/^```.*^```/gms).join('');
+        //Note: Remove lists and return statement
+        description = description.split(/^(?:(?:-)|(?:\d\))|(?:`?->))\s+.*$/gm).join('');
+        description = spaceTrim.spaceTrim(description);
+        if (description === '') {
+            description = undefined;
+        }
+        promptbookJson.description = description;
+        var defaultModelRequirements = {};
+        var listItems = extractAllListItemsFromMarkdown(markdownStructure.content);
+        try {
+            for (var listItems_1 = __values(listItems), listItems_1_1 = listItems_1.next(); !listItems_1_1.done; listItems_1_1 = listItems_1.next()) {
+                var listItem = listItems_1_1.value;
+                var command = parseCommand(listItem);
+                switch (command.type) {
+                    case 'PROMPTBOOK_URL':
+                        promptbookJson.promptbookUrl = command.promptbookUrl.href;
+                        break;
+                    case 'PROMPTBOOK_VERSION':
+                        promptbookJson.promptbookVersion = command.promptbookVersion;
+                        break;
+                    case 'MODEL':
+                        defaultModelRequirements[command.key] = command.value;
+                        break;
+                    case 'PARAMETER':
+                        addParam(command);
+                        break;
+                    default:
+                        throw new PromptbookSyntaxError("Command ".concat(command.type, " is not allowed in the head of the promptbook ONLY at the prompt template block"));
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (listItems_1_1 && !listItems_1_1.done && (_a = listItems_1.return)) _a.call(listItems_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        var _loop_1 = function (section) {
+            var e_3, _e;
+            // TODO: Parse prompt template description (the content out of the codeblock and lists)
+            var templateModelRequirements = __assign({}, defaultModelRequirements);
+            var listItems_3 = extractAllListItemsFromMarkdown(section.content);
+            var dependentParameterNames = new Set();
+            var executionType = 'PROMPT_TEMPLATE';
+            var jokers = [];
+            var postprocessing = [];
+            var expectAmount = {};
+            var expectFormat = undefined;
+            var isExecutionTypeChanged = false;
+            try {
+                for (var listItems_2 = (e_3 = void 0, __values(listItems_3)), listItems_2_1 = listItems_2.next(); !listItems_2_1.done; listItems_2_1 = listItems_2.next()) {
+                    var listItem = listItems_2_1.value;
+                    var command = parseCommand(listItem);
+                    switch (command.type) {
+                        case 'JOKER':
+                            jokers.push(command.parameterName);
+                            dependentParameterNames.add(command.parameterName);
+                            break;
+                        case 'EXECUTE':
+                            if (isExecutionTypeChanged) {
+                                throw new PromptbookSyntaxError('Execution type is already defined in the prompt template. It can be defined only once.');
+                            }
+                            executionType = command.executionType;
+                            isExecutionTypeChanged = true;
+                            break;
+                        case 'MODEL':
+                            templateModelRequirements[command.key] = command.value;
+                            break;
+                        case 'PARAMETER':
+                            // Note: This is just for detecting resulitng parameter name
+                            addParam(command);
+                            break;
+                        case 'POSTPROCESS':
+                            postprocessing.push(command.functionName);
+                            break;
+                        case 'EXPECT_AMOUNT':
+                            // eslint-disable-next-line no-case-declarations
+                            var unit = command.unit.toLowerCase();
+                            expectAmount[unit] = expectAmount[unit] || {};
+                            if (command.sign === 'MINIMUM' || command.sign === 'EXACTLY') {
+                                if (expectAmount[unit].min !== undefined) {
+                                    throw new PromptbookSyntaxError("Already defined minumum ".concat(expectAmount[unit].min, " ").concat(command.unit.toLowerCase(), ", now trying to redefine it to ").concat(command.amount));
+                                }
+                                expectAmount[unit].min = command.amount;
+                            } /* not else */
+                            if (command.sign === 'MAXIMUM' || command.sign === 'EXACTLY') {
+                                if (expectAmount[unit].max !== undefined) {
+                                    throw new PromptbookSyntaxError("Already defined maximum ".concat(expectAmount[unit].max, " ").concat(command.unit.toLowerCase(), ", now trying to redefine it to ").concat(command.amount));
+                                }
+                                expectAmount[unit].max = command.amount;
+                            }
+                            break;
+                        case 'EXPECT_FORMAT':
+                            if (expectFormat !== undefined && command.format !== expectFormat) {
+                                throw new PromptbookSyntaxError("Expect format is already defined to \"".concat(expectFormat, "\". Now you try to redefine it by \"").concat(command.format, "\"."));
+                            }
+                            expectFormat = command.format;
+                            break;
+                        default:
+                            throw new PromptbookSyntaxError("Command ".concat(command.type, " is not allowed in the block of the prompt template ONLY at the head of the promptbook"));
+                    }
+                }
+            }
+            catch (e_3_1) { e_3 = { error: e_3_1 }; }
+            finally {
+                try {
+                    if (listItems_2_1 && !listItems_2_1.done && (_e = listItems_2.return)) _e.call(listItems_2);
+                }
+                finally { if (e_3) throw e_3.error; }
+            }
+            var _f = extractOneBlockFromMarkdown(section.content), language = _f.language, content = _f.content;
+            if (executionType === 'SCRIPT') {
+                if (!language) {
+                    throw new PromptbookSyntaxError('You must specify the language of the script in the prompt template');
+                }
+                else if (!SUPPORTED_SCRIPT_LANGUAGES.includes(language)) {
+                    throw new PromptbookSyntaxError(spaceTrim.spaceTrim(function (block) { return "\n                            Script language ".concat(language, " is not supported.\n\n                            Supported languages are:\n                            ").concat(block(SUPPORTED_SCRIPT_LANGUAGES.join(', ')), "\n\n                        "); }));
+                }
+            }
+            var lastLine = section.content.split('\n').pop();
+            var match = /^->\s*\{(?<resultingParamName>[a-z0-9_]+)\}/im.exec(lastLine);
+            if (!match || match.groups === undefined || match.groups.resultingParamName === undefined) {
+                throw new PromptbookSyntaxError(spaceTrim.spaceTrim(function (block) { return "\n                        Invalid template - each section must end with \"-> {...}\"\n\n                        Invalid section:\n                        ".concat(block(
+                // TODO: Show code of invalid sections each time + DRY
+                section.content
+                    .split('\n')
+                    .map(function (line) { return "> ".concat(line); })
+                    .join('\n')), "\n                        "); }));
+            }
+            var resultingParameterName = match.groups.resultingParamName;
+            // TODO: [1] DRY description
+            var description_1 = section.content;
+            // Note: Remove codeblocks
+            description_1 = description_1.split(/^```.*^```/gms).join('');
+            //Note: Remove lists and return statement
+            description_1 = description_1.split(/^(?:(?:-)|(?:\d\))|(?:`?->))\s+.*$/gm).join('');
+            description_1 = spaceTrim.spaceTrim(description_1);
+            if (description_1 === '') {
+                description_1 = undefined;
+            }
+            if (Object.keys(jokers).length === 0) {
+                jokers = undefined;
+            }
+            if (Object.keys(expectAmount).length === 0) {
+                expectAmount = undefined;
+            }
+            if (Object.keys(postprocessing).length === 0) {
+                postprocessing = undefined;
+            }
+            dependentParameterNames = union(dependentParameterNames, extractParametersFromPromptTemplate(__assign(__assign({}, section), { description: description_1, executionType: executionType, content: content })));
+            if (templateModelRequirements.modelVariant === undefined) {
+                templateModelRequirements.modelVariant = 'CHAT';
+            }
+            promptbookJson.promptTemplates.push({
+                name: titleToName(section.title),
+                title: section.title,
+                description: description_1,
+                dependentParameterNames: Array.from(dependentParameterNames),
+                executionType: executionType,
+                jokers: jokers,
+                postprocessing: postprocessing,
+                expectations: expectAmount,
+                expectFormat: expectFormat,
+                modelRequirements: templateModelRequirements,
+                contentLanguage: executionType === 'SCRIPT' ? language : undefined,
+                content: content,
+                resultingParameterName: resultingParameterName,
+            });
+        };
+        try {
+            for (var _c = __values(markdownStructure.sections), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var section = _d.value;
+                _loop_1(section);
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        // =============================================================
+        return promptbookJson;
+    }
+    /**
+     * TODO: Report here line/column of error
+     * TODO: Use spaceTrim more effectively
+     * TODO: [🧠] Parameter flags - isInput, isOutput, isInternal
+     */
+
+    /**
+     * This error indicates that the promptbook object has valid syntax but contains logical errors (like circular dependencies)
+     */
+    var PromptbookLogicError = /** @class */ (function (_super) {
+        __extends(PromptbookLogicError, _super);
+        function PromptbookLogicError(message) {
+            var _this = _super.call(this, message) || this;
+            _this.name = 'PromptbookLogicError';
+            Object.setPrototypeOf(_this, PromptbookLogicError.prototype);
+            return _this;
+        }
+        return PromptbookLogicError;
+    }(Error));
+
+    /**
+     * Tests if given string is valid URL.
+     *
+     * Note: Dataurl are considered perfectly valid.
+     */
+    function isValidUrl(url) {
+        if (typeof url !== 'string') {
+            return false;
+        }
+        try {
+            if (url.startsWith('blob:')) {
+                url = url.replace(/^blob:/, '');
+            }
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            var urlObject = new URL(url);
+            if (!['http:', 'https:', 'data:'].includes(urlObject.protocol)) {
+                return false;
+            }
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+
+    /**
+     * Validates PromptbookJson if it is logically valid
+     *
+     * It checks:
+     * -   if it has correct parameters dependency
+     *
+     * It does NOT check:
+     * -   if it is valid json
+     * -   if it is meaningful
+     *
+     * @param promptbook valid or invalid PromptbookJson
+     * @returns the same promptbook if it is logically valid
+     * @throws {PromptbookLogicError} on logical error in the promptbook
+     */
+    function validatePromptbookJson(promptbook) {
+        // TODO: [🧠] Maybe test if promptbook is a promise and make specific error case for that
+        var e_1, _a, e_2, _b, e_3, _c, e_4, _d;
+        if (promptbook.promptbookUrl !== undefined) {
+            if (!isValidUrl(promptbook.promptbookUrl)) {
+                // TODO: This should be maybe the syntax error detected during parsing
+                throw new PromptbookLogicError("Invalid promptbook URL \"".concat(promptbook.promptbookUrl, "\""));
+            }
+        }
+        // TODO: [🧠] Maybe do here some propper JSON-schema / ZOD checking
+        if (!Array.isArray(promptbook.parameters)) {
+            // TODO: [🧠] what is the correct error tp throw - maybe PromptbookSchemaError
+            throw new PromptbookSyntaxError(spaceTrim.spaceTrim("\n                Promptbook is valid JSON but with wrong structure\n\n                promptbook.parameters expected to be an array, but got ".concat(typeof promptbook.parameters, "\n            ")));
+        }
+        // TODO: [🧠] Maybe do here some propper JSON-schema / ZOD checking
+        if (!Array.isArray(promptbook.promptTemplates)) {
+            // TODO: [🧠] what is the correct error tp throw - maybe PromptbookSchemaError
+            throw new PromptbookSyntaxError(spaceTrim.spaceTrim("\n              Promptbook is valid JSON but with wrong structure\n\n              promptbook.promptTemplates expected to be an array, but got ".concat(typeof promptbook.promptTemplates, "\n          ")));
+        }
+        var _loop_1 = function (parameter) {
+            if (parameter.isInput && parameter.isOutput) {
+                throw new PromptbookLogicError("Parameter {".concat(parameter.name, "} can not be both input and output"));
+            }
+            // Note: Testing that parameter is either intermediate or output BUT not created and unused
+            if (!parameter.isInput &&
+                !parameter.isOutput &&
+                !promptbook.promptTemplates.some(function (template) { return template.dependentParameterNames.includes(parameter.name); })) {
+                throw new PromptbookLogicError(spaceTrim.spaceTrim("\n                    Parameter {".concat(parameter.name, "} is created but not used\n\n                    You can declare {").concat(parameter.name, "} as output parameter by adding in the header:\n                    - OUTPUT PARAMETER `{").concat(parameter.name, "}` ").concat(parameter.description || '', "\n\n                ")));
+            }
+            // Note: Testing that parameter is either input or result of some template
+            if (!parameter.isInput &&
+                !promptbook.promptTemplates.some(function (template) { return template.resultingParameterName === parameter.name; })) {
+                throw new PromptbookLogicError(spaceTrim.spaceTrim("\n                    Parameter {".concat(parameter.name, "} is declared but not defined\n\n                    You can do one of these:\n                    - Remove declaration of {").concat(parameter.name, "}\n                    - Add prompt template that results in -> {").concat(parameter.name, "}\n\n                ")));
+            }
+        };
+        try {
+            // Note: Check each parameter individually
+            for (var _e = __values(promptbook.parameters), _f = _e.next(); !_f.done; _f = _e.next()) {
+                var parameter = _f.value;
+                _loop_1(parameter);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_f && !_f.done && (_a = _e.return)) _a.call(_e);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        // Note: Check each template individually
+        var definedParameters = new Set(promptbook.parameters.filter(function (_a) {
+            var isInput = _a.isInput;
+            return isInput;
+        }).map(function (_a) {
+            var name = _a.name;
+            return name;
+        }));
+        try {
+            for (var _g = __values(promptbook.promptTemplates), _h = _g.next(); !_h.done; _h = _g.next()) {
+                var template = _h.value;
+                if (definedParameters.has(template.resultingParameterName)) {
+                    throw new PromptbookLogicError("Parameter {".concat(template.resultingParameterName, "} is defined multiple times"));
+                }
+                definedParameters.add(template.resultingParameterName);
+                if (template.executionType === 'PROMPT_TEMPLATE' &&
+                    (template.modelRequirements.modelVariant === undefined)) {
+                    throw new PromptbookLogicError(spaceTrim.spaceTrim("\n\n                  You must specify MODEL VARIANT in the prompt template \"".concat(template.title, "\"\n\n                  For example:\n                  - MODEL VARIANT Chat\n                  - MODEL NAME `gpt-4-1106-preview`\n\n              ")));
+                }
+                if (template.jokers && template.jokers.length > 0) {
+                    if (!template.expectFormat &&
+                        !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 {
+                        for (var _j = (e_3 = void 0, __values(template.jokers)), _k = _j.next(); !_k.done; _k = _j.next()) {
+                            var joker = _k.value;
+                            if (!template.dependentParameterNames.includes(joker)) {
+                                throw new PromptbookLogicError("Parameter {".concat(joker, "} is used for {").concat(template.resultingParameterName, "} as joker but not in dependentParameterNames"));
+                            }
+                        }
+                    }
+                    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                    finally {
+                        try {
+                            if (_k && !_k.done && (_c = _j.return)) _c.call(_j);
+                        }
+                        finally { if (e_3) throw e_3.error; }
+                    }
+                }
+                if (template.expectations) {
+                    try {
+                        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, ")"));
+                            }
+                            if (min !== undefined && min < 0) {
+                                throw new PromptbookLogicError("Min expectation of ".concat(unit, " must be zero or positive"));
+                            }
+                            if (max !== undefined && max <= 0) {
+                                throw new PromptbookLogicError("Max expectation of ".concat(unit, " must be positive"));
+                            }
+                        }
+                    }
+                    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                    finally {
+                        try {
+                            if (_m && !_m.done && (_d = _l.return)) _d.call(_l);
+                        }
+                        finally { if (e_4) throw e_4.error; }
+                    }
+                }
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (_h && !_h.done && (_b = _g.return)) _b.call(_g);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        // Note: Detect circular dependencies
+        var resovedParameters = promptbook.parameters
+            .filter(function (_a) {
+            var isInput = _a.isInput;
+            return isInput;
+        })
+            .map(function (_a) {
+            var name = _a.name;
+            return name;
+        });
+        var unresovedTemplates = __spreadArray([], __read(promptbook.promptTemplates), false);
+        var loopLimit = LOOP_LIMIT;
+        var _loop_2 = function () {
+            if (loopLimit-- < 0) {
+                throw new UnexpectedError('Loop limit reached during detection of circular dependencies in `validatePromptbookJson`');
+            }
+            var currentlyResovedTemplates = unresovedTemplates.filter(function (template) {
+                return template.dependentParameterNames.every(function (name) { return resovedParameters.includes(name); });
+            });
+            if (currentlyResovedTemplates.length === 0) {
+                throw new PromptbookLogicError(spaceTrim.spaceTrim(function (block) { return "\n\n                        Can not resolve some parameters\n                        It may be circular dependencies\n\n                        Can not resolve:\n                        ".concat(block(unresovedTemplates
+                    .map(function (_a) {
+                    var resultingParameterName = _a.resultingParameterName, dependentParameterNames = _a.dependentParameterNames;
+                    return "- {".concat(resultingParameterName, "} depends on ").concat(dependentParameterNames
+                        .map(function (dependentParameterName) { return "{".concat(dependentParameterName, "}"); })
+                        .join(', '));
+                })
+                    .join('\n')), "\n\n                        Resolved:\n                        ").concat(block(resovedParameters.map(function (name) { return "- {".concat(name, "}"); }).join('\n')), "\n                    "); }));
+            }
+            resovedParameters = __spreadArray(__spreadArray([], __read(resovedParameters), false), __read(currentlyResovedTemplates.map(function (_a) {
+                var resultingParameterName = _a.resultingParameterName;
+                return resultingParameterName;
+            })), false);
+            unresovedTemplates = unresovedTemplates.filter(function (template) { return !currentlyResovedTemplates.includes(template); });
+        };
+        while (unresovedTemplates.length > 0) {
+            _loop_2();
+        }
+        return promptbook;
+    }
+    /**
+     * TODO: [🧠] Work with promptbookVersion
+     * TODO: Use here some json-schema, Zod or something similar and change it to:
+     *     > /**
+     *     >  * Validates PromptbookJson if it is logically valid.
+     *     >  *
+     *     >  * It checks:
+     *     >  * -   it has a valid structure
+     *     >  * -   ...
+     *     >  ex port function validatePromptbookJson(promptbook: unknown): asserts promptbook is PromptbookJson {
+     */
+
+    /**
+     * This error indicates that the promptbook library cannot be propperly loaded
+     */
+    var PromptbookLibraryError = /** @class */ (function (_super) {
+        __extends(PromptbookLibraryError, _super);
+        function PromptbookLibraryError(message) {
+            var _this = _super.call(this, message) || this;
+            _this.name = 'PromptbookLibraryError';
+            Object.setPrototypeOf(_this, PromptbookLibraryError.prototype);
+            return _this;
+        }
+        return PromptbookLibraryError;
+    }(Error));
+
+    /**
+     * Detects if the code is running in a browser environment in main thread (Not in a web worker)
+     */
+    new Function("\n    try {\n        return this === window;\n    } catch (e) {\n        return false;\n    }\n");
+    /**
+     * Detects if the code is running in a Node.js environment
+     */
+    var isRunningInNode = new Function("\n    try {\n        return this === global;\n    } catch (e) {\n        return false;\n    }\n");
+    /**
+     * Detects if the code is running in a web worker
+     */
+    new Function("\n    try {\n        if (typeof WorkerGlobalScope !== 'undefined' && self instanceof WorkerGlobalScope) {\n            return true;\n        } else {\n            return false;\n        }\n    } catch (e) {\n        return false;\n    }\n");
+
+    /**
+     * Prettify the html code
+     *
+     * @param content raw html code
+     * @returns formatted html code
+     */
+    function prettifyMarkdown(content) {
+        try {
+            return prettier.format(content, {
+                parser: 'markdown',
+                plugins: [parserHtml__default["default"]],
+                // 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) {
+            console.error('There was an error with prettifying the markdown, using the original as the fallback', {
+                error: error,
+                html: content,
+            });
+            return content;
+        }
+    }
+
+    /**
+     * Converts promptbook in JSON format to string format
+     *
+     * @param promptbookJson Promptbook in JSON format (.ptbk.json)
+     * @returns Promptbook in string format (.ptbk.md)
+     */
+    function promptbookJsonToString(promptbookJson) {
+        var e_1, _a, e_2, _b, e_3, _c, e_4, _d, e_5, _e, e_6, _f;
+        var title = promptbookJson.title, promptbookUrl = promptbookJson.promptbookUrl, promptbookVersion = promptbookJson.promptbookVersion, description = promptbookJson.description, parameters = promptbookJson.parameters, promptTemplates = promptbookJson.promptTemplates;
+        var promptbookString = "# ".concat(title);
+        if (description) {
+            promptbookString += '\n\n';
+            promptbookString += description;
+        }
+        // TODO:> const commands: Array<Command>
+        var commands = [];
+        if (promptbookUrl) {
+            commands.push("PROMPTBOOK URL ".concat(promptbookUrl));
+        }
+        commands.push("PROMPTBOOK VERSION ".concat(promptbookVersion));
+        promptbookString = prettifyMarkdown(promptbookString);
+        try {
+            for (var _g = __values(parameters.filter(function (_a) {
+                var isInput = _a.isInput;
+                return isInput;
+            })), _h = _g.next(); !_h.done; _h = _g.next()) {
+                var parameter = _h.value;
+                commands.push("INPUT PARAMETER ".concat(promptTemplateParameterJsonToString(parameter)));
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_h && !_h.done && (_a = _g.return)) _a.call(_g);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        try {
+            for (var _j = __values(parameters.filter(function (_a) {
+                var isOutput = _a.isOutput;
+                return isOutput;
+            })), _k = _j.next(); !_k.done; _k = _j.next()) {
+                var parameter = _k.value;
+                commands.push("OUTPUT PARAMETER ".concat(promptTemplateParameterJsonToString(parameter)));
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (_k && !_k.done && (_b = _j.return)) _b.call(_j);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        promptbookString += '\n\n';
+        promptbookString += commands.map(function (command) { return "- ".concat(command); }).join('\n');
+        try {
+            for (var promptTemplates_1 = __values(promptTemplates), promptTemplates_1_1 = promptTemplates_1.next(); !promptTemplates_1_1.done; promptTemplates_1_1 = promptTemplates_1.next()) {
+                var promptTemplate = promptTemplates_1_1.value;
+                var 
+                /* Note: Not using:> name, */
+                title_1 = promptTemplate.title, description_1 = promptTemplate.description, 
+                /* Note: dependentParameterNames, */
+                jokers = promptTemplate.jokers, executionType = promptTemplate.executionType, content = promptTemplate.content, postprocessing = promptTemplate.postprocessing, expectations = promptTemplate.expectations, expectFormat = promptTemplate.expectFormat, resultingParameterName = promptTemplate.resultingParameterName;
+                promptbookString += '\n\n';
+                promptbookString += "## ".concat(title_1);
+                if (description_1) {
+                    promptbookString += '\n\n';
+                    promptbookString += description_1;
+                }
+                // TODO:> const commands: Array<Command>
+                var commands_1 = [];
+                var contentLanguage = 'text';
+                if (executionType === 'PROMPT_TEMPLATE') {
+                    var modelRequirements = promptTemplate.modelRequirements;
+                    var modelName = modelRequirements.modelName, modelVariant = modelRequirements.modelVariant;
+                    commands_1.push("EXECUTE PROMPT TEMPLATE");
+                    if (modelVariant) {
+                        commands_1.push("MODEL VARIANT ".concat(capitalize(modelVariant)));
+                    }
+                    if (modelName) {
+                        commands_1.push("MODEL NAME `".concat(modelName, "`"));
+                    }
+                }
+                else if (executionType === 'SIMPLE_TEMPLATE') {
+                    commands_1.push("SIMPLE TEMPLATE");
+                    // Note: Nothing special here
+                }
+                else if (executionType === 'SCRIPT') {
+                    commands_1.push("EXECUTE SCRIPT");
+                    if (promptTemplate.contentLanguage) {
+                        contentLanguage = promptTemplate.contentLanguage;
+                    }
+                    else {
+                        contentLanguage = '';
+                    }
+                }
+                else if (executionType === 'PROMPT_DIALOG') {
+                    commands_1.push("PROMPT DIALOG");
+                    // Note: Nothing special here
+                }
+                if (jokers) {
+                    try {
+                        for (var jokers_1 = (e_4 = void 0, __values(jokers)), jokers_1_1 = jokers_1.next(); !jokers_1_1.done; jokers_1_1 = jokers_1.next()) {
+                            var joker = jokers_1_1.value;
+                            commands_1.push("JOKER {".concat(joker, "}"));
+                        }
+                    }
+                    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                    finally {
+                        try {
+                            if (jokers_1_1 && !jokers_1_1.done && (_d = jokers_1.return)) _d.call(jokers_1);
+                        }
+                        finally { if (e_4) throw e_4.error; }
+                    }
+                } /* not else */
+                if (postprocessing) {
+                    try {
+                        for (var postprocessing_1 = (e_5 = void 0, __values(postprocessing)), postprocessing_1_1 = postprocessing_1.next(); !postprocessing_1_1.done; postprocessing_1_1 = postprocessing_1.next()) {
+                            var postprocessingFunctionName = postprocessing_1_1.value;
+                            commands_1.push("POSTPROCESSING `".concat(postprocessingFunctionName, "`"));
+                        }
+                    }
+                    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+                    finally {
+                        try {
+                            if (postprocessing_1_1 && !postprocessing_1_1.done && (_e = postprocessing_1.return)) _e.call(postprocessing_1);
+                        }
+                        finally { if (e_5) throw e_5.error; }
+                    }
+                } /* not else */
+                if (expectations) {
+                    try {
+                        for (var _l = (e_6 = void 0, __values(Object.entries(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 === max) {
+                                commands_1.push("EXPECT EXACTLY ".concat(min, " ").concat(capitalize(unit + (min > 1 ? 's' : ''))));
+                            }
+                            else {
+                                if (min !== undefined) {
+                                    commands_1.push("EXPECT MIN ".concat(min, " ").concat(capitalize(unit + (min > 1 ? 's' : ''))));
+                                } /* not else */
+                                if (max !== undefined) {
+                                    commands_1.push("EXPECT MAX ".concat(max, " ").concat(capitalize(unit + (max > 1 ? 's' : ''))));
+                                }
+                            }
+                        }
+                    }
+                    catch (e_6_1) { e_6 = { error: e_6_1 }; }
+                    finally {
+                        try {
+                            if (_m && !_m.done && (_f = _l.return)) _f.call(_l);
+                        }
+                        finally { if (e_6) throw e_6.error; }
+                    }
+                } /* not else */
+                if (expectFormat) {
+                    if (expectFormat === 'JSON') {
+                        // TODO: @deprecated remove
+                        commands_1.push("EXPECT JSON");
+                    }
+                } /* not else */
+                promptbookString += '\n\n';
+                promptbookString += commands_1.map(function (command) { return "- ".concat(command); }).join('\n');
+                promptbookString += '\n\n';
+                promptbookString += '```' + contentLanguage;
+                promptbookString += '\n';
+                promptbookString += spaceTrim__default["default"](content);
+                //                   <- TODO: !!! Escape
+                //                   <- TODO: [🧠] Some clear strategy how to spaceTrim the blocks
+                promptbookString += '\n';
+                promptbookString += '```';
+                promptbookString += '\n\n';
+                promptbookString += "`-> {".concat(resultingParameterName, "}`"); // <- TODO: !!! If the parameter here has description, add it and use promptTemplateParameterJsonToString
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (promptTemplates_1_1 && !promptTemplates_1_1.done && (_c = promptTemplates_1.return)) _c.call(promptTemplates_1);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+        return promptbookString;
+    }
+    /**
+     * @private internal util of promptbookJsonToString
+     */
+    function promptTemplateParameterJsonToString(promptTemplateParameterJson) {
+        var name = promptTemplateParameterJson.name, description = promptTemplateParameterJson.description;
+        var parameterString = "{".concat(name, "}");
+        if (description) {
+            parameterString = "".concat(parameterString, " ").concat(description);
+        }
+        return parameterString;
+    }
+    /**
+     * TODO: Escape all
+     */
+
+    /**
+     * This error indicates that promptbook not found in the library
+     */
+    var PromptbookNotFoundError = /** @class */ (function (_super) {
+        __extends(PromptbookNotFoundError, _super);
+        function PromptbookNotFoundError(message) {
+            var _this = _super.call(this, message) || this;
+            _this.name = 'PromptbookNotFoundError';
+            Object.setPrototypeOf(_this, PromptbookNotFoundError.prototype);
+            return _this;
+        }
+        return PromptbookNotFoundError;
+    }(Error));
+
+    /**
+     * This error indicates errors in referencing promptbooks between each other
+     */
+    var PromptbookReferenceError = /** @class */ (function (_super) {
+        __extends(PromptbookReferenceError, _super);
+        function PromptbookReferenceError(message) {
+            var _this = _super.call(this, message) || this;
+            _this.name = 'PromptbookReferenceError';
+            Object.setPrototypeOf(_this, PromptbookReferenceError.prototype);
+            return _this;
+        }
+        return PromptbookReferenceError;
+    }(Error));
+
+    /**
+     * Library of promptbooks that groups together promptbooks for an application.
+     * This implementation is a very thin wrapper around the Array / Map of promptbooks.
+     *
+     * @see https://github.com/webgptorg/promptbook#promptbook-library
+     */
+    var SimplePromptbookLibrary = /** @class */ (function () {
+        /**
+         * Constructs a promptbook library from promptbooks
+         *
+         * @param promptbooks !!!
+         *
+         * Note: During the construction logic of all promptbooks are validated
+         * Note: It is not recommended to use this constructor directly, use `createPromptbookLibraryFromSources` *(or other variant)* instead
+         */
+        function SimplePromptbookLibrary() {
+            var e_1, _a;
+            var promptbooks = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                promptbooks[_i] = arguments[_i];
+            }
+            this.library = new Map();
+            try {
+                for (var promptbooks_1 = __values(promptbooks), promptbooks_1_1 = promptbooks_1.next(); !promptbooks_1_1.done; promptbooks_1_1 = promptbooks_1.next()) {
+                    var promptbook = promptbooks_1_1.value;
+                    if (promptbook.promptbookUrl === undefined) {
+                        throw new PromptbookReferenceError(spaceTrim.spaceTrim("\n                        Promptbook with name \"".concat(promptbook.title, "\" does not have defined URL\n\n                        Note: Promptbooks without URLs are called anonymous promptbooks\n                              They can be used as standalone promptbooks, but they cannot be referenced by other promptbooks\n                              And also they cannot be used in the promptbook library\n\n                    ")));
+                    }
+                    validatePromptbookJson(promptbook);
+                    // Note: [🦄]
+                    if (this.library.has(promptbook.promptbookUrl) &&
+                        promptbookJsonToString(promptbook) !==
+                            promptbookJsonToString(this.library.get(promptbook.promptbookUrl))) {
+                        throw new PromptbookReferenceError(spaceTrim.spaceTrim("\n                        Promptbook with URL \"".concat(promptbook.promptbookUrl, "\" is already in the library\n\n                        Note: Promptbooks with the same URL are not allowed\n                        Note: Automatically check whether the promptbooks are the same BUT they are DIFFERENT\n\n                    ")));
+                    }
+                    this.library.set(promptbook.promptbookUrl, promptbook);
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (promptbooks_1_1 && !promptbooks_1_1.done && (_a = promptbooks_1.return)) _a.call(promptbooks_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+        }
+        /**
+         * Gets all promptbooks in the library
+         */
+        SimplePromptbookLibrary.prototype.listPromptbooks = function () {
+            return Array.from(this.library.keys());
+        };
+        /**
+         * Gets promptbook by its URL
+         *
+         * Note: This is not a direct fetching from the URL, but a lookup in the library
+         */
+        SimplePromptbookLibrary.prototype.getPromptbookByUrl = function (url) {
+            var _this = this;
+            var promptbook = this.library.get(url);
+            if (!promptbook) {
+                if (this.listPromptbooks().length === 0) {
+                    throw new PromptbookNotFoundError(spaceTrim.spaceTrim("\n                            Promptbook with url \"".concat(url, "\" not found\n\n                            No promptbooks available\n                        ")));
+                }
+                throw new PromptbookNotFoundError(spaceTrim.spaceTrim(function (block) { return "\n                        Promptbook with url \"".concat(url, "\" not found\n\n                        Available promptbooks:\n                        ").concat(block(_this.listPromptbooks()
+                    .map(function (promptbookUrl) { return "- ".concat(promptbookUrl); })
+                    .join('\n')), "\n\n                    "); }));
+            }
+            return promptbook;
+        };
+        /**
+         * Checks whether given prompt was defined in any promptbook in the library
+         */
+        SimplePromptbookLibrary.prototype.isResponsibleForPrompt = function (prompt) {
+            return true;
+        };
+        return SimplePromptbookLibrary;
+    }());
+
+    /**
+     * Creates PromptbookLibrary from array of PromptbookJson or PromptbookString
+     *
+     * Note: You can combine `PromptbookString` (`.ptbk.md`) with `PromptbookJson` BUT it is not recommended
+     * Note: During the construction syntax and logic of all sources are validated
+     *
+     * @param promptbookSources
+     * @returns PromptbookLibrary
+     */
+    function createPromptbookLibraryFromSources() {
+        var e_1, _a;
+        var promptbookSources = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            promptbookSources[_i] = arguments[_i];
+        }
+        var promptbooks = new Array();
+        try {
+            for (var promptbookSources_1 = __values(promptbookSources), promptbookSources_1_1 = promptbookSources_1.next(); !promptbookSources_1_1.done; promptbookSources_1_1 = promptbookSources_1.next()) {
+                var source = promptbookSources_1_1.value;
+                var promptbook = void 0;
+                if (typeof source === 'string') {
+                    // Note: When directly creating from string, no need to validate the source
+                    //       The validation is performed always before execution
+                    promptbook = promptbookStringToJson(source);
+                }
+                else {
+                    promptbook = source;
+                }
+                promptbooks.push(promptbook);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (promptbookSources_1_1 && !promptbookSources_1_1.done && (_a = promptbookSources_1.return)) _a.call(promptbookSources_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return new (SimplePromptbookLibrary.bind.apply(SimplePromptbookLibrary, __spreadArray([void 0], __read(promptbooks), false)))();
+    }
+
+    /**
+     * Constructs Promptbook from async sources
+     * It can be one of the following:
+     * - Promise of array of PromptbookJson or PromptbookString
+     * - Factory function that returns Promise of array of PromptbookJson or PromptbookString
+     *
+     * Note: This is useful as internal tool for other constructor functions like
+     *       `createPromptbookLibraryFromUrl` or `createPromptbookLibraryFromDirectory`
+     *       Consider using those functions instead of this one
+     *
+     * Note: The function does NOT return promise it returns the library directly which waits for the sources to be resolved
+     *       when error occurs in given promise or factory function, it is thrown during `listPromptbooks` or `getPromptbookByUrl` call
+     *
+     * Note: Consider using  `createPromptbookLibraryFromDirectory` or `createPromptbookLibraryFromUrl`
+     *
+     * @param promptbookSourcesPromiseOrFactory
+     * @returns PromptbookLibrary
+     * @private Just internal tool for other constructor functions
+     */
+    function createPromptbookLibraryFromPromise(promptbookSourcesPromiseOrFactory) {
+        var library;
+        function forSources() {
+            return __awaiter(this, void 0, void 0, function () {
+                var promptbookSources;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            if (typeof promptbookSourcesPromiseOrFactory === 'function') {
+                                // Note: Calling factory function only once despite multiple calls to resolveSources
+                                promptbookSourcesPromiseOrFactory = promptbookSourcesPromiseOrFactory();
+                            }
+                            return [4 /*yield*/, promptbookSourcesPromiseOrFactory];
+                        case 1:
+                            promptbookSources = _a.sent();
+                            library = createPromptbookLibraryFromSources.apply(void 0, __spreadArray([], __read(promptbookSources), false));
+                            return [2 /*return*/];
+                    }
+                });
+            });
+        }
+        function listPromptbooks() {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, forSources()];
+                        case 1:
+                            _a.sent();
+                            return [2 /*return*/, /* not await */ library.listPromptbooks()];
+                    }
+                });
+            });
+        }
+        function getPromptbookByUrl(url) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, forSources()];
+                        case 1:
+                            _a.sent();
+                            return [2 /*return*/, /* not await */ library.getPromptbookByUrl(url)];
+                    }
+                });
+            });
+        }
+        function isResponsibleForPrompt(prompt) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, forSources()];
+                        case 1:
+                            _a.sent();
+                            return [2 /*return*/, /* not await */ library.isResponsibleForPrompt(prompt)];
+                    }
+                });
+            });
+        }
+        return {
+            listPromptbooks: listPromptbooks,
+            getPromptbookByUrl: getPromptbookByUrl,
+            isResponsibleForPrompt: isResponsibleForPrompt,
+        };
+    }
+
+    /**
+     * Constructs Promptbook from given directory
+     *
+     * Note: Works only in Node.js environment because it reads the file system
+     *
+     * @param path - path to the directory with promptbooks
+     * @param options - Misc options for the library
+     * @returns PromptbookLibrary
+     */
+    function createPromptbookLibraryFromDirectory(path, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, _b, isRecursive, _c, isVerbose, _d, isLazyLoaded, _e, isCrashOnError, library;
+            var _this = this;
+            return __generator(this, function (_f) {
+                switch (_f.label) {
+                    case 0:
+                        if (!isRunningInNode()) {
+                            throw new Error('Function `createPromptbookLibraryFromDirectory` can only be run in Node.js environment because it reads the file system.');
+                        }
+                        _a = options || {}, _b = _a.isRecursive, isRecursive = _b === void 0 ? true : _b, _c = _a.isVerbose, isVerbose = _c === void 0 ? false : _c, _d = _a.isLazyLoaded, isLazyLoaded = _d === void 0 ? false : _d, _e = _a.isCrashOnError, isCrashOnError = _e === void 0 ? true : _e;
+                        library = createPromptbookLibraryFromPromise(function () { return __awaiter(_this, void 0, void 0, function () {
+                            var fileNames, promptbooks, _loop_1, fileNames_1, fileNames_1_1, fileName, e_1_1;
+                            var e_1, _a;
+                            return __generator(this, function (_b) {
+                                switch (_b.label) {
+                                    case 0:
+                                        if (isVerbose) {
+                                            console.info("Creating promptbook library from path ".concat(path));
+                                        }
+                                        return [4 /*yield*/, listAllFiles(path, isRecursive)];
+                                    case 1:
+                                        fileNames = _b.sent();
+                                        if (isVerbose) {
+                                            console.info('createPromptbookLibraryFromDirectory', { path: path, isRecursive: isRecursive, fileNames: fileNames });
+                                        }
+                                        promptbooks = [];
+                                        _loop_1 = function (fileName) {
+                                            var promptbook, promptbookString, _c, _d, error_1, wrappedErrorMessage;
+                                            return __generator(this, function (_e) {
+                                                switch (_e.label) {
+                                                    case 0:
+                                                        _e.trys.push([0, 6, , 7]);
+                                                        promptbook = null;
+                                                        if (!fileName.endsWith('.ptbk.md')) return [3 /*break*/, 2];
+                                                        return [4 /*yield*/, promises.readFile(fileName, 'utf8')];
+                                                    case 1:
+                                                        promptbookString = (_e.sent());
+                                                        promptbook = promptbookStringToJson(promptbookString);
+                                                        return [3 /*break*/, 5];
+                                                    case 2:
+                                                        if (!fileName.endsWith('.ptbk.json')) return [3 /*break*/, 4];
+                                                        if (isVerbose) {
+                                                            console.info("Loading ".concat(fileName));
+                                                        }
+                                                        _d = (_c = JSON).parse;
+                                                        return [4 /*yield*/, promises.readFile(fileName, 'utf8')];
+                                                    case 3:
+                                                        // TODO: Handle non-valid JSON files
+                                                        promptbook = _d.apply(_c, [_e.sent()]);
+                                                        return [3 /*break*/, 5];
+                                                    case 4:
+                                                        if (isVerbose) {
+                                                            console.info("Skipping file ".concat(fileName));
+                                                        }
+                                                        _e.label = 5;
+                                                    case 5:
+                                                        // ---
+                                                        if (promptbook !== null) {
+                                                            if (!promptbook.promptbookUrl) {
+                                                                if (isVerbose) {
+                                                                    console.info("Not loading ".concat(fileName, " - missing URL"));
+                                                                }
+                                                            }
+                                                            else {
+                                                                if (isVerbose) {
+                                                                    console.info("Loading ".concat(fileName));
+                                                                }
+                                                                if (!isCrashOnError) {
+                                                                    // Note: Validate promptbook to check if it is logically correct to not crash on invalid promptbooks
+                                                                    //       But be handled in current try-catch block
+                                                                    validatePromptbookJson(promptbook);
+                                                                }
+                                                                // Note: [🦄] Promptbook with same url uniqueness will be checked automatically in SimplePromptbookLibrary
+                                                                promptbooks.push(promptbook);
+                                                            }
+                                                        }
+                                                        return [3 /*break*/, 7];
+                                                    case 6:
+                                                        error_1 = _e.sent();
+                                                        if (!(error_1 instanceof Error)) {
+                                                            throw error_1;
+                                                        }
+                                                        wrappedErrorMessage = spaceTrim__default["default"](function (block) { return "\n                        Error during loading promptbook from file ".concat(fileName.split('\\').join('/'), ":\n\n                        ").concat(block(error_1.message), "\n\n                    "); });
+                                                        if (isCrashOnError) {
+                                                            throw new PromptbookLibraryError(wrappedErrorMessage);
+                                                        }
+                                                        console.error(wrappedErrorMessage);
+                                                        return [3 /*break*/, 7];
+                                                    case 7: return [2 /*return*/];
+                                                }
+                                            });
+                                        };
+                                        _b.label = 2;
+                                    case 2:
+                                        _b.trys.push([2, 7, 8, 9]);
+                                        fileNames_1 = __values(fileNames), fileNames_1_1 = fileNames_1.next();
+                                        _b.label = 3;
+                                    case 3:
+                                        if (!!fileNames_1_1.done) return [3 /*break*/, 6];
+                                        fileName = fileNames_1_1.value;
+                                        return [5 /*yield**/, _loop_1(fileName)];
+                                    case 4:
+                                        _b.sent();
+                                        _b.label = 5;
+                                    case 5:
+                                        fileNames_1_1 = fileNames_1.next();
+                                        return [3 /*break*/, 3];
+                                    case 6: return [3 /*break*/, 9];
+                                    case 7:
+                                        e_1_1 = _b.sent();
+                                        e_1 = { error: e_1_1 };
+                                        return [3 /*break*/, 9];
+                                    case 8:
+                                        try {
+                                            if (fileNames_1_1 && !fileNames_1_1.done && (_a = fileNames_1.return)) _a.call(fileNames_1);
+                                        }
+                                        finally { if (e_1) throw e_1.error; }
+                                        return [7 /*endfinally*/];
+                                    case 9: return [2 /*return*/, promptbooks];
+                                }
+                            });
+                        }); });
+                        if (!(isLazyLoaded === false)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, library.listPromptbooks()];
+                    case 1:
+                        _f.sent();
+                        _f.label = 2;
+                    case 2: return [2 /*return*/, library];
+                }
+            });
+        });
+    }
+    /**
+     * Reads all files in the directory
+     *
+     * @param path
+     * @param isRecursive
+     * @returns List of all files in the directory
+     * @private internal function for `createPromptbookLibraryFromDirectory`
+     */
+    function listAllFiles(path$1, isRecursive) {
+        return __awaiter(this, void 0, void 0, function () {
+            var dirents, fileNames, _a, _b, dirent, subPath, _c, _d, _e, _f, e_2_1;
+            var e_2, _g;
+            return __generator(this, function (_h) {
+                switch (_h.label) {
+                    case 0: return [4 /*yield*/, promises.readdir(path$1, {
+                            withFileTypes: true /* Note: This is not working: recursive: isRecursive */,
+                        })];
+                    case 1:
+                        dirents = _h.sent();
+                        fileNames = dirents.filter(function (dirent) { return dirent.isFile(); }).map(function (_a) {
+                            var name = _a.name;
+                            return path.join(path$1, name);
+                        });
+                        if (!isRecursive) return [3 /*break*/, 9];
+                        _h.label = 2;
+                    case 2:
+                        _h.trys.push([2, 7, 8, 9]);
+                        _a = __values(dirents.filter(function (dirent) { return dirent.isDirectory(); })), _b = _a.next();
+                        _h.label = 3;
+                    case 3:
+                        if (!!_b.done) return [3 /*break*/, 6];
+                        dirent = _b.value;
+                        subPath = path.join(path$1, dirent.name);
+                        _d = (_c = fileNames.push).apply;
+                        _e = [fileNames];
+                        _f = [[]];
+                        return [4 /*yield*/, listAllFiles(subPath, isRecursive)];
+                    case 4:
+                        _d.apply(_c, _e.concat([__spreadArray.apply(void 0, _f.concat([__read.apply(void 0, [(_h.sent())]), false]))]));
+                        _h.label = 5;
+                    case 5:
+                        _b = _a.next();
+                        return [3 /*break*/, 3];
+                    case 6: return [3 /*break*/, 9];
+                    case 7:
+                        e_2_1 = _h.sent();
+                        e_2 = { error: e_2_1 };
+                        return [3 /*break*/, 9];
+                    case 8:
+                        try {
+                            if (_b && !_b.done && (_g = _a.return)) _g.call(_a);
+                        }
+                        finally { if (e_2) throw e_2.error; }
+                        return [7 /*endfinally*/];
+                    case 9: return [2 /*return*/, fileNames];
+                }
+            });
+        });
+    }
+
+    exports.PROMPTBOOK_VERSION = PROMPTBOOK_VERSION;
+    exports.createPromptbookLibraryFromDirectory = createPromptbookLibraryFromDirectory;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+}));
+//# sourceMappingURL=index.umd.js.map