@promptbook/editable 0.82.0-3 → 0.83.0

package/umd/index.umd.js

@@ -1,12 +1,13 @@
 (function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('spacetrim')) :
-    typeof define === 'function' && define.amd ? define(['exports', 'spacetrim'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["promptbook-editable"] = {}, global.spaceTrim));
-})(this, (function (exports, spaceTrim) { 'use strict';
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('spacetrim'), require('papaparse'), require('crypto-js'), require('crypto-js/enc-hex')) :
+    typeof define === 'function' && define.amd ? define(['exports', 'spacetrim', 'papaparse', 'crypto-js', 'crypto-js/enc-hex'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["promptbook-editable"] = {}, global.spaceTrim, global.papaparse, global.cryptoJs, global.hexEncoder));
+})(this, (function (exports, spaceTrim, papaparse, cryptoJs, hexEncoder) { 'use strict';
 
     function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
     var spaceTrim__default = /*#__PURE__*/_interopDefaultLegacy(spaceTrim);
+    var hexEncoder__default = /*#__PURE__*/_interopDefaultLegacy(hexEncoder);
 
     // ⚠️ WARNING: This code has been generated so that any manual changes will be overwritten
     /**
@@ -22,7 +23,7 @@
      * @generated
      * @see https://github.com/webgptorg/promptbook
      */
-    var PROMPTBOOK_ENGINE_VERSION = '0.82.0-2';
+    var PROMPTBOOK_ENGINE_VERSION = '0.82.0';
     /**
      * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
      * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -70,6 +71,44 @@
         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);
@@ -110,128 +149,23 @@
     }
 
     /**
-     * Function `removePipelineCommand` will remove one command from pipeline string
+     * Returns the same value that is passed as argument.
+     * No side effects.
      *
-     * @public exported from `@promptbook/editable`
-     */
-    function removePipelineCommand(options) {
-        var e_1, _a;
-        var command = options.command, pipeline = options.pipeline;
-        var lines = pipeline.split('\n');
-        // TODO: [🧽] DRY
-        var currentType = 'MARKDOWN';
-        var newLines = [];
-        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 (currentType === 'MARKDOWN') {
-                    if (line.startsWith('```')) {
-                        currentType = 'CODE_BLOCK';
-                    }
-                    else if (line.includes('<!--')) {
-                        currentType = 'COMMENT';
-                    }
-                }
-                else if (currentType === 'CODE_BLOCK') {
-                    if (line.startsWith('```')) {
-                        currentType = 'MARKDOWN';
-                    }
-                }
-                else if (currentType === 'COMMENT') {
-                    if (line.includes('-->')) {
-                        currentType = 'MARKDOWN';
-                    }
-                }
-                if (currentType === 'MARKDOWN' && /^(-|\d\))/m.test(line) && line.toUpperCase().includes(command)) {
-                    continue;
-                }
-                newLines.push(line);
-            }
-        }
-        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; }
-        }
-        var newPipeline = spaceTrim__default["default"](newLines.join('\n'));
-        return newPipeline;
-    }
-
-    /**
-     * This error indicates that the promptbook object has valid syntax (=can be parsed) but contains logical errors (like circular dependencies)
+     * Note: It can be usefull for:
      *
-     * @public exported from `@promptbook/core`
-     */
-    var PipelineLogicError = /** @class */ (function (_super) {
-        __extends(PipelineLogicError, _super);
-        function PipelineLogicError(message) {
-            var _this = _super.call(this, message) || this;
-            _this.name = 'PipelineLogicError';
-            Object.setPrototypeOf(_this, PipelineLogicError.prototype);
-            return _this;
-        }
-        return PipelineLogicError;
-    }(Error));
-
-    /**
-     * Function `renamePipelineParameter` will find all usable parameters for given task
-     * In other words, it will find all parameters that are not used in the task itseld and all its dependencies
+     * 1) Leveling indentation
+     * 2) Putting always-true or always-false conditions without getting eslint errors
      *
-     * @throws {PipelineLogicError} If the new parameter name is already used in the pipeline
-     * @public exported from `@promptbook/editable`
+     * @param value any values
+     * @returns the same values
+     * @private within the repository
      */
-    function renamePipelineParameter(options) {
-        var e_1, _a, e_2, _b;
-        var pipeline = options.pipeline, oldParameterName = options.oldParameterName, newParameterName = options.newParameterName;
-        if (pipeline.parameters.some(function (parameter) { return parameter.name === newParameterName; })) {
-            throw new PipelineLogicError("Can not replace {".concat(oldParameterName, "} to {").concat(newParameterName, "} because {").concat(newParameterName, "} is already used in the pipeline"));
-        }
-        var renamedPipeline = __assign(__assign({}, pipeline), { 
-            // <- TODO: [🪓] This should be without `as $PipelineJson`
-            parameters: __spreadArray([], __read(pipeline.parameters), false), tasks: __spreadArray([], __read(pipeline.tasks), false) });
-        try {
-            for (var _c = __values(renamedPipeline.parameters), _d = _c.next(); !_d.done; _d = _c.next()) {
-                var parameter = _d.value;
-                if (parameter.name !== oldParameterName) {
-                    continue;
-                }
-                parameter.name = newParameterName;
-            }
-        }
-        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; }
-        }
-        try {
-            for (var _e = __values(renamedPipeline.tasks), _f = _e.next(); !_f.done; _f = _e.next()) {
-                var task = _f.value;
-                if (task.resultingParameterName === oldParameterName) {
-                    task.resultingParameterName = newParameterName;
-                }
-                task.dependentParameterNames = task.dependentParameterNames.map(function (dependentParameterName) {
-                    return dependentParameterName === oldParameterName ? newParameterName : dependentParameterName;
-                });
-                task.content = task.content.replace(new RegExp("{".concat(oldParameterName, "}"), 'g'), "{".concat(newParameterName, "}"));
-                task.title = task.title.replace(new RegExp("{".concat(oldParameterName, "}"), 'g'), "{".concat(newParameterName, "}"));
-                task.description =
-                    task.description === undefined
-                        ? undefined
-                        : task.description.replace(new RegExp("{".concat(oldParameterName, "}"), 'g'), "{".concat(newParameterName, "}"));
-            }
-        }
-        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; }
+    function just(value) {
+        if (value === undefined) {
+            return undefined;
         }
-        return renamedPipeline;
+        return value;
     }
 
     /**
@@ -278,56 +212,6 @@
      * TODO: [🧠][🧜‍♂️] Maybe join remoteUrl and path into single value
      */
 
-    /**
-     * Orders JSON object by keys
-     *
-     * @returns The same type of object as the input re-ordered
-     * @public exported from `@promptbook/utils`
-     */
-    function orderJson(options) {
-        var value = options.value, order = options.order;
-        var orderedValue = __assign(__assign({}, (order === undefined ? {} : Object.fromEntries(order.map(function (key) { return [key, undefined]; })))), value);
-        return orderedValue;
-    }
-
-    /**
-     * Freezes the given object and all its nested objects recursively
-     *
-     * Note: `$` is used to indicate that this function is not a pure function - it mutates given object
-     * Note: This function mutates the object and returns the original (but mutated-deep-freezed) object
-     *
-     * @returns The same object as the input, but deeply frozen
-     * @public exported from `@promptbook/utils`
-     */
-    function $deepFreeze(objectValue) {
-        var e_1, _a;
-        if (Array.isArray(objectValue)) {
-            return Object.freeze(objectValue.map(function (item) { return $deepFreeze(item); }));
-        }
-        var propertyNames = Object.getOwnPropertyNames(objectValue);
-        try {
-            for (var propertyNames_1 = __values(propertyNames), propertyNames_1_1 = propertyNames_1.next(); !propertyNames_1_1.done; propertyNames_1_1 = propertyNames_1.next()) {
-                var propertyName = propertyNames_1_1.value;
-                var value = objectValue[propertyName];
-                if (value && typeof value === 'object') {
-                    $deepFreeze(value);
-                }
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (propertyNames_1_1 && !propertyNames_1_1.done && (_a = propertyNames_1.return)) _a.call(propertyNames_1);
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
-        Object.freeze(objectValue);
-        return objectValue;
-    }
-    /**
-     * TODO: [🧠] Is there a way how to meaningfully test this utility
-     */
-
     /**
      * Make error report URL for the given error
      *
@@ -363,216 +247,3752 @@
     }(Error));
 
     /**
-     * Checks if the value is [🚉] serializable as JSON
-     * If not, throws an UnexpectedError with a rich error message and tracking
+     * This error indicates that the promptbook in a markdown format cannot be parsed into a valid promptbook object
      *
-     * - Almost all primitives are serializable BUT:
-     * - `undefined` is not serializable
-     * - `NaN` is not serializable
-     * - Objects and arrays are serializable if all their properties are serializable
-     * - Functions are not serializable
-     * - Circular references are not serializable
-     * - `Date` objects are not serializable
-     * - `Map` and `Set` objects are not serializable
-     * - `RegExp` objects are not serializable
-     * - `Error` objects are not serializable
-     * - `Symbol` objects are not serializable
-     * - And much more...
-     *
-     * @throws UnexpectedError if the value is not serializable as JSON
-     * @public exported from `@promptbook/utils`
+     * @public exported from `@promptbook/core`
      */
-    function checkSerializableAsJson(options) {
-        var e_1, _a;
-        var value = options.value, name = options.name, message = options.message;
-        if (value === undefined) {
-            throw new UnexpectedError("".concat(name, " is undefined"));
-        }
-        else if (value === null) {
-            return;
+    var ParseError = /** @class */ (function (_super) {
+        __extends(ParseError, _super);
+        function ParseError(message) {
+            var _this = _super.call(this, message) || this;
+            _this.name = 'ParseError';
+            Object.setPrototypeOf(_this, ParseError.prototype);
+            return _this;
         }
-        else if (typeof value === 'boolean') {
-            return;
+        return ParseError;
+    }(Error));
+    /**
+     * TODO: Maybe split `ParseError` and `ApplyError`
+     */
+
+    /**
+     * Parses the boilerplate command
+     *
+     * Note: @@@ This command is used as boilerplate for new commands - it should NOT be used in any `.book.md` file
+     *
+     * @see `documentationUrl` for more details
+     * @private within the commands folder
+     */
+    var boilerplateCommandParser = {
+        /**
+         * Name of the command
+         */
+        name: 'BOILERPLATE',
+        /**
+         * Aliases for the BOILERPLATE command
+         */
+        aliasNames: ['BP'],
+        /**
+         * BOILERPLATE command can be used in:
+         */
+        isUsedInPipelineHead: true,
+        isUsedInPipelineTask: true,
+        /**
+         * Description of the BOILERPLATE command
+         */
+        description: "@@",
+        /**
+         * Link to documentation
+         */
+        documentationUrl: 'https://github.com/webgptorg/promptbook/discussions/@@',
+        /**
+         * Example usages of the BOILERPLATE command
+         */
+        examples: ['BOILERPLATE foo', 'BOILERPLATE bar', 'BP foo', 'BP bar'],
+        /**
+         * Parses the BOILERPLATE command
+         */
+        parse: function (input) {
+            var args = input.args;
+            if (args.length !== 1) {
+                throw new ParseError("BOILERPLATE command requires exactly one argument");
+            }
+            var value = args[0].toLowerCase();
+            if (value.includes('brr')) {
+                throw new ParseError("BOILERPLATE value can not contain brr");
+            }
+            return {
+                type: 'BOILERPLATE',
+                value: value,
+            };
+        },
+        /**
+         * Apply the BOILERPLATE command to the `pipelineJson`
+         *
+         * Note: `$` is used to indicate that this function mutates given `pipelineJson`
+         */
+        $applyToPipelineJson: function (command, $pipelineJson) {
+            throw new ParseError("BOILERPLATE command is only for testing purposes and should not be used in the .book.md file");
+        },
+        /**
+         * Apply the BOILERPLATE command to the `pipelineJson`
+         *
+         * Note: `$` is used to indicate that this function mutates given `taskJson`
+         */
+        $applyToTaskJson: function (command, $taskJson, $pipelineJson) {
+            throw new ParseError("BOILERPLATE command is only for testing purposes and should not be used in the .book.md file");
+        },
+        /**
+         * Converts the BOILERPLATE command back to string
+         *
+         * Note: This is used in `pipelineJsonToString` utility
+         */
+        stringify: function (command) {
+            return "---"; // <- TODO: [🛋] Implement
+        },
+        /**
+         * Reads the BOILERPLATE command from the `PipelineJson`
+         *
+         * Note: This is used in `pipelineJsonToString` utility
+         */
+        takeFromPipelineJson: function (pipelineJson) {
+            throw new ParseError("BOILERPLATE command is only for testing purposes and should not be used in the .book.md file");
+        },
+        /**
+         * Reads the BOILERPLATE command from the `TaskJson`
+         *
+         * Note: This is used in `pipelineJsonToString` utility
+         */
+        takeFromTaskJson: function ($taskJson) {
+            throw new ParseError("BOILERPLATE command is only for testing purposes and should not be used in the .book.md file");
+        },
+    };
+
+    /**
+     * This error type indicates that some part of the code is not implemented yet
+     *
+     * @public exported from `@promptbook/core`
+     */
+    var NotYetImplementedError = /** @class */ (function (_super) {
+        __extends(NotYetImplementedError, _super);
+        function NotYetImplementedError(message) {
+            var _this = _super.call(this, spaceTrim.spaceTrim(function (block) { return "\n                    ".concat(block(message), "\n\n                    Note: This feature is not implemented yet but it will be soon.\n\n                    If you want speed up the implementation or just read more, look here:\n                    https://github.com/webgptorg/promptbook\n\n                    Or contact us on me@pavolhejny.com\n\n                "); })) || this;
+            _this.name = 'NotYetImplementedError';
+            Object.setPrototypeOf(_this, NotYetImplementedError.prototype);
+            return _this;
         }
-        else if (typeof value === 'number' && !isNaN(value)) {
-            return;
+        return NotYetImplementedError;
+    }(Error));
+
+    /**
+     * Tests if given string is valid semantic version
+     *
+     * Note: There are two simmilar functions:
+     * - `isValidSemanticVersion` which tests any semantic version
+     * - `isValidPromptbookVersion` *(this one)* which tests just Promptbook versions
+     *
+     * @public exported from `@promptbook/utils`
+     */
+    function isValidSemanticVersion(version) {
+        if (typeof version !== 'string') {
+            return false;
         }
-        else if (typeof value === 'string') {
-            return;
+        if (version.startsWith('0.0.0')) {
+            return false;
         }
-        else if (typeof value === 'symbol') {
-            throw new UnexpectedError("".concat(name, " is symbol"));
+        return /^\d+\.\d+\.\d+(-\d+)?$/i.test(version);
+    }
+
+    /**
+     * Tests if given string is valid promptbook version
+     * It looks into list of known promptbook versions.
+     *
+     * @see https://www.npmjs.com/package/promptbook?activeTab=versions
+     * Note: When you are using for example promptbook 2.0.0 and there already is promptbook 3.0.0 it don`t know about it.
+     * Note: There are two simmilar functions:
+     * - `isValidSemanticVersion` which tests any semantic version
+     * - `isValidPromptbookVersion` *(this one)* which tests just Promptbook versions
+     *
+     * @public exported from `@promptbook/utils`
+     */
+    function isValidPromptbookVersion(version) {
+        if (!isValidSemanticVersion(version)) {
+            return false;
         }
-        else if (typeof value === 'function') {
-            throw new UnexpectedError("".concat(name, " is function"));
+        if ( /* version === '1.0.0' || */version === '2.0.0' || version === '3.0.0') {
+            return false;
         }
-        else if (typeof value === 'object' && Array.isArray(value)) {
-            for (var i = 0; i < value.length; i++) {
-                checkSerializableAsJson({ name: "".concat(name, "[").concat(i, "]"), value: value[i], message: message });
+        // <- TODO: [main] !!3 Check isValidPromptbookVersion against PROMPTBOOK_ENGINE_VERSIONS
+        return true;
+    }
+
+    /**
+     * Parses the BOOK_VERSION command
+     *
+     * @see `documentationUrl` for more details
+     * @public exported from `@promptbook/editable`
+     */
+    var bookVersionCommandParser = {
+        /**
+         * Name of the command
+         */
+        name: 'BOOK_VERSION',
+        aliasNames: ['PTBK_VERSION', 'PROMPTBOOK_VERSION', 'BOOK'],
+        /**
+         * BOILERPLATE command can be used in:
+         */
+        isUsedInPipelineHead: true,
+        isUsedInPipelineTask: false,
+        /**
+         * Description of the BOOK_VERSION command
+         */
+        description: "Which version of the Book language is the .book.md using",
+        /**
+         * Link to documentation
+         */
+        documentationUrl: 'https://github.com/webgptorg/promptbook/discussions/69',
+        /**
+         * Example usages of the BOOK_VERSION command
+         */
+        examples: ["BOOK VERSION ".concat(BOOK_LANGUAGE_VERSION), "BOOK ".concat(BOOK_LANGUAGE_VERSION)],
+        /**
+         * Parses the BOOK_VERSION command
+         */
+        parse: function (input) {
+            var args = input.args;
+            var bookVersion = args.pop();
+            if (bookVersion === undefined) {
+                throw new ParseError("Version is required");
             }
-        }
-        else if (typeof value === 'object') {
-            if (value instanceof Date) {
-                throw new UnexpectedError(spaceTrim__default["default"](function (block) { return "\n                        `".concat(name, "` is Date\n\n                        Use `string_date_iso8601` instead\n\n                        Additional message for `").concat(name, "`:\n                        ").concat(block(message || '(nothing)'), "\n                    "); }));
+            if (!isValidPromptbookVersion(bookVersion)) {
+                throw new ParseError("Invalid Promptbook version \"".concat(bookVersion, "\""));
             }
-            else if (value instanceof Map) {
-                throw new UnexpectedError("".concat(name, " is Map"));
-            }
-            else if (value instanceof Set) {
-                throw new UnexpectedError("".concat(name, " is Set"));
+            if (args.length > 0 && !(((args.length === 1 && args[0]) || '').toUpperCase() === 'VERSION')) {
+                throw new ParseError("Can not have more than one Promptbook version");
             }
-            else if (value instanceof RegExp) {
-                throw new UnexpectedError("".concat(name, " is RegExp"));
+            return {
+                type: 'BOOK_VERSION',
+                bookVersion: bookVersion,
+            };
+        },
+        /**
+         * Apply the BOOK_VERSION command to the `pipelineJson`
+         *
+         * Note: `$` is used to indicate that this function mutates given `pipelineJson`
+         */
+        $applyToPipelineJson: function (command, $pipelineJson) {
+            // TODO: Warn if the version is overridden
+            $pipelineJson.bookVersion = command.bookVersion;
+        },
+        /**
+         * Converts the BOOK_VERSION command back to string
+         *
+         * Note: This is used in `pipelineJsonToString` utility
+         */
+        stringify: function (command) {
+            return "---"; // <- TODO: [🛋] Implement
+        },
+        /**
+         * Reads the BOOK_VERSION command from the `PipelineJson`
+         *
+         * Note: This is used in `pipelineJsonToString` utility
+         */
+        takeFromPipelineJson: function (pipelineJson) {
+            throw new NotYetImplementedError("[\uD83D\uDECB] Not implemented yet"); // <- TODO: [🛋] Implement
+        },
+    };
+
+    /**
+     * Units of text measurement
+     *
+     * @see https://github.com/webgptorg/promptbook/discussions/30
+     * @public exported from `@promptbook/core`
+     */
+    var EXPECTATION_UNITS = ['CHARACTERS', 'WORDS', 'SENTENCES', 'LINES', 'PARAGRAPHS', 'PAGES'];
+    /**
+     * TODO: [💝] Unite object for expecting amount and format - remove format
+     */
+
+    /**
+     * 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 {ParseError} if the value is not a number
+     *
+     * @public exported from `@promptbook/utils`
+     */
+    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
             }
-            else if (value instanceof Error) {
-                throw new UnexpectedError(spaceTrim__default["default"](function (block) { return "\n                        `".concat(name, "` is unserialized Error\n\n                        Use function `serializeError`\n\n                        Additional message for `").concat(name, "`:\n                        ").concat(block(message || '(nothing)'), "\n\n                    "); }));
+            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 ParseError("Unable to parse number from \"".concat(originalValue, "\" because denominator is zero"));
             }
-            else {
+            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 ParseError("Unable to parse number from \"".concat(originalValue, "\""));
+        }
+        var num = parseFloat(value);
+        if (isNaN(num)) {
+            throw new ParseError("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
+     * TODO: [🧠][🌻] Maybe export through `@promptbook/markdown-utils` not `@promptbook/utils`
+     */
+
+    /**
+     * Parses the expect command
+     *
+     * @see `documentationUrl` for more details
+     * @public exported from `@promptbook/editable`
+     */
+    var expectCommandParser = {
+        /**
+         * Name of the command
+         */
+        name: 'EXPECT',
+        /**
+         * BOILERPLATE command can be used in:
+         */
+        isUsedInPipelineHead: false,
+        isUsedInPipelineTask: true,
+        /**
+         * Description of the FORMAT command
+         */
+        description: spaceTrim__default["default"]("\n        Expect command describes the desired output of the task *(after post-processing)*\n        It can set limits for the maximum/minimum length of the output, measured in characters, words, sentences, paragraphs or some other shape of the output.\n    "),
+        /**
+         * Link to documentation
+         */
+        documentationUrl: 'https://github.com/webgptorg/promptbook/discussions/30',
+        /**
+         * Example usages of the FORMAT command
+         */
+        examples: [
+            'EXPECT MIN 100 Characters',
+            'EXPECT MAX 10 Words',
+            'EXPECT EXACTLY 3 Sentences',
+            'EXPECT EXACTLY 1 Paragraph',
+            // <- TODO: 'EXPECT 1 Paragraph',
+        ],
+        /**
+         * Parses the FORMAT command
+         */
+        parse: function (input) {
+            var e_1, _a;
+            var args = input.args;
+            try {
+                var sign = void 0;
+                var signRaw = args.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 ParseError("Invalid sign \"".concat(signRaw, "\", expected EXACTLY, MIN or MAX"));
+                }
+                var amountRaw = args.shift();
+                var amount = parseNumber(amountRaw);
+                if (amount < 0) {
+                    throw new ParseError('Amount must be positive number or zero');
+                }
+                if (amount !== Math.floor(amount)) {
+                    throw new ParseError('Amount must be whole number');
+                }
+                var unitRaw = args.shift();
+                var unit = undefined;
                 try {
-                    for (var _b = __values(Object.entries(value)), _c = _b.next(); !_c.done; _c = _b.next()) {
-                        var _d = __read(_c.value, 2), subName = _d[0], subValue = _d[1];
-                        if (subValue === undefined) {
-                            // Note: undefined in object is serializable - it is just omited
-                            continue;
+                    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 ParseError("Ambiguous unit \"".concat(unitRaw, "\""));
+                            }
+                            unit = existingUnit;
                         }
-                        checkSerializableAsJson({ name: "".concat(name, ".").concat(subName), value: subValue, message: message });
                     }
                 }
                 catch (e_1_1) { e_1 = { error: e_1_1 }; }
                 finally {
                     try {
-                        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                        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; }
                 }
-                try {
-                    JSON.stringify(value); // <- TODO: [0]
+                if (unit === undefined) {
+                    throw new ParseError("Invalid unit \"".concat(unitRaw, "\""));
                 }
-                catch (error) {
-                    if (!(error instanceof Error)) {
-                        throw error;
-                    }
-                    throw new UnexpectedError(spaceTrim__default["default"](function (block) { return "\n                            `".concat(name, "` is not serializable\n\n                            ").concat(block(error.stack || error.message), "\n\n                            Additional message for `").concat(name, "`:\n                            ").concat(block(message || '(nothing)'), "\n                        "); }));
+                return {
+                    type: 'EXPECT',
+                    sign: sign,
+                    unit: unit,
+                    amount: amount,
+                };
+            }
+            catch (error) {
+                if (!(error instanceof Error)) {
+                    throw error;
                 }
-                /*
-                TODO: [0] Is there some more elegant way to check circular references?
-                const seen = new Set();
-                const stack = [{ value }];
-                while (stack.length > 0) {
-                    const { value } = stack.pop()!;
-                    if (typeof value === 'object' && value !== null) {
-                        if (seen.has(value)) {
-                            throw new UnexpectedError(`${name} has circular reference`);
-                        }
-                        seen.add(value);
-                        if (Array.isArray(value)) {
-                            stack.push(...value.map((value) => ({ value })));
-                        } else {
-                            stack.push(...Object.values(value).map((value) => ({ value })));
-                        }
-                    }
+                throw new ParseError(spaceTrim__default["default"](function (block) {
+                    return "\n                            Invalid FORMAT command\n                            ".concat(block(error.message), ":\n                        ");
+                }));
+            }
+        },
+        /**
+         * Apply the FORMAT command to the `pipelineJson`
+         *
+         * Note: `$` is used to indicate that this function mutates given `taskJson`
+         */
+        $applyToTaskJson: function (command, $taskJson) {
+            // eslint-disable-next-line no-case-declarations
+            var unit = command.unit.toLowerCase();
+            $taskJson.expectations = $taskJson.expectations || {};
+            $taskJson.expectations[unit] = $taskJson.expectations[unit] || {};
+            if (command.sign === 'MINIMUM' || command.sign === 'EXACTLY') {
+                if ($taskJson.expectations[unit].min !== undefined) {
+                    throw new ParseError("Already defined minumum ".concat($taskJson.expectations[unit].min, " ").concat(command.unit.toLowerCase(), ", now trying to redefine it to ").concat(command.amount));
                 }
-                */
-                return;
+                $taskJson.expectations[unit].min = command.amount;
+            } /* not else */
+            if (command.sign === 'MAXIMUM' || command.sign === 'EXACTLY') {
+                if ($taskJson.expectations[unit].max !== undefined) {
+                    throw new ParseError("Already defined maximum ".concat($taskJson.expectations[unit].max, " ").concat(command.unit.toLowerCase(), ", now trying to redefine it to ").concat(command.amount));
+                }
+                $taskJson.expectations[unit].max = command.amount;
             }
+        },
+        /**
+         * Converts the FORMAT command back to string
+         *
+         * Note: This is used in `pipelineJsonToString` utility
+         */
+        stringify: function (command) {
+            return "---"; // <- TODO: [🛋] Implement
+        },
+        /**
+         * Reads the FORMAT command from the `TaskJson`
+         *
+         * Note: This is used in `pipelineJsonToString` utility
+         */
+        takeFromTaskJson: function ($taskJson) {
+            throw new NotYetImplementedError("[\uD83D\uDECB] Not implemented yet"); // <- TODO: [🛋] Implement
+        },
+    };
+
+    /**
+     * This error indicates problems parsing the format value
+     *
+     * For example, when the format value is not a valid JSON or CSV
+     * This is not thrown directly but in extended classes
+     *
+     * @public exported from `@promptbook/core`
+     */
+    var AbstractFormatError = /** @class */ (function (_super) {
+        __extends(AbstractFormatError, _super);
+        // Note: To allow instanceof do not put here error `name`
+        // public readonly name = 'AbstractFormatError';
+        function AbstractFormatError(message) {
+            var _this = _super.call(this, message) || this;
+            Object.setPrototypeOf(_this, AbstractFormatError.prototype);
+            return _this;
         }
-        else {
-            throw new UnexpectedError(spaceTrim__default["default"](function (block) { return "\n                    `".concat(name, "` is unknown type\n\n                    Additional message for `").concat(name, "`:\n                    ").concat(block(message || '(nothing)'), "\n                "); }));
-        }
-    }
+        return AbstractFormatError;
+    }(Error));
+
     /**
-     * TODO: Can be return type more type-safe? like `asserts options.value is JsonValue`
-     * TODO: [🧠][main] !!3 In-memory cache of same values to prevent multiple checks
-     * Note: [🐠] This is how `checkSerializableAsJson` + `isSerializableAsJson` together can just retun true/false or rich error message
+     * This error indicates problem with parsing of CSV
+     *
+     * @public exported from `@promptbook/core`
      */
+    var CsvFormatError = /** @class */ (function (_super) {
+        __extends(CsvFormatError, _super);
+        function CsvFormatError(message) {
+            var _this = _super.call(this, message) || this;
+            _this.name = 'CsvFormatError';
+            Object.setPrototypeOf(_this, CsvFormatError.prototype);
+            return _this;
+        }
+        return CsvFormatError;
+    }(AbstractFormatError));
 
     /**
      * @@@
      *
+     * @public exported from `@promptbook/core`
+     */
+    var MANDATORY_CSV_SETTINGS = Object.freeze({
+        header: true,
+        // encoding: 'utf-8',
+    });
+
+    /**
+     * Definition for CSV spreadsheet
+     *
+     * @public exported from `@promptbook/core`
+     *                          <- TODO: [🏢] Export from package `@promptbook/csv`
+     */
+    var CsvFormatDefinition = {
+        formatName: 'CSV',
+        aliases: ['SPREADSHEET', 'TABLE'],
+        isValid: function (value, settings, schema) {
+            return true;
+        },
+        canBeValid: function (partialValue, settings, schema) {
+            return true;
+        },
+        heal: function (value, settings, schema) {
+            throw new Error('Not implemented');
+        },
+        subvalueDefinitions: [
+            {
+                subvalueName: 'ROW',
+                mapValues: function (value, outputParameterName, settings, mapCallback) {
+                    return __awaiter(this, void 0, void 0, function () {
+                        var csv, mappedData;
+                        var _this = this;
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0:
+                                    csv = papaparse.parse(value, __assign(__assign({}, settings), MANDATORY_CSV_SETTINGS));
+                                    if (csv.errors.length !== 0) {
+                                        throw new CsvFormatError(spaceTrim__default["default"](function (block) { return "\n                                CSV parsing error\n\n                                Error(s) from CSV parsing:\n                                ".concat(block(csv.errors.map(function (error) { return error.message; }).join('\n\n')), "\n\n                                The CSV setings:\n                                ").concat(block(JSON.stringify(__assign(__assign({}, settings), MANDATORY_CSV_SETTINGS), null, 2)), "\n\n                                The CSV data:\n                                ").concat(block(value), "\n                            "); }));
+                                    }
+                                    return [4 /*yield*/, Promise.all(csv.data.map(function (row, index) { return __awaiter(_this, void 0, void 0, function () {
+                                            var _a, _b;
+                                            var _c;
+                                            return __generator(this, function (_d) {
+                                                switch (_d.label) {
+                                                    case 0:
+                                                        if (row[outputParameterName]) {
+                                                            throw new CsvFormatError("Can not overwrite existing column \"".concat(outputParameterName, "\" in CSV row"));
+                                                        }
+                                                        _a = [__assign({}, row)];
+                                                        _c = {};
+                                                        _b = outputParameterName;
+                                                        return [4 /*yield*/, mapCallback(row, index)];
+                                                    case 1: return [2 /*return*/, __assign.apply(void 0, _a.concat([(_c[_b] = _d.sent(), _c)]))];
+                                                }
+                                            });
+                                        }); }))];
+                                case 1:
+                                    mappedData = _a.sent();
+                                    return [2 /*return*/, papaparse.unparse(mappedData, __assign(__assign({}, settings), MANDATORY_CSV_SETTINGS))];
+                            }
+                        });
+                    });
+                },
+            },
+            {
+                subvalueName: 'CELL',
+                mapValues: function (value, outputParameterName, settings, mapCallback) {
+                    return __awaiter(this, void 0, void 0, function () {
+                        var csv, mappedData;
+                        var _this = this;
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0:
+                                    csv = papaparse.parse(value, __assign(__assign({}, settings), MANDATORY_CSV_SETTINGS));
+                                    if (csv.errors.length !== 0) {
+                                        throw new CsvFormatError(spaceTrim__default["default"](function (block) { return "\n                                CSV parsing error\n\n                                Error(s) from CSV parsing:\n                                ".concat(block(csv.errors.map(function (error) { return error.message; }).join('\n\n')), "\n\n                                The CSV setings:\n                                ").concat(block(JSON.stringify(__assign(__assign({}, settings), MANDATORY_CSV_SETTINGS), null, 2)), "\n\n                                The CSV data:\n                                ").concat(block(value), "\n                            "); }));
+                                    }
+                                    return [4 /*yield*/, Promise.all(csv.data.map(function (row, rowIndex) { return __awaiter(_this, void 0, void 0, function () {
+                                            var _this = this;
+                                            return __generator(this, function (_a) {
+                                                return [2 /*return*/, /* not await */ Promise.all(Object.entries(row).map(function (_a, columnIndex) {
+                                                        var _b = __read(_a, 2), key = _b[0], value = _b[1];
+                                                        return __awaiter(_this, void 0, void 0, function () {
+                                                            var index;
+                                                            var _c;
+                                                            return __generator(this, function (_d) {
+                                                                index = rowIndex * Object.keys(row).length + columnIndex;
+                                                                return [2 /*return*/, /* not await */ mapCallback((_c = {}, _c[key] = value, _c), index)];
+                                                            });
+                                                        });
+                                                    }))];
+                                            });
+                                        }); }))];
+                                case 1:
+                                    mappedData = _a.sent();
+                                    return [2 /*return*/, papaparse.unparse(mappedData, __assign(__assign({}, settings), MANDATORY_CSV_SETTINGS))];
+                            }
+                        });
+                    });
+                },
+            },
+        ],
+    };
+    /**
+     * TODO: [🍓] In `CsvFormatDefinition` implement simple `isValid`
+     * TODO: [🍓] In `CsvFormatDefinition` implement partial `canBeValid`
+     * TODO: [🍓] In `CsvFormatDefinition` implement `heal
+     * TODO: [🍓] In `CsvFormatDefinition` implement `subvalueDefinitions`
+     * TODO: [🏢] Allow to expect something inside CSV objects and other formats
+     */
+
+    /**
+     * Function isValidJsonString will tell you if the string is valid JSON or not
+     *
      * @public exported from `@promptbook/utils`
      */
-    function deepClone(objectValue) {
-        return JSON.parse(JSON.stringify(objectValue));
-        /*
-        TODO: [🧠] Is there a better implementation?
-        > const propertyNames = Object.getOwnPropertyNames(objectValue);
-        > for (const propertyName of propertyNames) {
-        >     const value = (objectValue as really_any)[propertyName];
-        >     if (value && typeof value === 'object') {
-        >         deepClone(value);
-        >     }
-        > }
-        > return Object.assign({}, objectValue);
-        */
+    function isValidJsonString(value /* <- [👨‍⚖️] */) {
+        try {
+            JSON.parse(value);
+            return true;
+        }
+        catch (error) {
+            if (!(error instanceof Error)) {
+                throw error;
+            }
+            if (error.message.includes('Unexpected token')) {
+                return false;
+            }
+            return false;
+        }
     }
+
     /**
-     * TODO: [🧠] Is there a way how to meaningfully test this utility
+     * Definition for JSON format
+     *
+     * @private still in development [🏢]
+     */
+    var JsonFormatDefinition = {
+        formatName: 'JSON',
+        mimeType: 'application/json',
+        isValid: function (value, settings, schema) {
+            return isValidJsonString(value);
+        },
+        canBeValid: function (partialValue, settings, schema) {
+            return true;
+        },
+        heal: function (value, settings, schema) {
+            throw new Error('Not implemented');
+        },
+        subvalueDefinitions: [],
+    };
+    /**
+     * TODO: [🧠] Maybe propper instance of object
+     * TODO: [0] Make string_serialized_json
+     * TODO: [1] Make type for JSON Settings and Schema
+     * TODO: [🧠] What to use for validating JSONs - JSON Schema, ZoD, typescript types/interfaces,...?
+     * TODO: [🍓] In `JsonFormatDefinition` implement simple `isValid`
+     * TODO: [🍓] In `JsonFormatDefinition` implement partial `canBeValid`
+     * TODO: [🍓] In `JsonFormatDefinition` implement `heal
+     * TODO: [🍓] In `JsonFormatDefinition` implement `subvalueDefinitions`
+     * TODO: [🏢] Allow to expect something inside JSON objects and other formats
      */
 
     /**
-     * Utility to export a JSON object from a function
-     *
-     * 1) Checks if the value is serializable as JSON
-     * 2) Makes a deep clone of the object
-     * 2) Orders the object properties
-     * 2) Deeply freezes the cloned object
+     * Definition for any text - this will be always valid
      *
-     * Note: This function does not mutates the given object
+     * Note: This is not useful for validation, but for splitting and mapping with `subvalueDefinitions`
      *
-     * @returns The same type of object as the input but read-only and re-ordered
-     * @public exported from `@promptbook/utils`
+     * @public exported from `@promptbook/core`
      */
-    function exportJson(options) {
-        var name = options.name, value = options.value, order = options.order, message = options.message;
-        checkSerializableAsJson({ name: name, value: value, message: message });
-        var orderedValue = 
-        // TODO: Fix error "Type instantiation is excessively deep and possibly infinite."
-        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-        // @ts-ignore
-        order === undefined
-            ? deepClone(value)
-            : orderJson({
-                value: value,
-                // <- Note: checkSerializableAsJson asserts that the value is serializable as JSON
-                order: order,
-            });
-        $deepFreeze(orderedValue);
-        return orderedValue;
-    }
+    var TextFormatDefinition = {
+        formatName: 'TEXT',
+        isValid: function (value) {
+            return typeof value === 'string';
+        },
+        canBeValid: function (partialValue) {
+            return typeof partialValue === 'string';
+        },
+        heal: function () {
+            throw new UnexpectedError('It does not make sense to call `TextFormatDefinition.heal`');
+        },
+        subvalueDefinitions: [
+            {
+                subvalueName: 'LINE',
+                mapValues: function (value, outputParameterName, settings, mapCallback) {
+                    return __awaiter(this, void 0, void 0, function () {
+                        var lines, mappedLines;
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0:
+                                    lines = value.split('\n');
+                                    return [4 /*yield*/, Promise.all(lines.map(function (lineContent, lineNumber) {
+                                            // TODO: [🧠] Maybe option to skip empty line
+                                            /* not await */ return mapCallback({
+                                                lineContent: lineContent,
+                                                // TODO: [🧠] Maybe also put here `lineNumber`
+                                            }, lineNumber);
+                                        }))];
+                                case 1:
+                                    mappedLines = _a.sent();
+                                    return [2 /*return*/, mappedLines.join('\n')];
+                            }
+                        });
+                    });
+                },
+            },
+            // <- TODO: [🧠][🤠] Here should be all words, characters, lines, paragraphs, pages aviable as subvalues
+        ],
+    };
     /**
-     * TODO: [🧠] Is there a way how to meaningfully test this utility
+     * TODO: [1] Make type for XML Text and Schema
+     * TODO: [🧠][🤠] Here should be all words, characters, lines, paragraphs, pages aviable as subvalues
+     * TODO: [🍓] In `TextFormatDefinition` implement simple `isValid`
+     * TODO: [🍓] In `TextFormatDefinition` implement partial `canBeValid`
+     * TODO: [🍓] In `TextFormatDefinition` implement `heal
+     * TODO: [🍓] In `TextFormatDefinition` implement `subvalueDefinitions`
+     * TODO: [🏢] Allow to expect something inside each item of list and other formats
      */
 
     /**
-     * Nonce which is used for replacing things in strings
+     * Definition for XML format
      *
-     * @private within the repository
+     * @private still in development [🏢]
      */
-    var REPLACING_NONCE = 'u$k42k%!V2zo34w7Fu#@QUHYPW';
+    var XmlFormatDefinition = {
+        formatName: 'XML',
+        mimeType: 'application/xml',
+        isValid: function (value, settings, schema) {
+            return true;
+        },
+        canBeValid: function (partialValue, settings, schema) {
+            return true;
+        },
+        heal: function (value, settings, schema) {
+            throw new Error('Not implemented');
+        },
+        subvalueDefinitions: [],
+    };
     /**
-     * The names of the parameters that are reserved for special purposes
+     * TODO: [🧠] Maybe propper instance of object
+     * TODO: [0] Make string_serialized_xml
+     * TODO: [1] Make type for XML Settings and Schema
+     * TODO: [🧠] What to use for validating XMLs - XSD,...
+     * TODO: [🍓] In `XmlFormatDefinition` implement simple `isValid`
+     * TODO: [🍓] In `XmlFormatDefinition` implement partial `canBeValid`
+     * TODO: [🍓] In `XmlFormatDefinition` implement `heal
+     * TODO: [🍓] In `XmlFormatDefinition` implement `subvalueDefinitions`
+     * TODO: [🏢] Allow to expect something inside XML and other formats
+     */
+
+    /**
+     * Definitions for all formats supported by Promptbook
      *
-     * @public exported from `@promptbook/core`
+     * @private internal index of `...` <- TODO [🏢]
      */
-    exportJson({
-        name: 'RESERVED_PARAMETER_NAMES',
-        message: "The names of the parameters that are reserved for special purposes",
-        value: [
-            'content',
-            'context',
-            'knowledge',
-            'examples',
-            'modelName',
-            'currentDate',
-            // <- TODO: list here all command names
-            // <- TODO: Add more like 'date', 'modelName',...
-            // <- TODO: Add [emoji] + instructions ACRY when adding new reserved parameter
-        ],
-    });
+    var FORMAT_DEFINITIONS = [
+        JsonFormatDefinition,
+        XmlFormatDefinition,
+        TextFormatDefinition,
+        CsvFormatDefinition,
+    ];
     /**
      * Note: [💞] Ignore a discrepancy between file name and entity name
      */
 
+    /**
+     * @@@
+     *
+     * @param text @@@
+     * @returns @@@
+     * @example 'HELLO_WORLD'
+     * @example 'I_LOVE_PROMPTBOOK'
+     * @public exported from `@promptbook/utils`
+     */
+    function normalizeTo_SCREAMING_CASE(text) {
+        var e_1, _a;
+        var charType;
+        var lastCharType = 'OTHER';
+        var normalizedName = '';
+        try {
+            for (var text_1 = __values(text), text_1_1 = text_1.next(); !text_1_1.done; text_1_1 = text_1.next()) {
+                var char = text_1_1.value;
+                var normalizedChar = void 0;
+                if (/^[a-z]$/.test(char)) {
+                    charType = 'LOWERCASE';
+                    normalizedChar = char.toUpperCase();
+                }
+                else if (/^[A-Z]$/.test(char)) {
+                    charType = 'UPPERCASE';
+                    normalizedChar = char;
+                }
+                else if (/^[0-9]$/.test(char)) {
+                    charType = 'NUMBER';
+                    normalizedChar = char;
+                }
+                else {
+                    charType = 'OTHER';
+                    normalizedChar = '_';
+                }
+                if (charType !== lastCharType &&
+                    !(lastCharType === 'UPPERCASE' && charType === 'LOWERCASE') &&
+                    !(lastCharType === 'NUMBER') &&
+                    !(charType === 'NUMBER')) {
+                    normalizedName += '_';
+                }
+                normalizedName += normalizedChar;
+                lastCharType = charType;
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (text_1_1 && !text_1_1.done && (_a = text_1.return)) _a.call(text_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        normalizedName = normalizedName.replace(/_+/g, '_');
+        normalizedName = normalizedName.replace(/_?\/_?/g, '/');
+        normalizedName = normalizedName.replace(/^_/, '');
+        normalizedName = normalizedName.replace(/_$/, '');
+        return normalizedName;
+    }
+    /**
+     * TODO: Tests
+     *     > expect(encodeRoutePath({ uriId: 'VtG7sR9rRJqwNEdM2', name: 'Moje tabule' })).toEqual('/VtG7sR9rRJqwNEdM2/Moje tabule');
+     *     > expect(encodeRoutePath({ uriId: 'VtG7sR9rRJqwNEdM2', name: 'ěščřžžýáíúů' })).toEqual('/VtG7sR9rRJqwNEdM2/escrzyaieuu');
+     *     > expect(encodeRoutePath({ uriId: 'VtG7sR9rRJqwNEdM2', name: '  ahoj  ' })).toEqual('/VtG7sR9rRJqwNEdM2/ahoj');
+     *     > expect(encodeRoutePath({ uriId: 'VtG7sR9rRJqwNEdM2', name: '  ahoj_ahojAhoj    ahoj  ' })).toEqual('/VtG7sR9rRJqwNEdM2/ahoj-ahoj-ahoj-ahoj');
+     * TODO: [🌺] Use some intermediate util splitWords
+     */
+
+    /**
+     * Orders JSON object by keys
+     *
+     * @returns The same type of object as the input re-ordered
+     * @public exported from `@promptbook/utils`
+     */
+    function orderJson(options) {
+        var value = options.value, order = options.order;
+        var orderedValue = __assign(__assign({}, (order === undefined ? {} : Object.fromEntries(order.map(function (key) { return [key, undefined]; })))), value);
+        return orderedValue;
+    }
+
+    /**
+     * Freezes the given object and all its nested objects recursively
+     *
+     * Note: `$` is used to indicate that this function is not a pure function - it mutates given object
+     * Note: This function mutates the object and returns the original (but mutated-deep-freezed) object
+     *
+     * @returns The same object as the input, but deeply frozen
+     * @public exported from `@promptbook/utils`
+     */
+    function $deepFreeze(objectValue) {
+        var e_1, _a;
+        if (Array.isArray(objectValue)) {
+            return Object.freeze(objectValue.map(function (item) { return $deepFreeze(item); }));
+        }
+        var propertyNames = Object.getOwnPropertyNames(objectValue);
+        try {
+            for (var propertyNames_1 = __values(propertyNames), propertyNames_1_1 = propertyNames_1.next(); !propertyNames_1_1.done; propertyNames_1_1 = propertyNames_1.next()) {
+                var propertyName = propertyNames_1_1.value;
+                var value = objectValue[propertyName];
+                if (value && typeof value === 'object') {
+                    $deepFreeze(value);
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (propertyNames_1_1 && !propertyNames_1_1.done && (_a = propertyNames_1.return)) _a.call(propertyNames_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        Object.freeze(objectValue);
+        return objectValue;
+    }
+    /**
+     * TODO: [🧠] Is there a way how to meaningfully test this utility
+     */
+
+    /**
+     * Checks if the value is [🚉] serializable as JSON
+     * If not, throws an UnexpectedError with a rich error message and tracking
+     *
+     * - Almost all primitives are serializable BUT:
+     * - `undefined` is not serializable
+     * - `NaN` is not serializable
+     * - Objects and arrays are serializable if all their properties are serializable
+     * - Functions are not serializable
+     * - Circular references are not serializable
+     * - `Date` objects are not serializable
+     * - `Map` and `Set` objects are not serializable
+     * - `RegExp` objects are not serializable
+     * - `Error` objects are not serializable
+     * - `Symbol` objects are not serializable
+     * - And much more...
+     *
+     * @throws UnexpectedError if the value is not serializable as JSON
+     * @public exported from `@promptbook/utils`
+     */
+    function checkSerializableAsJson(options) {
+        var e_1, _a;
+        var value = options.value, name = options.name, message = options.message;
+        if (value === undefined) {
+            throw new UnexpectedError("".concat(name, " is undefined"));
+        }
+        else if (value === null) {
+            return;
+        }
+        else if (typeof value === 'boolean') {
+            return;
+        }
+        else if (typeof value === 'number' && !isNaN(value)) {
+            return;
+        }
+        else if (typeof value === 'string') {
+            return;
+        }
+        else if (typeof value === 'symbol') {
+            throw new UnexpectedError("".concat(name, " is symbol"));
+        }
+        else if (typeof value === 'function') {
+            throw new UnexpectedError("".concat(name, " is function"));
+        }
+        else if (typeof value === 'object' && Array.isArray(value)) {
+            for (var i = 0; i < value.length; i++) {
+                checkSerializableAsJson({ name: "".concat(name, "[").concat(i, "]"), value: value[i], message: message });
+            }
+        }
+        else if (typeof value === 'object') {
+            if (value instanceof Date) {
+                throw new UnexpectedError(spaceTrim__default["default"](function (block) { return "\n                        `".concat(name, "` is Date\n\n                        Use `string_date_iso8601` instead\n\n                        Additional message for `").concat(name, "`:\n                        ").concat(block(message || '(nothing)'), "\n                    "); }));
+            }
+            else if (value instanceof Map) {
+                throw new UnexpectedError("".concat(name, " is Map"));
+            }
+            else if (value instanceof Set) {
+                throw new UnexpectedError("".concat(name, " is Set"));
+            }
+            else if (value instanceof RegExp) {
+                throw new UnexpectedError("".concat(name, " is RegExp"));
+            }
+            else if (value instanceof Error) {
+                throw new UnexpectedError(spaceTrim__default["default"](function (block) { return "\n                        `".concat(name, "` is unserialized Error\n\n                        Use function `serializeError`\n\n                        Additional message for `").concat(name, "`:\n                        ").concat(block(message || '(nothing)'), "\n\n                    "); }));
+            }
+            else {
+                try {
+                    for (var _b = __values(Object.entries(value)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                        var _d = __read(_c.value, 2), subName = _d[0], subValue = _d[1];
+                        if (subValue === undefined) {
+                            // Note: undefined in object is serializable - it is just omited
+                            continue;
+                        }
+                        checkSerializableAsJson({ name: "".concat(name, ".").concat(subName), value: subValue, message: message });
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+                try {
+                    JSON.stringify(value); // <- TODO: [0]
+                }
+                catch (error) {
+                    if (!(error instanceof Error)) {
+                        throw error;
+                    }
+                    throw new UnexpectedError(spaceTrim__default["default"](function (block) { return "\n                            `".concat(name, "` is not serializable\n\n                            ").concat(block(error.stack || error.message), "\n\n                            Additional message for `").concat(name, "`:\n                            ").concat(block(message || '(nothing)'), "\n                        "); }));
+                }
+                /*
+                TODO: [0] Is there some more elegant way to check circular references?
+                const seen = new Set();
+                const stack = [{ value }];
+                while (stack.length > 0) {
+                    const { value } = stack.pop()!;
+                    if (typeof value === 'object' && value !== null) {
+                        if (seen.has(value)) {
+                            throw new UnexpectedError(`${name} has circular reference`);
+                        }
+                        seen.add(value);
+                        if (Array.isArray(value)) {
+                            stack.push(...value.map((value) => ({ value })));
+                        } else {
+                            stack.push(...Object.values(value).map((value) => ({ value })));
+                        }
+                    }
+                }
+                */
+                return;
+            }
+        }
+        else {
+            throw new UnexpectedError(spaceTrim__default["default"](function (block) { return "\n                    `".concat(name, "` is unknown type\n\n                    Additional message for `").concat(name, "`:\n                    ").concat(block(message || '(nothing)'), "\n                "); }));
+        }
+    }
+    /**
+     * TODO: Can be return type more type-safe? like `asserts options.value is JsonValue`
+     * TODO: [🧠][main] !!3 In-memory cache of same values to prevent multiple checks
+     * Note: [🐠] This is how `checkSerializableAsJson` + `isSerializableAsJson` together can just retun true/false or rich error message
+     */
+
+    /**
+     * @@@
+     *
+     * @public exported from `@promptbook/utils`
+     */
+    function deepClone(objectValue) {
+        return JSON.parse(JSON.stringify(objectValue));
+        /*
+        TODO: [🧠] Is there a better implementation?
+        > const propertyNames = Object.getOwnPropertyNames(objectValue);
+        > for (const propertyName of propertyNames) {
+        >     const value = (objectValue as really_any)[propertyName];
+        >     if (value && typeof value === 'object') {
+        >         deepClone(value);
+        >     }
+        > }
+        > return Object.assign({}, objectValue);
+        */
+    }
+    /**
+     * TODO: [🧠] Is there a way how to meaningfully test this utility
+     */
+
+    /**
+     * Utility to export a JSON object from a function
+     *
+     * 1) Checks if the value is serializable as JSON
+     * 2) Makes a deep clone of the object
+     * 2) Orders the object properties
+     * 2) Deeply freezes the cloned object
+     *
+     * Note: This function does not mutates the given object
+     *
+     * @returns The same type of object as the input but read-only and re-ordered
+     * @public exported from `@promptbook/utils`
+     */
+    function exportJson(options) {
+        var name = options.name, value = options.value, order = options.order, message = options.message;
+        checkSerializableAsJson({ name: name, value: value, message: message });
+        var orderedValue = 
+        // TODO: Fix error "Type instantiation is excessively deep and possibly infinite."
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        order === undefined
+            ? deepClone(value)
+            : orderJson({
+                value: value,
+                // <- Note: checkSerializableAsJson asserts that the value is serializable as JSON
+                order: order,
+            });
+        $deepFreeze(orderedValue);
+        return orderedValue;
+    }
+    /**
+     * TODO: [🧠] Is there a way how to meaningfully test this utility
+     */
+
+    /**
+     * Nonce which is used for replacing things in strings
+     *
+     * @private within the repository
+     */
+    var REPLACING_NONCE = 'u$k42k%!V2zo34w7Fu#@QUHYPW';
+    /**
+     * The names of the parameters that are reserved for special purposes
+     *
+     * @public exported from `@promptbook/core`
+     */
+    var RESERVED_PARAMETER_NAMES = exportJson({
+        name: 'RESERVED_PARAMETER_NAMES',
+        message: "The names of the parameters that are reserved for special purposes",
+        value: [
+            'content',
+            'context',
+            'knowledge',
+            'examples',
+            'modelName',
+            'currentDate',
+            // <- TODO: list here all command names
+            // <- TODO: Add more like 'date', 'modelName',...
+            // <- TODO: Add [emoji] + instructions ACRY when adding new reserved parameter
+        ],
+    });
+    /**
+     * Note: [💞] Ignore a discrepancy between file name and entity name
+     */
+
+    /**
+     * @@@
+     *
+     * @param text @@@
+     * @param _isFirstLetterCapital @@@
+     * @returns @@@
+     * @example 'helloWorld'
+     * @example 'iLovePromptbook'
+     * @public exported from `@promptbook/utils`
+     */
+    function normalizeTo_camelCase(text, _isFirstLetterCapital) {
+        var e_1, _a;
+        if (_isFirstLetterCapital === void 0) { _isFirstLetterCapital = false; }
+        var charType;
+        var lastCharType = null;
+        var normalizedName = '';
+        try {
+            for (var text_1 = __values(text), text_1_1 = text_1.next(); !text_1_1.done; text_1_1 = text_1.next()) {
+                var char = text_1_1.value;
+                var normalizedChar = void 0;
+                if (/^[a-z]$/.test(char)) {
+                    charType = 'LOWERCASE';
+                    normalizedChar = char;
+                }
+                else if (/^[A-Z]$/.test(char)) {
+                    charType = 'UPPERCASE';
+                    normalizedChar = char.toLowerCase();
+                }
+                else if (/^[0-9]$/.test(char)) {
+                    charType = 'NUMBER';
+                    normalizedChar = char;
+                }
+                else {
+                    charType = 'OTHER';
+                    normalizedChar = '';
+                }
+                if (!lastCharType) {
+                    if (_isFirstLetterCapital) {
+                        normalizedChar = normalizedChar.toUpperCase(); //TODO: DRY
+                    }
+                }
+                else if (charType !== lastCharType &&
+                    !(charType === 'LOWERCASE' && lastCharType === 'UPPERCASE') &&
+                    !(lastCharType === 'NUMBER') &&
+                    !(charType === 'NUMBER')) {
+                    normalizedChar = normalizedChar.toUpperCase(); //TODO: [🌺] DRY
+                }
+                normalizedName += normalizedChar;
+                lastCharType = charType;
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (text_1_1 && !text_1_1.done && (_a = text_1.return)) _a.call(text_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return normalizedName;
+    }
+    /**
+     * TODO: [🌺] Use some intermediate util splitWords
+     */
+
+    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"
+     * > ...
+     *
+     * @public exported from `@promptbook/utils`
+     */
+    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.
+    */
+
+    /**
+     * @@@
+     *
+     * @param input @@@
+     * @returns @@@
+     * @public exported from `@promptbook/utils`
+     */
+    function removeDiacritics(input) {
+        /*eslint no-control-regex: "off"*/
+        return input.replace(/[^\u0000-\u007E]/g, function (a) {
+            return DIACRITIC_VARIANTS_LETTERS[a] || a;
+        });
+    }
+    /**
+     * TODO: [Ж] Variant for cyrillic (and in general non-latin) letters
+     */
+
+    /**
+     * Removes emojis from a string and fix whitespaces
+     *
+     * @param text with emojis
+     * @returns text without emojis
+     * @public exported from `@promptbook/utils`
+     */
+    function removeEmojis(text) {
+        // Replace emojis (and also ZWJ sequence) with hyphens
+        text = text.replace(/(\p{Extended_Pictographic})\p{Modifier_Symbol}/gu, '$1');
+        text = text.replace(/(\p{Extended_Pictographic})[\u{FE00}-\u{FE0F}]/gu, '$1');
+        text = text.replace(/(\p{Extended_Pictographic})(\u{200D}\p{Extended_Pictographic})*/gu, '$1');
+        text = text.replace(/\p{Extended_Pictographic}/gu, '');
+        return text;
+    }
+
+    /**
+     * Removes quotes from a string
+     *
+     * Tip: This is very usefull for post-processing of the result of the LLM model
+     * Note: This function removes only the same quotes from the beginning and the end of the string
+     * Note: There are two simmilar functions:
+     * - `removeQuotes` which removes only bounding quotes
+     * - `unwrapResult` which removes whole introduce sentence
+     *
+     * @param text optionally quoted text
+     * @returns text without quotes
+     * @public exported from `@promptbook/utils`
+     */
+    function removeQuotes(text) {
+        if (text.startsWith('"') && text.endsWith('"')) {
+            return text.slice(1, -1);
+        }
+        if (text.startsWith('\'') && text.endsWith('\'')) {
+            return text.slice(1, -1);
+        }
+        return text;
+    }
+
+    /**
+     * Function `validateParameterName` will @@@
+     *
+     * @param parameterName @@@
+     * @returns @@@
+     * @throws {ParseError} @@@
+     * @private within the repository
+     */
+    function validateParameterName(parameterName) {
+        var e_1, _a;
+        var rawParameterName = parameterName;
+        try {
+            for (var _b = __values([
+                ['`', '`'],
+                ['{', '}'],
+                ['[', ']'],
+                ['(', ')'],
+                ['<', '>'],
+            ]), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var _d = __read(_c.value, 2), start = _d[0], end = _d[1];
+                if (parameterName.substring(0, 1) === start &&
+                    parameterName.substring(parameterName.length - 1, parameterName.length) === end
+                // <- TODO: More universal that 1 character
+                ) {
+                    parameterName = parameterName.substring(1, parameterName.length - 1);
+                    // <- TODO: More universal that 1 character
+                }
+            }
+        }
+        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; }
+        }
+        // TODO: [🐠] Following try-catch block should be part of common validators logic
+        try {
+            /*
+            Note: We don't need to check for spaces because we are going to normalize the parameter name to camelCase
+            if (parameterName.includes(' ')) {
+                throw new ParseError(`Parameter name cannot contain spaces`);
+            }
+            */
+            if (parameterName.includes('.')) {
+                throw new ParseError("Parameter name cannot contain dots");
+            }
+            if (parameterName.includes('/') || parameterName.includes('\\')) {
+                throw new ParseError("Parameter name cannot contain slashes");
+            }
+            if (parameterName.includes('(') ||
+                parameterName.includes(')') ||
+                parameterName.includes('{') ||
+                parameterName.includes('}') ||
+                parameterName.includes('[') ||
+                parameterName.includes(']')) {
+                throw new ParseError("Parameter name cannot contain braces");
+            }
+            parameterName = removeDiacritics(parameterName);
+            parameterName = removeEmojis(parameterName);
+            parameterName = removeQuotes(parameterName);
+            parameterName = normalizeTo_camelCase(parameterName);
+            if (parameterName === '') {
+                throw new ParseError("Parameter name cannot be empty");
+            }
+            if (RESERVED_PARAMETER_NAMES.includes(parameterName)) {
+                throw new ParseError("{".concat(parameterName, "} is a reserved parameter name"));
+            }
+        }
+        catch (error) {
+            if (!(error instanceof ParseError)) {
+                throw error;
+            }
+            throw new ParseError(spaceTrim__default["default"](function (block) { return "\n                    ".concat(block(error.message), "\n\n                    Tried to validate parameter name:\n                    ").concat(block(rawParameterName), "\n                "); }));
+        }
+        return parameterName;
+    }
+
+    /**
+     * Parses the foreach command
+     *
+     * Note: @@@ This command is used as foreach for new commands - it should NOT be used in any `.book.md` file
+     *
+     * @see `documentationUrl` for more details
+     * @public exported from `@promptbook/editable`
+     */
+    var foreachCommandParser = {
+        /**
+         * Name of the command
+         */
+        name: 'FOREACH',
+        /**
+         * Aliases for the FOREACH command
+         */
+        aliasNames: ['FOR', 'EACH'],
+        /**
+         * FOREACH command can be used in:
+         */
+        isUsedInPipelineHead: false,
+        isUsedInPipelineTask: true,
+        /**
+         * Description of the FOREACH command
+         */
+        description: "@@",
+        /**
+         * Link to documentation
+         */
+        documentationUrl: 'https://github.com/webgptorg/promptbook/discussions/148',
+        /**
+         * Example usages of the FOREACH command
+         */
+        examples: [
+            'FOREACH Text Line `{customers}` -> `{customer}`',
+            'FOREACH Csv Cell `{customers}` -> `{cell}`',
+            'FOREACH Csv Row `{customers}` -> `{firstName}`, `{lastName}`, `+{email}`',
+            'FOR Text Line `{customers}` -> `{customer}`',
+            'EACH Text Line `{customers}` -> `{customer}`',
+        ],
+        /**
+         * Parses the FOREACH command
+         */
+        parse: function (input) {
+            var args = input.args;
+            var formatName = normalizeTo_SCREAMING_CASE(args[0] || '');
+            var subformatName = normalizeTo_SCREAMING_CASE(args[1] || '');
+            var parameterNameArg = args[2] || '';
+            var assignSign = args[3];
+            var formatDefinition = FORMAT_DEFINITIONS.find(function (formatDefinition) {
+                return __spreadArray([formatDefinition.formatName], __read((formatDefinition.aliases || [])), false).includes(formatName);
+            });
+            if (formatDefinition === undefined) {
+                throw new ParseError(spaceTrim__default["default"](function (block) { return "\n                        Unsupported format \"".concat(formatName, "\"\n\n                        Available formats:\n                        ").concat(block(FORMAT_DEFINITIONS.map(function (formatDefinition) { return formatDefinition.formatName; })
+                    .map(function (formatName) { return "- ".concat(formatName); })
+                    .join('\n')), "\n                    "); }));
+                // <- TODO: [🏢] List all supported format names
+            }
+            var subvalueDefinition = formatDefinition.subvalueDefinitions.find(function (subvalueDefinition) {
+                return __spreadArray([subvalueDefinition.subvalueName], __read((subvalueDefinition.aliases || [])), false).includes(subformatName);
+            });
+            if (subvalueDefinition === undefined) {
+                throw new ParseError(spaceTrim__default["default"](function (block) { return "\n                        Unsupported subformat name \"".concat(subformatName, "\" for format \"").concat(formatName, "\"\n\n                        Available subformat names for format \"").concat(formatDefinition.formatName, "\":\n                        ").concat(block(formatDefinition.subvalueDefinitions
+                    .map(function (subvalueDefinition) { return subvalueDefinition.subvalueName; })
+                    .map(function (subvalueName) { return "- ".concat(subvalueName); })
+                    .join('\n')), "\n                    "); }));
+                // <- TODO: [🏢] List all supported subformat names for the format
+            }
+            if (assignSign !== '->') {
+                throw new ParseError("FOREACH command must have '->' to assign the value to the parameter");
+            }
+            var parameterName = validateParameterName(parameterNameArg);
+            var outputSubparameterName = null;
+            // TODO: [4] DRY
+            var inputSubparameterNames = args
+                .slice(4)
+                .map(function (parameterName) { return parameterName.split(',').join(' ').trim(); })
+                .filter(function (parameterName) { return !parameterName.includes('+'); })
+                .filter(function (parameterName) { return parameterName !== ''; })
+                .map(validateParameterName);
+            // TODO: [4] DRY
+            var outputSubparameterNames = args
+                .slice(4)
+                .map(function (parameterName) { return parameterName.split(',').join(' ').trim(); })
+                .filter(function (parameterName) { return parameterName.includes('+'); })
+                .map(function (parameterName) { return parameterName.split('+').join(''); })
+                .map(validateParameterName);
+            if (outputSubparameterNames.length === 1) {
+                outputSubparameterName = outputSubparameterNames[0];
+            }
+            else if (outputSubparameterNames.length > 1) {
+                throw new ParseError("FOREACH command can not have more than one output subparameter");
+            }
+            if (inputSubparameterNames.length === 0) {
+                throw new ParseError("FOREACH command must have at least one input subparameter");
+            }
+            if (outputSubparameterName === null) {
+                // TODO: Following code should be unhardcoded from here and moved to the format definition
+                if (formatName === 'CSV' && subformatName === 'CELL') {
+                    outputSubparameterName = 'newCell';
+                }
+                else if (formatName === 'TEXT' && subformatName === 'LINE') {
+                    outputSubparameterName = 'newLine';
+                }
+                else {
+                    throw new ParseError(spaceTrim__default["default"]("\n                        FOREACH ".concat(formatName, " ").concat(subformatName, " must specify output subparameter\n\n                        Correct example:\n                        - FOREACH ").concat(formatName, " ").concat(subformatName, " {").concat(parameterName, "} -> {inputSubparameterName1}, {inputSubparameterName2}, +{outputSubparameterName}\n\n                    ")));
+                }
+            }
+            return {
+                type: 'FOREACH',
+                formatName: formatName,
+                subformatName: subformatName,
+                parameterName: parameterName,
+                inputSubparameterNames: inputSubparameterNames,
+                outputSubparameterName: outputSubparameterName,
+            };
+        },
+        /**
+         * Apply the FOREACH command to the `pipelineJson`
+         *
+         * Note: `$` is used to indicate that this function mutates given `taskJson`
+         */
+        $applyToTaskJson: function (command, $taskJson, $pipelineJson) {
+            var formatName = command.formatName, subformatName = command.subformatName, parameterName = command.parameterName, inputSubparameterNames = command.inputSubparameterNames, outputSubparameterName = command.outputSubparameterName;
+            // TODO: [🍭] Detect double use
+            // TODO: [🍭] Detect usage with JOKER and don't allow it
+            $taskJson.foreach = {
+                formatName: formatName,
+                subformatName: subformatName,
+                parameterName: parameterName,
+                inputSubparameterNames: inputSubparameterNames,
+                outputSubparameterName: outputSubparameterName,
+            };
+            // Note: [🍭] FOREACH apply has some sideeffects on different places in codebase
+        },
+        /**
+         * Converts the FOREACH command back to string
+         *
+         * Note: This is used in `pipelineJsonToString` utility
+         */
+        stringify: function (command) {
+            return "---"; // <- TODO: [🛋] Implement
+        },
+        /**
+         * Reads the FOREACH command from the `TaskJson`
+         *
+         * Note: This is used in `pipelineJsonToString` utility
+         */
+        takeFromTaskJson: function ($taskJson) {
+            throw new NotYetImplementedError("[\uD83D\uDECB] Not implemented yet"); // <- TODO: [🛋] Implement
+        },
+    };
+    /**
+     * TODO: [🍭] Make .book.md file with examples of the FOREACH with wrong parsing and logic
+     */
+
+    /**
+     * Parses the format command
+     *
+     * @see `documentationUrl` for more details
+     * @public exported from `@promptbook/editable`
+     */
+    var formatCommandParser = {
+        /**
+         * Name of the command
+         */
+        name: 'FORMAT',
+        /**
+         * BOILERPLATE command can be used in:
+         */
+        isUsedInPipelineHead: false,
+        isUsedInPipelineTask: true,
+        /**
+         * Description of the FORMAT command
+         */
+        description: spaceTrim__default["default"]("\n        Format command describes the desired output of the task (after post-processing)\n        It can set limits for the maximum/minimum length of the output, measured in characters, words, sentences, paragraphs or some other shape of the output.\n    "),
+        /**
+         * Link to documentation
+         */
+        documentationUrl: 'https://github.com/webgptorg/promptbook/discussions/30',
+        /**
+         * Example usages of the FORMAT command
+         */
+        examples: ['FORMAT JSON'],
+        /**
+         * Parses the FORMAT command
+         */
+        parse: function (input) {
+            var normalized = input.normalized;
+            if (!normalized.startsWith('FORMAT_JSON')) {
+                throw new ParseError("For now only JSON format is supported, in future we will support more formats");
+            }
+            return {
+                type: 'FORMAT',
+                format: 'JSON',
+            };
+            // <- TODO: [🦽] Why this is constantly removed by repair-imports.ts
+            // [🥤]
+        },
+        /**
+         * Apply the FORMAT command to the `pipelineJson`
+         *
+         * Note: `$` is used to indicate that this function mutates given `taskJson`
+         */
+        $applyToTaskJson: function (command, $taskJson) {
+            if ($taskJson.format !== undefined && command.format !== $taskJson.format) {
+                throw new ParseError("Format format is already defined to \"".concat($taskJson.format, "\".\n                Now you try to redefine it by \"").concat(command.format, "\""));
+            }
+            $taskJson.format = command.format;
+        },
+        /**
+         * Converts the FORMAT command back to string
+         *
+         * Note: This is used in `pipelineJsonToString` utility
+         */
+        stringify: function (command) {
+            return "---"; // <- TODO: [🛋] Implement
+        },
+        /**
+         * Reads the FORMAT command from the `TaskJson`
+         *
+         * Note: This is used in `pipelineJsonToString` utility
+         */
+        takeFromTaskJson: function ($taskJson) {
+            throw new NotYetImplementedError("[\uD83D\uDECB] Not implemented yet"); // <- TODO: [🛋] Implement
+        },
+    };
+
+    /**
+     * @@@
+     *
+     * @public exported from `@promptbook/core`
+     */
+    var ChatbotFormfactorDefinition = {
+        name: 'CHATBOT',
+        aliasNames: ['CHAT'],
+        description: "@@@",
+        documentationUrl: "https://github.com/webgptorg/promptbook/discussions/174",
+        pipelineInterface: {
+            inputParameters: [
+                {
+                    name: 'previousTitle',
+                    description: "Previous title of the conversation",
+                    isInput: true,
+                    isOutput: false,
+                },
+                {
+                    name: 'previousConversationSummary',
+                    description: "Previous conversation summary",
+                    isInput: true,
+                    isOutput: false,
+                },
+                { name: 'userMessage', description: "User message", isInput: true, isOutput: false },
+            ],
+            outputParameters: [
+                { name: 'title', description: "Title of the conversation", isInput: false, isOutput: true },
+                { name: 'conversationSummary', description: "Summary of the conversation", isInput: false, isOutput: true },
+                { name: 'chatbotResponse', description: "Chatbot response", isInput: false, isOutput: true },
+            ],
+        },
+    };
+
+    /**
+     * Generator is form of app that @@@
+     *
+     * @public exported from `@promptbook/core`
+     */
+    var GeneratorFormfactorDefinition = {
+        name: 'GENERATOR',
+        description: "Generates any kind (in HTML with possible scripts and css format) of content from input message",
+        documentationUrl: "https://github.com/webgptorg/promptbook/discussions/184",
+        pipelineInterface: {
+            inputParameters: [
+                {
+                    name: 'inputMessage',
+                    description: "Input message to be image made from",
+                    isInput: true,
+                    isOutput: false,
+                },
+            ],
+            outputParameters: [
+                {
+                    name: 'result',
+                    description: "Result in HTML to be shown to user",
+                    isInput: false,
+                    isOutput: true,
+                },
+            ],
+        },
+    };
+
+    /**
+     * @@@
+     *
+     * @see https://github.com/webgptorg/promptbook/discussions/171
+     *
+     * @public exported from `@promptbook/core`
+     */
+    var GENERIC_PIPELINE_INTERFACE = {
+        inputParameters: [],
+        outputParameters: [],
+    };
+    /**
+     * Note: [💞] Ignore a discrepancy between file name and entity name
+     */
+
+    /**
+     * @@@
+     *
+     * @public exported from `@promptbook/core`
+     */
+    var GenericFormfactorDefinition = {
+        name: 'GENERIC',
+        description: "@@@",
+        documentationUrl: "https://github.com/webgptorg/promptbook/discussions/173",
+        pipelineInterface: GENERIC_PIPELINE_INTERFACE,
+    };
+
+    /**
+     * Image generator is form of app that generates image from input message
+     *
+     * @public exported from `@promptbook/core`
+     */
+    var ImageGeneratorFormfactorDefinition = {
+        name: 'IMAGE_GENERATOR',
+        description: "Generates prompt for image generation from input message",
+        documentationUrl: "https://github.com/webgptorg/promptbook/discussions/184",
+        pipelineInterface: {
+            inputParameters: [
+                {
+                    name: 'inputMessage',
+                    description: "Input message to be image made from",
+                    isInput: true,
+                    isOutput: false,
+                },
+            ],
+            outputParameters: [
+                {
+                    name: 'prompt',
+                    description: "Prompt to be used for image generation",
+                    isInput: false,
+                    isOutput: true,
+                },
+            ],
+        },
+    };
+
+    /**
+     * Matcher is form of app that @@@
+     *
+     * @public exported from `@promptbook/core`
+     */
+    var MatcherFormfactorDefinition = {
+        name: 'EXPERIMENTAL_MATCHER',
+        description: "@@@",
+        documentationUrl: "https://github.com/webgptorg/promptbook/discussions/177",
+        pipelineInterface: {
+            inputParameters: [
+                /* @@@ */
+                {
+                    name: 'nonce',
+                    description: 'Just to prevent EXPERIMENTAL_MATCHER to be set as implicit formfactor',
+                    isInput: true,
+                    isOutput: false,
+                },
+            ],
+            outputParameters: [
+            /* @@@ */
+            ],
+        },
+    };
+
+    /**
+     * Sheets is form of app that @@@
+     *
+     * @public exported from `@promptbook/core`
+     */
+    var SheetsFormfactorDefinition = {
+        name: 'SHEETS',
+        aliasNames: ['SHEETS', 'SHEET'],
+        description: "@@@",
+        documentationUrl: "https://github.com/webgptorg/promptbook/discussions/176",
+        pipelineInterface: {
+            inputParameters: [
+                {
+                    name: 'inputSheet',
+                    description: "Input sheet to be processed as csv",
+                    isInput: true,
+                    isOutput: false,
+                },
+            ],
+            outputParameters: [
+                {
+                    name: 'outputSheet',
+                    description: "Output sheet as csv",
+                    isInput: false,
+                    isOutput: true,
+                },
+            ],
+        },
+    };
+
+    /**
+     * Translator is form of app that @@@
+     *
+     * @public exported from `@promptbook/core`
+     */
+    var TranslatorFormfactorDefinition = {
+        name: 'TRANSLATOR',
+        description: "@@@",
+        documentationUrl: "https://github.com/webgptorg/promptbook/discussions/175",
+        pipelineInterface: {
+            inputParameters: [
+                {
+                    name: 'inputMessage',
+                    description: "Input message to be translated",
+                    isInput: true,
+                    isOutput: false,
+                },
+            ],
+            outputParameters: [
+                {
+                    name: 'outputMessage',
+                    description: "Translated output message",
+                    isInput: false,
+                    isOutput: true,
+                },
+            ],
+            // <- TODO: [🤓] Maybe add {summary}
+            // <- TODO: [🧠] maybe change to {inputText}, {inputText} / or make system for any name of first input and first outpur parameter
+        },
+    };
+
+    /**
+     * All available formfactor definitions
+     *
+     * @public exported from `@promptbook/core`
+     */
+    var FORMFACTOR_DEFINITIONS = [
+        GenericFormfactorDefinition,
+        ChatbotFormfactorDefinition,
+        TranslatorFormfactorDefinition,
+        SheetsFormfactorDefinition,
+        MatcherFormfactorDefinition,
+        GeneratorFormfactorDefinition,
+        ImageGeneratorFormfactorDefinition,
+    ];
+    /**
+     * Note: [💞] Ignore a discrepancy between file name and entity name
+     */
+
+    /**
+     * Parses the formfactor command
+     *
+     * Note: @@@ This command is used as formfactor for new commands - it should NOT be used in any `.book.md` file
+     *
+     * @see `documentationUrl` for more details
+     * @public exported from `@promptbook/editable`
+     */
+    var formfactorCommandParser = {
+        /**
+         * Name of the command
+         */
+        name: 'FORMFACTOR',
+        /**
+         * Aliases for the FORMFACTOR command
+         */
+        aliasNames: ['FORM', 'FF'],
+        /**
+         * FORMFACTOR command can be used in:
+         */
+        isUsedInPipelineHead: true,
+        isUsedInPipelineTask: false,
+        /**
+         * Description of the FORMFACTOR command
+         */
+        description: "@@",
+        /**
+         * Link to documentation
+         */
+        documentationUrl: 'https://github.com/webgptorg/promptbook/discussions/168',
+        /**
+         * Example usages of the FORMFACTOR command
+         */
+        examples: ['FORMFACTOR Chatbot', 'FF Chat'],
+        /**
+         * Parses the FORMFACTOR command
+         */
+        parse: function (input) {
+            var args = input.args;
+            if (args.length !== 1) {
+                throw new ParseError("FORMFACTOR command requires exactly one argument");
+            }
+            var formfactorNameCandidate = args[0].toUpperCase();
+            var formfactor = FORMFACTOR_DEFINITIONS.find(function (definition) {
+                return __spreadArray([definition.name], __read(__assign({ aliasNames: [] }, definition).aliasNames), false).includes(formfactorNameCandidate);
+            });
+            if (formfactor === undefined) {
+                throw new ParseError(spaceTrim__default["default"](function (block) { return "\n                        Unknown formfactor name \"".concat(formfactorNameCandidate, "\"\n\n                        Available formfactors:\n                        ").concat(block(FORMFACTOR_DEFINITIONS.map(function (_a) {
+                    var name = _a.name;
+                    return "- ".concat(name);
+                }).join('\n')), "\n                    "); }));
+            }
+            return {
+                type: 'FORMFACTOR',
+                formfactorName: formfactor.name,
+            };
+        },
+        /**
+         * Apply the FORMFACTOR command to the `pipelineJson`
+         *
+         * Note: `$` is used to indicate that this function mutates given `pipelineJson`
+         */
+        $applyToPipelineJson: function (command, $pipelineJson) {
+            if ($pipelineJson.formfactorName !== undefined && $pipelineJson.formfactorName !== command.formfactorName) {
+                throw new ParseError(spaceTrim__default["default"]("\n                    Redefinition of `FORMFACTOR` in the pipeline head\n\n                    You have used:\n                    1) FORMFACTOR `".concat($pipelineJson.formfactorName, "`\n                    2) FORMFACTOR `").concat(command.formfactorName, "`\n                ")));
+            }
+            $pipelineJson.formfactorName = command.formfactorName;
+        },
+        /**
+         * Converts the FORMFACTOR command back to string
+         *
+         * Note: This is used in `pipelineJsonToString` utility
+         */
+        stringify: function (command) {
+            return "FORMFACTOR ".concat(command.formfactorName);
+        },
+        /**
+         * Reads the FORMFACTOR command from the `PipelineJson`
+         *
+         * Note: This is used in `pipelineJsonToString` utility
+         */
+        takeFromPipelineJson: function (pipelineJson) {
+            return [
+                {
+                    type: 'FORMFACTOR',
+                    formfactorName: pipelineJson.formfactorName,
+                },
+            ];
+        },
+    };
+
+    /**
+     * Parses the joker command
+     *
+     * @see `documentationUrl` for more details
+     * @public exported from `@promptbook/editable`
+     */
+    var jokerCommandParser = {
+        /**
+         * Name of the command
+         */
+        name: 'JOKER',
+        /**
+         * BOILERPLATE command can be used in:
+         */
+        isUsedInPipelineHead: false,
+        isUsedInPipelineTask: true,
+        /**
+         * Description of the JOKER command
+         */
+        description: "Joker parameter is used instead of executing the task result if jokers value meets the expectations requirements",
+        /**
+         * Link to documentation
+         */
+        documentationUrl: 'https://github.com/webgptorg/promptbook/discussions/66',
+        /**
+         * Example usages of the JOKER command
+         */
+        examples: ['JOKER {documentTitle}'],
+        /**
+         * Parses the JOKER command
+         */
+        parse: function (input) {
+            var args = input.args;
+            if (args.length !== 1) {
+                throw new ParseError("JOKE command expects exactly one parameter name");
+            }
+            var parameterNameArg = args[0] || '';
+            var parameterName = validateParameterName(parameterNameArg);
+            return {
+                type: 'JOKER',
+                parameterName: parameterName,
+            };
+        },
+        /**
+         * Apply the JOKER command to the `pipelineJson`
+         *
+         * Note: `$` is used to indicate that this function mutates given `taskJson`
+         */
+        $applyToTaskJson: function (command, $taskJson) {
+            $taskJson.jokerParameterNames = $taskJson.jokerParameterNames || [];
+            $taskJson.jokerParameterNames.push(command.parameterName);
+        },
+        /**
+         * Converts the JOKER command back to string
+         *
+         * Note: This is used in `pipelineJsonToString` utility
+         */
+        stringify: function (command) {
+            return "---"; // <- TODO: [🛋] Implement
+        },
+        /**
+         * Reads the JOKER command from the `TaskJson`
+         *
+         * Note: This is used in `pipelineJsonToString` utility
+         */
+        takeFromTaskJson: function ($taskJson) {
+            throw new NotYetImplementedError("[\uD83D\uDECB] Not implemented yet"); // <- TODO: [🛋] Implement
+        },
+    };
+
+    /**
+     * Tests if given string is valid URL.
+     *
+     * Note: This does not check if the file exists only if the path is valid
+     * @public exported from `@promptbook/utils`
+     */
+    function isValidFilePath(filename) {
+        if (typeof filename !== 'string') {
+            return false;
+        }
+        if (filename.split('\n').length > 1) {
+            return false;
+        }
+        if (filename.split(' ').length >
+            5 /* <- TODO: [🧠][🈷] Make some better non-arbitrary way how to distinct filenames from informational texts */) {
+            return false;
+        }
+        var filenameSlashes = filename.split('\\').join('/');
+        // Absolute Unix path: /hello.txt
+        if (/^(\/)/i.test(filenameSlashes)) {
+            // console.log(filename, 'Absolute Unix path: /hello.txt');
+            return true;
+        }
+        // Absolute Windows path: /hello.txt
+        if (/^([A-Z]{1,2}:\/?)\//i.test(filenameSlashes)) {
+            // console.log(filename, 'Absolute Windows path: /hello.txt');
+            return true;
+        }
+        // Relative path: ./hello.txt
+        if (/^(\.\.?\/)+/i.test(filenameSlashes)) {
+            // console.log(filename, 'Relative path: ./hello.txt');
+            return true;
+        }
+        // Allow paths like foo/hello
+        if (/^[^/]+\/[^/]+/i.test(filenameSlashes)) {
+            // console.log(filename, 'Allow paths like foo/hello');
+            return true;
+        }
+        // Allow paths like hello.book
+        if (/^[^/]+\.[^/]+$/i.test(filenameSlashes)) {
+            // console.log(filename, 'Allow paths like hello.book');
+            return true;
+        }
+        return false;
+    }
+    /**
+     * TODO: [🍏] Implement for MacOs
+     */
+
+    /**
+     * Tests if given string is valid URL.
+     *
+     * Note: Dataurl are considered perfectly valid.
+     * Note: There are two simmilar functions:
+     * - `isValidUrl` which tests any URL
+     * - `isValidPipelineUrl` *(this one)* which tests just promptbook URL
+     *
+     * @public exported from `@promptbook/utils`
+     */
+    function isValidUrl(url) {
+        if (typeof url !== 'string') {
+            return false;
+        }
+        try {
+            if (url.startsWith('blob:')) {
+                url = url.replace(/^blob:/, '');
+            }
+            var urlObject = new URL(url /* because fail is handled */);
+            if (!['http:', 'https:', 'data:'].includes(urlObject.protocol)) {
+                return false;
+            }
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+
+    /**
+     * @@@
+     *
+     * @param text @@@
+     * @returns @@@
+     * @example 'hello-world'
+     * @example 'i-love-promptbook'
+     * @public exported from `@promptbook/utils`
+     */
+    function normalizeToKebabCase(text) {
+        var e_1, _a;
+        text = removeDiacritics(text);
+        var charType;
+        var lastCharType = 'OTHER';
+        var normalizedName = '';
+        try {
+            for (var text_1 = __values(text), text_1_1 = text_1.next(); !text_1_1.done; text_1_1 = text_1.next()) {
+                var char = text_1_1.value;
+                var normalizedChar = void 0;
+                if (/^[a-z]$/.test(char)) {
+                    charType = 'LOWERCASE';
+                    normalizedChar = char;
+                }
+                else if (/^[A-Z]$/.test(char)) {
+                    charType = 'UPPERCASE';
+                    normalizedChar = char.toLowerCase();
+                }
+                else if (/^[0-9]$/.test(char)) {
+                    charType = 'NUMBER';
+                    normalizedChar = char;
+                }
+                else {
+                    charType = 'OTHER';
+                    normalizedChar = '-';
+                }
+                if (charType !== lastCharType &&
+                    !(lastCharType === 'UPPERCASE' && charType === 'LOWERCASE') &&
+                    !(lastCharType === 'NUMBER') &&
+                    !(charType === 'NUMBER')) {
+                    normalizedName += '-';
+                }
+                normalizedName += normalizedChar;
+                lastCharType = charType;
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (text_1_1 && !text_1_1.done && (_a = text_1.return)) _a.call(text_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        normalizedName = normalizedName.split(/-+/g).join('-');
+        normalizedName = normalizedName.split(/-?\/-?/g).join('/');
+        normalizedName = normalizedName.replace(/^-/, '');
+        normalizedName = normalizedName.replace(/-$/, '');
+        return normalizedName;
+    }
+    /**
+     * Note: [💞] Ignore a discrepancy between file name and entity name
+     */
+
+    /**
+     * Creates unique name for the source
+     *
+     * @public exported from `@promptbook/editable`
+     */
+    function knowledgeSourceContentToName(knowledgeSourceContent) {
+        var hash = cryptoJs.SHA256(hexEncoder__default["default"].parse(JSON.stringify(knowledgeSourceContent)))
+            //    <- TODO: [🥬] Encapsulate sha256 to some private utility function
+            .toString( /* hex */)
+            .substring(0, 20);
+        //    <- TODO: [🥬] Make some system for hashes and ids of promptbook
+        var semanticName = normalizeToKebabCase(knowledgeSourceContent.substring(0, 20));
+        var pieces = ['source', semanticName, hash].filter(function (piece) { return piece !== ''; });
+        var name = pieces.join('-').split('--').join('-');
+        // <- TODO: Use MAX_FILENAME_LENGTH
+        return name;
+    }
+    /**
+     * TODO: [🐱‍🐉][🧠] Make some smart crop NOT source-i-m-pavol-a-develop-... BUT source-i-m-pavol-a-developer-...
+     */
+
+    /**
+     * Parses the knowledge command
+     *
+     * @see `documentationUrl` for more details
+     * @public exported from `@promptbook/editable`
+     */
+    var knowledgeCommandParser = {
+        /**
+         * Name of the command
+         */
+        name: 'KNOWLEDGE',
+        /**
+         * BOILERPLATE command can be used in:
+         */
+        isUsedInPipelineHead: true,
+        isUsedInPipelineTask: false,
+        /**
+         * Description of the KNOWLEDGE command
+         */
+        description: "Tells promptbook which external knowledge to use",
+        /**
+         * Link to documentation
+         */
+        documentationUrl: 'https://github.com/webgptorg/promptbook/discussions/41',
+        /**
+         * Example usages of the KNOWLEDGE command
+         */
+        examples: [
+            'KNOWLEDGE https://www.pavolhejny.com/',
+            'KNOWLEDGE ./hejny-cv.txt',
+            'KNOWLEDGE ./hejny-cv.md',
+            'KNOWLEDGE ./hejny-cv.pdf',
+            'KNOWLEDGE ./hejny-cv.docx',
+            //          <- TODO: [😿] Allow ONLY files scoped in the (sub)directory NOT ../ and test it
+        ],
+        /**
+         * Parses the KNOWLEDGE command
+         */
+        parse: function (input) {
+            var args = input.args;
+            var knowledgeSourceContent = spaceTrim__default["default"](args[0] || '');
+            if (knowledgeSourceContent === '') {
+                throw new ParseError("Source is not defined");
+            }
+            // TODO: [main] !!4 Following checks should be applied every link in the `sourceContent`
+            if (knowledgeSourceContent.startsWith('http://')) {
+                throw new ParseError("Source is not secure");
+            }
+            if (!(isValidFilePath(knowledgeSourceContent) || isValidUrl(knowledgeSourceContent))) {
+                throw new ParseError("Source not valid");
+            }
+            if (knowledgeSourceContent.startsWith('../') ||
+                knowledgeSourceContent.startsWith('/') ||
+                /^[A-Z]:[\\/]+/i.test(knowledgeSourceContent)) {
+                throw new ParseError("Source cannot be outside of the .book.md folder");
+            }
+            return {
+                type: 'KNOWLEDGE',
+                knowledgeSourceContent: knowledgeSourceContent,
+            };
+        },
+        /**
+         * Apply the KNOWLEDGE command to the `pipelineJson`
+         *
+         * Note: `$` is used to indicate that this function mutates given `pipelineJson`
+         */
+        $applyToPipelineJson: function (command, $pipelineJson) {
+            var knowledgeSourceContent = command.knowledgeSourceContent;
+            $pipelineJson.knowledgeSources.push({
+                name: knowledgeSourceContentToName(knowledgeSourceContent),
+                knowledgeSourceContent: knowledgeSourceContent,
+            });
+        },
+        /**
+         * Converts the KNOWLEDGE command back to string
+         *
+         * Note: This is used in `pipelineJsonToString` utility
+         */
+        stringify: function (command) {
+            return "---"; // <- TODO: [🛋] Implement
+        },
+        /**
+         * Reads the KNOWLEDGE command from the `PipelineJson`
+         *
+         * Note: This is used in `pipelineJsonToString` utility
+         */
+        takeFromPipelineJson: function (pipelineJson) {
+            throw new NotYetImplementedError("[\uD83D\uDECB] Not implemented yet"); // <- TODO: [🛋] Implement
+        },
+    };
+    /**
+     * Note: [⛱] There are two types of KNOWLEDGE commands *...(read more in [⛱])*
+     */
+
+    /**
+     * @@@
+     *
+     * @public exported from `@promptbook/core`
+     */
+    var MODEL_VARIANTS = ['COMPLETION', 'CHAT', 'EMBEDDING' /* <- TODO [🏳] */ /* <- [🤖] */];
+
+    /**
+     * Parses the model command
+     *
+     * @see `documentationUrl` for more details
+     * @deprecated Option to manually set the model requirements is not recommended to use, use `PERSONA` instead
+     * @public exported from `@promptbook/editable`
+     */
+    var modelCommandParser = {
+        /**
+         * Name of the command
+         */
+        name: 'MODEL',
+        /**
+         * BOILERPLATE command can be used in:
+         */
+        isUsedInPipelineHead: true,
+        isUsedInPipelineTask: true,
+        /**
+         * Description of the MODEL command
+         */
+        description: "Tells which `modelRequirements` (for example which model) to use for the prompt task execution",
+        /**
+         * Link to documentation
+         */
+        documentationUrl: 'https://github.com/webgptorg/promptbook/discussions/67',
+        /**
+         * Example usages of the MODEL command
+         */
+        examples: ['MODEL VARIANT Chat', 'MODEL NAME `gpt-4`'],
+        /**
+         * Parses the MODEL command
+         */
+        parse: function (input) {
+            var args = input.args, normalized = input.normalized;
+            var availableVariantsMessage = spaceTrim__default["default"](function (block) { return "\n              Available variants are:\n              ".concat(block(MODEL_VARIANTS.map(function (variantName) {
+                return "- ".concat(variantName).concat(variantName !== 'EMBEDDING' ? '' : ' (Not available in pipeline)');
+            }).join('\n')), "\n          "); });
+            // TODO: Make this more elegant and dynamically
+            if (normalized.startsWith('MODEL_VARIANT')) {
+                if (normalized === 'MODEL_VARIANT_CHAT') {
+                    return {
+                        type: 'MODEL',
+                        key: 'modelVariant',
+                        value: 'CHAT',
+                    };
+                }
+                else if (normalized === 'MODEL_VARIANT_COMPLETION') {
+                    return {
+                        type: 'MODEL',
+                        key: 'modelVariant',
+                        value: 'COMPLETION',
+                    };
+                    // <- Note: [🤖]
+                }
+                else if (normalized.startsWith('MODEL_VARIANT_EMBED')) {
+                    spaceTrim__default["default"](function (block) { return "\n                        Embedding model can not be used in pipeline\n\n                        ".concat(block(availableVariantsMessage), "\n                    "); });
+                }
+                else {
+                    throw new ParseError(spaceTrim__default["default"](function (block) { return "\n                            Unknown model variant in command:\n\n                            ".concat(block(availableVariantsMessage), "\n                        "); }));
+                }
+            }
+            if (normalized.startsWith('MODEL_NAME')) {
+                return {
+                    type: 'MODEL',
+                    key: 'modelName',
+                    value: args.pop(),
+                };
+            }
+            else {
+                throw new ParseError(spaceTrim__default["default"](function (block) { return "\n                    Unknown model key in command.\n\n                    Supported model keys are:\n                    ".concat(block(['variant', 'name'].join(', ')), "\n\n                    Example:\n                    - MODEL VARIANT Chat\n                    - MODEL NAME gpt-4\n              "); }));
+            }
+        },
+        /**
+         * Apply the MODEL command to the `pipelineJson`
+         *
+         * Note: `$` is used to indicate that this function mutates given `pipelineJson`
+         */
+        $applyToPipelineJson: function (command, $pipelineJson) {
+            $pipelineJson.defaultModelRequirements = $pipelineJson.defaultModelRequirements || {};
+            // TODO: [🚜] DRY
+            if ($pipelineJson.defaultModelRequirements[command.key] !== undefined) {
+                if ($pipelineJson.defaultModelRequirements[command.key] === command.value) {
+                    console.warn("Multiple commands `MODEL ".concat(command.key, " ").concat(command.value, "` in the pipeline head"));
+                    // <- TODO: [🚎][💩] Some better way how to get warnings from pipeline parsing / logic
+                }
+                else {
+                    throw new ParseError(spaceTrim__default["default"]("\n                        Redefinition of `MODEL ".concat(command.key, "` in the pipeline head\n\n                        You have used:\n                        1) `MODEL ").concat(command.key, " ").concat($pipelineJson.defaultModelRequirements[command.key], "`\n                        2) `MODEL ").concat(command.key, " ").concat(command.value, "`\n                    ")));
+                }
+            }
+            $pipelineJson.defaultModelRequirements[command.key] = command.value;
+        },
+        /**
+         * Apply the MODEL command to the `pipelineJson`
+         *
+         * Note: `$` is used to indicate that this function mutates given `taskJson`
+         */
+        $applyToTaskJson: function (command, $taskJson, $pipelineJson) {
+            if ($taskJson.taskType !== 'PROMPT_TASK') {
+                throw new ParseError("MODEL command can only be used in PROMPT_TASK block");
+            }
+            $taskJson.modelRequirements = $taskJson.modelRequirements || {};
+            // TODO: [🚜] DRY
+            if ($taskJson.modelRequirements[command.key] !== undefined) {
+                if ($taskJson.modelRequirements[command.key] === command.value) {
+                    console.warn("Multiple commands `MODEL ".concat({
+                        modelName: 'NAME',
+                        modelVariant: 'VARIANT',
+                        maxTokens: '???',
+                    }[command.key], " ").concat(command.value, "` in the task \"").concat($taskJson.title || $taskJson.name, "\""));
+                }
+                else {
+                    throw new ParseError(spaceTrim__default["default"]("\n                              Redefinition of MODEL `".concat(command.key, "` in the task \"").concat($taskJson.title || $taskJson.name, "\"\n\n                              You have used:\n                              - MODEL ").concat(command.key, " ").concat($taskJson.modelRequirements[command.key], "\n                              - MODEL ").concat(command.key, " ").concat(command.value, "\n                          ")));
+                }
+            }
+            if (command.value === ($pipelineJson.defaultModelRequirements || {})[command.key]) {
+                console.log(spaceTrim__default["default"]("\n                    Setting MODEL `".concat(command.key, "` in the task \"").concat($taskJson.title || $taskJson.name, "\" to the same value as in the pipeline head\n\n                    In pipeline head:\n                    - MODEL ").concat(command.key, " ").concat(($pipelineJson.defaultModelRequirements || {})[command.key], "\n\n                    But same value is used in the task:\n                    - MODEL ").concat(command.key, " ").concat(command.value, "\n                ")));
+            }
+            $taskJson.modelRequirements[command.key] = command.value;
+        },
+        /**
+         * Converts the MODEL command back to string
+         *
+         * Note: This is used in `pipelineJsonToString` utility
+         */
+        stringify: function (command) {
+            return "---"; // <- TODO: [🛋] Implement
+        },
+        /**
+         * Reads the MODEL command from the `PipelineJson`
+         *
+         * Note: This is used in `pipelineJsonToString` utility
+         */
+        takeFromPipelineJson: function (pipelineJson) {
+            throw new NotYetImplementedError("[\uD83D\uDECB] Not implemented yet"); // <- TODO: [🛋] Implement
+        },
+        /**
+         * Reads the MODEL command from the `TaskJson`
+         *
+         * Note: This is used in `pipelineJsonToString` utility
+         */
+        takeFromTaskJson: function ($taskJson) {
+            throw new NotYetImplementedError("[\uD83D\uDECB] Not implemented yet"); // <- TODO: [🛋] Implement
+        },
+    };
+
+    /**
+     * Parses the parameter command
+     *
+     * @see `documentationUrl` for more details
+     * @public exported from `@promptbook/editable`
+     */
+    var parameterCommandParser = {
+        /**
+         * Name of the command
+         */
+        name: 'PARAMETER',
+        /**
+         * Aliases for the PARAMETER command
+         */
+        aliasNames: ['PARAM', 'INPUT_PARAM', 'OUTPUT_PARAM', 'INPUT_PARAMETER', 'OUTPUT_PARAMETER'],
+        /*
+        Note: [🦈] No need for extra alias name because it is already preprocessed
+        */
+        /**
+         * BOILERPLATE command can be used in:
+         */
+        isUsedInPipelineHead: true,
+        isUsedInPipelineTask: true,
+        /**
+         * Description of the PARAMETER command
+         */
+        description: "Describes one parameter of the task",
+        /**
+         * Link to documentation
+         */
+        documentationUrl: 'https://github.com/webgptorg/promptbook/discussions/68',
+        /**
+         * Example usages of the PARAMETER command
+         */
+        examples: ['PARAMETER {title} Title of the book', 'OUTPUT PARAMETER {websiteContent} Content of the book'],
+        /**
+         * Parses the PARAMETER command
+         */
+        parse: function (input) {
+            var normalized = input.normalized, args = input.args, raw = input.raw;
+            var parameterNameRaw = args.shift() || '';
+            var parameterDescriptionRaw = args.join(' ');
+            // <- TODO: When [🥶] fixed, change to:
+            //        >   const parameterDescriptionRaw = rawArgs.split(parameterNameRaw).join('').trim();
+            if (parameterDescriptionRaw && parameterDescriptionRaw.match(/\{(?<embeddedParameterName>[a-z0-9_]+)\}/im)) {
+                throw new ParseError(spaceTrim__default["default"](function (block) { return "\n                        Parameter `{".concat(parameterNameRaw, "}` can not contain another parameter in description\n\n                        The description:\n                        ").concat(block(parameterDescriptionRaw), "\n                    "); }));
+            }
+            var isInput = normalized.startsWith('INPUT');
+            var isOutput = normalized.startsWith('OUTPUT');
+            if (raw.startsWith('> {')) {
+                isInput = false;
+                isOutput = false;
+            }
+            var parameterName = validateParameterName(parameterNameRaw);
+            var parameterDescription = parameterDescriptionRaw.trim() || null;
+            return {
+                type: 'PARAMETER',
+                parameterName: parameterName,
+                parameterDescription: parameterDescription,
+                isInput: isInput,
+                isOutput: isOutput,
+            };
+        },
+        /**
+         * Apply the PARAMETER command to the `pipelineJson`
+         *
+         * Note: `$` is used to indicate that this function mutates given `pipelineJson`
+         */
+        $applyToPipelineJson: function (command, $pipelineJson) {
+            // Note: [🍣] Do nothing, its application is implemented separately in `parsePipeline`
+        },
+        /**
+         * Apply the PARAMETER command to the `pipelineJson`
+         *
+         * Note: `$` is used to indicate that this function mutates given `taskJson`
+         */
+        $applyToTaskJson: function (command, $taskJson, $pipelineJson) {
+            // Note: [🍣] Do nothing, its application is implemented separately in `parsePipeline`
+        },
+        /**
+         * Converts the PARAMETER command back to string
+         *
+         * Note: This is used in `pipelineJsonToString` utility
+         */
+        stringify: function (command) {
+            return "---"; // <- TODO: [🛋] Implement
+        },
+        /**
+         * Reads the PARAMETER command from the `PipelineJson`
+         *
+         * Note: This is used in `pipelineJsonToString` utility
+         */
+        takeFromPipelineJson: function (pipelineJson) {
+            throw new NotYetImplementedError("[\uD83D\uDECB] Not implemented yet"); // <- TODO: [🛋] Implement
+        },
+        /**
+         * Reads the PARAMETER command from the `TaskJson`
+         *
+         * Note: This is used in `pipelineJsonToString` utility
+         */
+        takeFromTaskJson: function ($taskJson) {
+            throw new NotYetImplementedError("[\uD83D\uDECB] Not implemented yet"); // <- TODO: [🛋] Implement
+        },
+    };
+
+    /**
+     * Parses the persona command
+     *
+     * @see `documentationUrl` for more details
+     * @public exported from `@promptbook/editable`
+     */
+    var personaCommandParser = {
+        /**
+         * Name of the command
+         */
+        name: 'PERSONA',
+        /**
+         * Aliases for the PERSONA command
+         */
+        aliasNames: ['PERSON'],
+        /**
+         * PERSONA command can be used in:
+         */
+        isUsedInPipelineHead: true,
+        isUsedInPipelineTask: true,
+        /**
+         * Description of the PERSONA command
+         */
+        description: "Persona command is used to specify who the system is, it will be transformed into system message, top_t,...",
+        /**
+         * Link to documentation
+         */
+        documentationUrl: 'https://github.com/webgptorg/promptbook/discussions/22',
+        /**
+         * Example usages of the PERSONA command
+         */
+        examples: ['PERSONA Jane, skilled copywriter', 'PERSONA Joe, male 28 years old, programmer'],
+        /**
+         * Parses the PERSONA command
+         */
+        parse: function (input) {
+            var rawArgs = input.rawArgs;
+            var _a = __read(rawArgs.split(/[,;:]/, 2), 2), personaNameRaw = _a[0], personaDescriptionRaw = _a[1];
+            var personaName = (personaNameRaw || '').trim();
+            if (personaName === '') {
+                throw new ParseError("You must set name for the persona");
+            }
+            var personaDescription = (personaDescriptionRaw || '').trim();
+            if (personaDescription === '') {
+                personaDescription = null;
+            }
+            return {
+                type: 'PERSONA',
+                personaName: personaName,
+                personaDescription: personaDescription,
+            };
+        },
+        /**
+         * Apply the PERSONA command to the `pipelineJson`
+         *
+         * Note: `$` is used to indicate that this function mutates given `pipelineJson`
+         */
+        $applyToPipelineJson: function (command, $pipelineJson) {
+            $applyToTaskJson(command, null, $pipelineJson);
+        },
+        $applyToTaskJson: $applyToTaskJson,
+        /**
+         * Converts the PERSONA command back to string
+         *
+         * Note: This is used in `pipelineJsonToString` utility
+         */
+        stringify: function (command) {
+            return "---"; // <- TODO: [🛋] Implement
+        },
+        /**
+         * Reads the PERSONA command from the `PipelineJson`
+         *
+         * Note: This is used in `pipelineJsonToString` utility
+         */
+        takeFromPipelineJson: function (pipelineJson) {
+            throw new NotYetImplementedError("[\uD83D\uDECB] Not implemented yet"); // <- TODO: [🛋] Implement
+        },
+        /**
+         * Reads the PERSONA command from the `TaskJson`
+         *
+         * Note: This is used in `pipelineJsonToString` utility
+         */
+        takeFromTaskJson: function ($taskJson) {
+            throw new NotYetImplementedError("[\uD83D\uDECB] Not implemented yet"); // <- TODO: [🛋] Implement
+        },
+    };
+    /**
+     * Apply the PERSONA command to the `pipelineJson`
+     *
+     * Note: `$` is used to indicate that this function mutates given `taskJson`
+     */
+    function $applyToTaskJson(command, $taskJson, $pipelineJson) {
+        var personaName = command.personaName, personaDescription = command.personaDescription;
+        if ($taskJson !== null) {
+            if ($taskJson.taskType !== 'PROMPT_TASK') {
+                throw new ParseError("PERSONA command can be used only in PROMPT_TASK block");
+            }
+            $taskJson.personaName = personaName;
+        }
+        var persona = $pipelineJson.personas.find(function (persona) { return persona.name === personaName; });
+        if (persona === undefined) {
+            $pipelineJson.personas.push({
+                name: personaName,
+                description: personaDescription || '',
+            });
+            return;
+        }
+        if (persona.description === personaDescription) {
+            return;
+        }
+        if (personaDescription === null) {
+            return;
+        }
+        if (persona.description === '') {
+            persona.description = personaDescription;
+            return;
+        }
+        console.warn(spaceTrim__default["default"]("\n\n         Persona \"".concat(personaName, "\" is defined multiple times with different description:\n\n         First definition:\n         ").concat(persona.description, "\n\n         Second definition:\n         ").concat(personaDescription, "\n\n     ")));
+        persona.description += spaceTrim__default["default"]('\n\n' + personaDescription);
+    }
+
+    /**
+     * @@@
+     *
+     * @param javascriptName @@@
+     * @returns @@@
+     * @public exported from `@promptbook/utils`
+     */
+    function isValidJavascriptName(javascriptName) {
+        if (typeof javascriptName !== 'string') {
+            return false;
+        }
+        return /^[a-zA-Z_$][0-9a-zA-Z_$]*$/i.test(javascriptName);
+    }
+
+    /**
+     * Parses the postprocess command
+     *
+     * @see `documentationUrl` for more details
+     * @public exported from `@promptbook/editable`
+     */
+    var postprocessCommandParser = {
+        /**
+         * Name of the command
+         */
+        name: 'POSTPROCESS',
+        aliasNames: ['POSTPROCESSING', 'PP'],
+        /**
+         * BOILERPLATE command can be used in:
+         */
+        isUsedInPipelineHead: false,
+        isUsedInPipelineTask: true,
+        /**
+         * Description of the POSTPROCESS command
+         */
+        description: "Defines the postprocess function to be used on the result from LLM and before the result is validated",
+        /**
+         * Link to documentation
+         */
+        documentationUrl: 'https://github.com/webgptorg/promptbook/discussions/31',
+        /**
+         * Example usages of the POSTPROCESS command
+         */
+        examples: [
+            'POSTPROCESS unwrapResult' /* <- TODO: Make it `POSTPROCESS` examples dynamic, load from all possible postprocess functions */,
+        ],
+        /**
+         * Parses the POSTPROCESS command
+         */
+        parse: function (input) {
+            var args = input.args;
+            var functionName = args.pop();
+            if (functionName === undefined) {
+                throw new ParseError("Postprocess function name is required");
+            }
+            if (!isValidJavascriptName(functionName)) {
+                throw new ParseError("Invalid postprocess function name \"".concat(functionName, "\""));
+            }
+            if (args.length > 0) {
+                throw new ParseError("Can not have more than one postprocess function");
+            }
+            return {
+                type: 'POSTPROCESS',
+                functionName: functionName,
+            };
+        },
+        /**
+         * Apply the POSTPROCESS command to the `pipelineJson`
+         *
+         * Note: `$` is used to indicate that this function mutates given `taskJson`
+         */
+        $applyToTaskJson: function (command, $taskJson) {
+            $taskJson.postprocessingFunctionNames = $taskJson.postprocessingFunctionNames || [];
+            $taskJson.postprocessingFunctionNames.push(command.functionName);
+        },
+        /**
+         * Converts the POSTPROCESS command back to string
+         *
+         * Note: This is used in `pipelineJsonToString` utility
+         */
+        stringify: function (command) {
+            return "---"; // <- TODO: [🛋] Implement
+        },
+        /**
+         * Reads the POSTPROCESS command from the `TaskJson`
+         *
+         * Note: This is used in `pipelineJsonToString` utility
+         */
+        takeFromTaskJson: function ($taskJson) {
+            throw new NotYetImplementedError("[\uD83D\uDECB] Not implemented yet"); // <- TODO: [🛋] Implement
+        },
+    };
+
+    /**
+     * All available task types
+     *
+     * There is is distinction between task types and section types
+     * - Every section in markdown has its SectionType
+     * - Some sections are tasks but other can be non-task sections
+     *
+     * @public exported from `@promptbook/core`
+     */
+    var TaskTypes = [
+        'PROMPT',
+        'SIMPLE',
+        'SCRIPT',
+        'DIALOG',
+        // <- [🅱]
+    ];
+
+    /**
+     * All available sections which are not tasks
+     *
+     * @public exported from `@promptbook/core`
+     */
+    var NonTaskSectionTypes = ['EXAMPLE', 'KNOWLEDGE', 'INSTRUMENT', 'ACTION'];
+    /**
+     * All available section types
+     *
+     * There is is distinction between task types and section types
+     * - Every section in markdown has its SectionType
+     * - Some sections are tasks but other can be non-task sections
+     *
+     * @public exported from `@promptbook/core`
+     */
+    var SectionTypes = __spreadArray(__spreadArray([], __read(TaskTypes.map(function (TaskType) { return "".concat(TaskType, "_TASK"); })), false), __read(NonTaskSectionTypes), false);
+
+    /**
+     * Parses the section command
+     *
+     * @see `documentationUrl` for more details
+     * @public exported from `@promptbook/editable`
+     */
+    var sectionCommandParser = {
+        /**
+         * Name of the command
+         */
+        name: 'SECTION',
+        /**
+         * Aliases for the SECTION command
+         */
+        aliasNames: [
+            'PROMPT',
+            'SIMPLE',
+            'SCRIPT',
+            'DIALOG',
+            'SAMPLE',
+            'EXAMPLE',
+            'KNOWLEDGE',
+            'INSTRUMENT',
+            'ACTION', // <- Note: [⛱]
+        ],
+        /**
+         * Aliases for the SECTION command
+         */
+        deprecatedNames: ['TEMPLATE', 'BLOCK', 'EXECUTE'],
+        /**
+         * BOILERPLATE command can be used in:
+         */
+        isUsedInPipelineHead: false,
+        isUsedInPipelineTask: true,
+        /**
+         * Description of the SECTION command
+         */
+        description: "Defines the purpose of the markdown section - if its a task and which type or something else",
+        /**
+         * Link to documentation
+         */
+        documentationUrl: 'https://github.com/webgptorg/promptbook/discussions/64',
+        /**
+         * Example usages of the SECTION command
+         */
+        examples: [
+            // Short form:
+            'PROMPT',
+            'SIMPLE',
+            'SCRIPT',
+            'DIALOG',
+            // <- [🅱]
+            'EXAMPLE',
+            'KNOWLEDGE',
+            'INSTRUMENT',
+            'ACTION',
+            // -----------------
+            // Recommended (reversed) form:
+            'PROMPT SECTION',
+            'SIMPLE SECTION',
+            'SCRIPT SECTION',
+            'DIALOG SECTION',
+            // <- [🅱]
+            'EXAMPLE SECTION',
+            'KNOWLEDGE SECTION',
+            'INSTRUMENT SECTION',
+            'ACTION SECTION',
+            // -----------------
+            // Standard form:
+            'SECTION PROMPT',
+            'SECTION SIMPLE',
+            'SECTION SCRIPT',
+            'SECTION DIALOG',
+            // <- [🅱]
+            'SECTION EXAMPLE',
+            'SECTION KNOWLEDGE',
+            'SECTION INSTRUMENT',
+            'SECTION ACTION',
+        ],
+        // TODO: [♓️] order: -10 /* <- Note: Putting before other commands */
+        /**
+         * Parses the SECTION command
+         */
+        parse: function (input) {
+            var normalized = input.normalized;
+            normalized = normalized.split('SAMPLE').join('EXAMPLE');
+            normalized = normalized.split('EXECUTE_').join('');
+            normalized = normalized.split('DIALOGUE').join('DIALOG');
+            var taskTypes = SectionTypes.filter(function (sectionType) {
+                return normalized.includes(sectionType.split('_TASK').join(''));
+            });
+            if (taskTypes.length !== 1) {
+                throw new ParseError(spaceTrim__default["default"](function (block) { return "\n                        Unknown section type \"".concat(normalized, "\"\n\n                        Supported section types are:\n                        ").concat(block(SectionTypes.join(', ')), "\n                    "); }));
+            }
+            var taskType = taskTypes[0];
+            return {
+                type: 'SECTION',
+                taskType: taskType,
+            };
+        },
+        /**
+         * Apply the SECTION command to the `pipelineJson`
+         *
+         * Note: `$` is used to indicate that this function mutates given `taskJson`
+         */
+        $applyToTaskJson: function (command, $taskJson, $pipelineJson) {
+            if ($taskJson.isSectionTypeSet === true) {
+                throw new ParseError(spaceTrim__default["default"]("\n                    Section type is already defined in the section.\n                    It can be defined only once.\n                "));
+            }
+            $taskJson.isSectionTypeSet = true;
+            // TODO: [🍧][💩] Rearrange better - but at bottom and unwrap from function
+            var expectResultingParameterName = function () {
+                if ($taskJson.resultingParameterName) {
+                    return;
+                }
+                throw new ParseError("Task section and example section must end with return statement -> {parameterName}");
+            };
+            if ($taskJson.content === undefined) {
+                throw new UnexpectedError("Content is missing in the taskJson - probbably commands are applied in wrong order");
+            }
+            if (command.taskType === 'EXAMPLE') {
+                expectResultingParameterName();
+                var parameter = $pipelineJson.parameters.find(function (param) { return param.name === $taskJson.resultingParameterName; });
+                if (parameter === undefined) {
+                    // TODO: !!6 Change to logic error for higher level abstraction of chatbot to work
+                    throw new ParseError("Parameter `{".concat($taskJson.resultingParameterName, "}` is not defined so can not define example value of it"));
+                }
+                parameter.exampleValues = parameter.exampleValues || [];
+                parameter.exampleValues.push($taskJson.content);
+                $taskJson.isTask = false;
+                return;
+            }
+            if (command.taskType === 'KNOWLEDGE') {
+                knowledgeCommandParser.$applyToPipelineJson({
+                    type: 'KNOWLEDGE',
+                    knowledgeSourceContent: $taskJson.content, // <- TODO: [🐝][main] !!3 Work with KNOWLEDGE which not referring to the source file or website, but its content itself
+                }, $pipelineJson);
+                $taskJson.isTask = false;
+                return;
+            }
+            if (command.taskType === 'ACTION') {
+                console.error(new NotYetImplementedError('Actions are not implemented yet'));
+                $taskJson.isTask = false;
+                return;
+            }
+            if (command.taskType === 'INSTRUMENT') {
+                console.error(new NotYetImplementedError('Instruments are not implemented yet'));
+                $taskJson.isTask = false;
+                return;
+            }
+            expectResultingParameterName();
+            $taskJson.taskType = command.taskType;
+            $taskJson.isTask = true;
+        },
+        /**
+         * Converts the SECTION command back to string
+         *
+         * Note: This is used in `pipelineJsonToString` utility
+         */
+        stringify: function (command) {
+            return "---"; // <- TODO: [🛋] Implement
+        },
+        /**
+         * Reads the SECTION command from the `TaskJson`
+         *
+         * Note: This is used in `pipelineJsonToString` utility
+         */
+        takeFromTaskJson: function ($taskJson) {
+            throw new NotYetImplementedError("[\uD83D\uDECB] Not implemented yet"); // <- TODO: [🛋] Implement
+        },
+    };
+    /**
+     * Note: [⛱] There are two types of KNOWLEDGE, ACTION and INSTRUMENT commands:
+     * 1) There are commands `KNOWLEDGE`, `ACTION` and `INSTRUMENT` used in the pipeline head, they just define the knowledge, action or instrument as single line after the command
+     *    - KNOWLEDGE Look at https://en.wikipedia.org/wiki/Artificial_intelligence
+     * 2) `KNOWLEDGE SECTION` which has short form `KNOWLEDGE` is used in the sectiom, does not refer the line itself, but the content of the section block
+     *   - KNOWLEDGE SECTION
+     *
+     *   ```
+     *   Look at https://en.wikipedia.org/wiki/Artificial_intelligence
+     *   ```
+     */
+
+    /**
+     * Checks if an URL is reserved for private networks or localhost.
+     *
+     * Note: There are two simmilar functions:
+     * - `isUrlOnPrivateNetwork` which tests full URL
+     * - `isHostnameOnPrivateNetwork` *(this one)* which tests just hostname
+     *
+     * @public exported from `@promptbook/utils`
+     */
+    function isHostnameOnPrivateNetwork(hostname) {
+        if (hostname === 'example.com' ||
+            hostname === 'localhost' ||
+            hostname.endsWith('.localhost') ||
+            hostname.endsWith('.local') ||
+            hostname.endsWith('.test') ||
+            hostname === '127.0.0.1' ||
+            hostname === '::1') {
+            return true;
+        }
+        if (hostname.includes(':')) {
+            // IPv6
+            var ipParts = hostname.split(':');
+            return ipParts[0] === 'fc00' || ipParts[0] === 'fd00' || ipParts[0] === 'fe80';
+        }
+        else {
+            // IPv4
+            var ipParts = hostname.split('.').map(function (part) { return Number.parseInt(part, 10); });
+            return (ipParts[0] === 10 ||
+                (ipParts[0] === 172 && ipParts[1] >= 16 && ipParts[1] <= 31) ||
+                (ipParts[0] === 192 && ipParts[1] === 168));
+        }
+    }
+
+    /**
+     * Checks if an IP address or hostname is reserved for private networks or localhost.
+     *
+     * Note: There are two simmilar functions:
+     * - `isUrlOnPrivateNetwork` *(this one)* which tests full URL
+     * - `isHostnameOnPrivateNetwork` which tests just hostname
+     *
+     * @param {string} ipAddress - The IP address to check.
+     * @returns {boolean} Returns true if the IP address is reserved for private networks or localhost, otherwise false.
+     * @public exported from `@promptbook/utils`
+     */
+    function isUrlOnPrivateNetwork(url) {
+        if (typeof url === 'string') {
+            url = new URL(url);
+        }
+        return isHostnameOnPrivateNetwork(url.hostname);
+    }
+
+    /**
+     * Tests if given string is valid pipeline URL URL.
+     *
+     * Note: There are two simmilar functions:
+     * - `isValidUrl` which tests any URL
+     * - `isValidPipelineUrl` *(this one)* which tests just pipeline URL
+     *
+     * @public exported from `@promptbook/utils`
+     */
+    function isValidPipelineUrl(url) {
+        if (!isValidUrl(url)) {
+            return false;
+        }
+        if (!url.startsWith('https://')) {
+            return false;
+        }
+        if (url.includes('#')) {
+            // TODO: [🐠]
+            return false;
+        }
+        if (isUrlOnPrivateNetwork(url)) {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * TODO: [🐠] Maybe more info why the URL is invalid
+     */
+
+    /**
+     * Parses the url command
+     *
+     * @see `documentationUrl` for more details
+     * @public exported from `@promptbook/editable`
+     */
+    var urlCommandParser = {
+        /**
+         * Name of the command
+         */
+        name: 'URL',
+        aliasNames: ['PIPELINE_URL'],
+        /*
+        Note: [🛵] No need for this alias name because it is already preprocessed
+        aliasNames: ['HTTPS'],
+        */
+        /**
+         * BOILERPLATE command can be used in:
+         */
+        isUsedInPipelineHead: true,
+        isUsedInPipelineTask: false,
+        /**
+         * Description of the URL command
+         */
+        description: "Declares unique URL for the pipeline",
+        /**
+         * Link to documentation
+         */
+        documentationUrl: 'https://github.com/webgptorg/promptbook/discussions/70',
+        /**
+         * Example usages of the URL command
+         */
+        examples: [
+            'PIPELINE URL https://promptbook.studio/library/write-cv.book.md',
+            'URL https://promptbook.studio/library/write-cv.book.md',
+            'https://promptbook.studio/library/write-cv.book.md',
+        ],
+        /**
+         * Parses the URL command
+         */
+        parse: function (input) {
+            var args = input.args;
+            var pipelineUrl = args.pop();
+            if (pipelineUrl === undefined) {
+                throw new ParseError("URL is required");
+            }
+            // TODO: [🧠][🚲] This should be maybe tested as logic not parse
+            if (!isValidPipelineUrl(pipelineUrl)) {
+                throw new ParseError("Invalid pipeline URL \"".concat(pipelineUrl, "\""));
+            }
+            if (args.length > 0) {
+                throw new ParseError("Can not have more than one pipeline URL");
+            }
+            /*
+            TODO: [🐠 Maybe more info from `isValidPipelineUrl`:
+            if (pipelineUrl.protocol !== 'https:') {
+                throw new ParseError(`Protocol must be HTTPS`);
+            }
+
+            if (pipelineUrl.hash !== '') {
+                throw new ParseError(
+                    spaceTrim(
+                        `
+                            URL must not contain hash
+                            Hash is used for identification of the section of the pipeline
+                        `,
+                    ),
+                );
+            }
+            */
+            return {
+                type: 'URL',
+                pipelineUrl: new URL(pipelineUrl),
+            };
+        },
+        /**
+         * Apply the URL command to the `pipelineJson`
+         *
+         * Note: `$` is used to indicate that this function mutates given `pipelineJson`
+         */
+        $applyToPipelineJson: function (command, $pipelineJson) {
+            $pipelineJson.pipelineUrl = command.pipelineUrl.href;
+        },
+        /**
+         * Converts the URL command back to string
+         *
+         * Note: This is used in `pipelineJsonToString` utility
+         */
+        stringify: function (command) {
+            return "---"; // <- TODO: [🛋] Implement
+        },
+        /**
+         * Reads the URL command from the `PipelineJson`
+         *
+         * Note: This is used in `pipelineJsonToString` utility
+         */
+        takeFromPipelineJson: function (pipelineJson) {
+            throw new NotYetImplementedError("[\uD83D\uDECB] Not implemented yet"); // <- TODO: [🛋] Implement
+        },
+    };
+
+    /**
+     * Parses the action command
+     *
+     * @see `documentationUrl` for more details
+     * @public exported from `@promptbook/editable`
+     */
+    var actionCommandParser = {
+        /**
+         * Name of the command
+         */
+        name: 'ACTION',
+        /**
+         * ACTION command can be used in:
+         */
+        isUsedInPipelineHead: true,
+        isUsedInPipelineTask: false,
+        /**
+         * Description of the ACTION command
+         */
+        description: "Actions influences from the pipeline or task into external world. Like turning on a light, sending an email, etc.",
+        /**
+         * Link to documentation
+         */
+        documentationUrl: 'https://github.com/webgptorg/promptbook/discussions/72',
+        /**
+         * Example usages of the ACTION command
+         */
+        examples: ['ACTION'],
+        /**
+         * Parses the ACTION command
+         */
+        parse: function (input) {
+            input.args;
+            return {
+                type: 'ACTION',
+            };
+        },
+        /**
+         * Apply the ACTION command to the `pipelineJson`
+         *
+         * Note: `$` is used to indicate that this function mutates given `pipelineJson`
+         */
+        $applyToPipelineJson: function (command, $pipelineJson) {
+            console.error(new NotYetImplementedError('[🛠] Actions are not implemented yet'));
+        },
+        /**
+         * Converts the ACTION command back to string
+         *
+         * Note: This is used in `pipelineJsonToString` utility
+         */
+        stringify: function (command) {
+            throw new NotYetImplementedError('[🛠] Actions are not implemented yet');
+        },
+        /**
+         * Reads the ACTION command from the `PipelineJson`
+         *
+         * Note: This is used in `pipelineJsonToString` utility
+         */
+        takeFromPipelineJson: function (pipelineJson) {
+            throw new NotYetImplementedError('[🛠] Actions are not implemented yet');
+        },
+    };
+    /**
+     * Note: [⛱] There are two types of ACTION commands *...(read more in [⛱])*
+     */
+
+    /**
+     * Parses the instrument command
+     *
+     * @see `documentationUrl` for more details
+     * @public exported from `@promptbook/editable`
+     */
+    var instrumentCommandParser = {
+        /**
+         * Name of the command
+         */
+        name: 'INSTRUMENT',
+        /**
+         * INSTRUMENT command can be used in:
+         */
+        isUsedInPipelineHead: true,
+        isUsedInPipelineTask: false,
+        /**
+         * Description of the INSTRUMENT command
+         */
+        description: "Instrument command is used to specify the instrument to be used in the pipeline or task like search, calculate, etc.",
+        /**
+         * Link to documentation
+         */
+        documentationUrl: 'https://github.com/webgptorg/promptbook/discussions/71',
+        /**
+         * Example usages of the INSTRUMENT command
+         */
+        examples: ['INSTRUMENT'],
+        /**
+         * Parses the INSTRUMENT command
+         */
+        parse: function (input) {
+            input.args;
+            return {
+                type: 'INSTRUMENT',
+            };
+        },
+        /**
+         * Apply the INSTRUMENT command to the `pipelineJson`
+         *
+         * Note: `$` is used to indicate that this function mutates given `pipelineJson`
+         */
+        $applyToPipelineJson: function (command, $pipelineJson) {
+            console.error(new NotYetImplementedError('[🛠] Instruments are not implemented yet'));
+        },
+        /**
+         * Converts the INSTRUMENT command back to string
+         *
+         * Note: This is used in `pipelineJsonToString` utility
+         */
+        stringify: function (command) {
+            throw new NotYetImplementedError('[🛠] Instruments are not implemented yet');
+        },
+        /**
+         * Reads the INSTRUMENT command from the `PipelineJson`
+         *
+         * Note: This is used in `pipelineJsonToString` utility
+         */
+        takeFromPipelineJson: function (pipelineJson) {
+            throw new NotYetImplementedError('[🛠] Instruments are not implemented yet');
+        },
+    };
+    /**
+     * Note: [⛱] There are two types of INSTRUMENT commands *...(read more in [⛱])*
+     */
+
+    /**
+     * All available command parsers
+     *
+     * @public exported from `@promptbook/editable`
+     */
+    var COMMANDS = [
+        sectionCommandParser,
+        expectCommandParser,
+        formatCommandParser,
+        jokerCommandParser,
+        modelCommandParser,
+        parameterCommandParser,
+        postprocessCommandParser,
+        bookVersionCommandParser,
+        formfactorCommandParser,
+        urlCommandParser,
+        knowledgeCommandParser,
+        actionCommandParser,
+        instrumentCommandParser,
+        personaCommandParser,
+        foreachCommandParser,
+        boilerplateCommandParser, // <- TODO: Only in development, remove in production
+        // <- Note: [♓️][💩] This is the order of the commands in the pipeline, BUT its not used in parsing and before usage maybe it should be done better
+    ];
+    /**
+     * Note: [💞] Ignore a discrepancy between file name and entity name
+     */
+
+    /**
+     * Gets the parser for the command
+     *
+     * @returns the parser for the command
+     * @throws {UnexpectedError} if the parser is not found
+     *
+     * @public exported from `@promptbook/editable`
+     */
+    function getParserForCommand(command) {
+        var commandParser = COMMANDS.find(function (commandParser) { return commandParser.name === command.type; });
+        if (commandParser === undefined) {
+            throw new UnexpectedError(spaceTrim.spaceTrim(function (block) { return "\n                    Command ".concat(command.type, " parser is not found\n\n                    ").concat(block(JSON.stringify(command, null, 4)
+                .split('\n')
+                .map(function (line) { return "> ".concat(line); })
+                .join('\n')), "\n                "); }));
+        }
+        return commandParser;
+    }
+
+    /**
+     * 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.
+     * @public exported from `@promptbook/markdown-utils`
+     */
+    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;
+    }
+
+    /**
+     * Parses one line of ul/ol to command
+     *
+     * @returns parsed command object
+     * @throws {ParseError} if the command is invalid
+     *
+     * @public exported from `@promptbook/editable`
+     */
+    function parseCommand(raw, usagePlace) {
+        if (raw.includes('\n') || raw.includes('\r')) {
+            throw new ParseError('Command can not contain new line characters' /* <- TODO: [🚞] */);
+        }
+        // TODO: Unit test all this processing and parsing
+        var normalized = raw.trim();
+        normalized = normalized.split('`').join('');
+        normalized = normalized.split('"').join('');
+        normalized = normalized.split("'").join('');
+        normalized = normalized.split('~').join('');
+        normalized = normalized.split('[').join('');
+        normalized = normalized.split(']').join('');
+        normalized = normalized.split('(').join('');
+        normalized = normalized.split(')').join('');
+        normalized = normalizeTo_SCREAMING_CASE(normalized);
+        var items = raw
+            .trim()
+            // Note: [🐡]
+            .split(/^>/)
+            .join('')
+            // ---
+            .trim()
+            .split(/["'`]/)
+            .join('')
+            .trim()
+            // Note: [🛵]:
+            .split(/^http/)
+            .join('URL http')
+            // ---
+            // Note: [🦈]
+            .split(/^{/)
+            .join('PARAMETER {')
+            // ---
+            .split(' ')
+            .map(function (part) { return part.trim(); })
+            .filter(function (item) { return item !== ''; })
+            .map(removeMarkdownFormatting)
+            .map(function (item) { return item.trim(); });
+        if (items.length === 0 || items[0] === '') {
+            throw new ParseError(spaceTrim.spaceTrim(function (block) {
+                return "\n                        Malformed command:\n                        - ".concat(raw, "\n\n                        Supported commands are:\n                        ").concat(block(getSupportedCommandsMessage()), "\n\n                    ");
+            }));
+        }
+        // Note: Taking command name from beginning of the line
+        //       FOO | BAR   Arg1   Arg2   Arg3
+        //       FOO   BAR | Arg1   Arg2   Arg3
+        for (var commandNameSegmentsCount = 0; commandNameSegmentsCount < Math.min(items.length, 3); commandNameSegmentsCount++) {
+            var commandNameRaw = items.slice(0, commandNameSegmentsCount + 1).join('_');
+            var args = items.slice(commandNameSegmentsCount + 1);
+            var rawArgs = raw
+                .substring(commandNameRaw.length)
+                .trim();
+            var command = parseCommandVariant({ usagePlace: usagePlace, raw: raw, rawArgs: rawArgs, normalized: normalized, args: args, commandNameRaw: commandNameRaw });
+            if (command !== null) {
+                return command;
+            }
+        }
+        // Note: Taking command name from end of the line
+        //        Arg1   Arg2   Arg3 | FOO
+        {
+            var commandNameRaw = items.slice(-1).join('_');
+            var args = items.slice(0, -1); // <- Note: This is probbably not correct
+            var rawArgs = raw
+                .substring(0, raw.length - commandNameRaw.length)
+                .trim();
+            var command = parseCommandVariant({ usagePlace: usagePlace, raw: raw, rawArgs: rawArgs, normalized: normalized, args: args, commandNameRaw: commandNameRaw });
+            if (command !== null) {
+                return command;
+            }
+        }
+        throw new ParseError(spaceTrim.spaceTrim(function (block) {
+            return "\n                  Malformed or unknown command:\n                  - ".concat(raw, "\n\n                  Supported commands are:\n                  ").concat(block(getSupportedCommandsMessage()), "\n\n              ");
+        }));
+    }
+    /**
+     * @@@
+     */
+    function getSupportedCommandsMessage() {
+        return COMMANDS.flatMap(function (_a) {
+            var name = _a.name, aliasNames = _a.aliasNames, description = _a.description, documentationUrl = _a.documentationUrl;
+            //                                                                        <- Note: [🦦] Its strange that this type assertion is needed
+            return __spreadArray([
+                "- **".concat(name, "** ").concat(description, ", see [discussion](").concat(documentationUrl, ")")
+            ], __read((aliasNames || []).map(function (aliasName) { return "    - **".concat(aliasName, "** Alias for **").concat(name, "**"); })), false);
+        }).join('\n');
+    }
+    /**
+     * @@@
+     */
+    function parseCommandVariant(input) {
+        var e_1, _a;
+        var commandNameRaw = input.commandNameRaw, usagePlace = input.usagePlace, normalized = input.normalized, args = input.args, raw = input.raw, rawArgs = input.rawArgs;
+        var commandName = normalizeTo_SCREAMING_CASE(commandNameRaw);
+        var _loop_1 = function (commandParser) {
+            //                               <- Note: [🦦] Its strange that this type assertion is needed
+            var name_1 = commandParser.name, isUsedInPipelineHead = commandParser.isUsedInPipelineHead, isUsedInPipelineTask = commandParser.isUsedInPipelineTask, aliasNames = commandParser.aliasNames, deprecatedNames = commandParser.deprecatedNames, parse = commandParser.parse;
+            if (just(false)) ;
+            else if (usagePlace === 'PIPELINE_HEAD' && !isUsedInPipelineHead) {
+                return "continue";
+            }
+            else if (usagePlace === 'PIPELINE_TASK' && !isUsedInPipelineTask) {
+                return "continue";
+            }
+            var names = __spreadArray(__spreadArray([name_1], __read((aliasNames || [])), false), __read((deprecatedNames || [])), false);
+            if (names.includes(commandName)) {
+                try {
+                    return { value: parse({ usagePlace: usagePlace, raw: raw, rawArgs: rawArgs, normalized: normalized, args: args }) };
+                }
+                catch (error) {
+                    if (!(error instanceof ParseError)) {
+                        throw error;
+                    }
+                    throw new ParseError(spaceTrim.spaceTrim(function (block) {
+                        return "\n                              Invalid ".concat(commandName, " command:\n\n                              Your command:\n                              - ").concat(raw, "\n\n                              The detailed error:\n                              ").concat(block(error.message), "\n\n                              Usage of ").concat(commandName, ":\n                              ").concat(block(commandParser.examples.map(function (example) { return "- ".concat(example); }).join('\n')), "\n\n                              All supported commands are:\n                              ").concat(block(getSupportedCommandsMessage()), "\n\n                          ");
+                    }));
+                }
+            }
+        };
+        try {
+            for (var _b = __values(COMMANDS), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var commandParser = _c.value;
+                var state_1 = _loop_1(commandParser);
+                if (typeof state_1 === "object")
+                    return state_1.value;
+            }
+        }
+        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 null;
+    }
+
+    /**
+     * Function `removePipelineCommand` will remove one command from pipeline string
+     *
+     * @public exported from `@promptbook/editable`
+     */
+    function removePipelineCommand(options) {
+        var e_1, _a;
+        var command = options.command, pipeline = options.pipeline;
+        var lines = pipeline.split('\n');
+        // TODO: [🧽] DRY
+        var currentType = 'MARKDOWN';
+        var newLines = [];
+        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 (currentType === 'MARKDOWN') {
+                    if (line.startsWith('```')) {
+                        currentType = 'CODE_BLOCK';
+                    }
+                    else if (line.includes('<!--')) {
+                        currentType = 'COMMENT';
+                    }
+                }
+                else if (currentType === 'CODE_BLOCK') {
+                    if (line.startsWith('```')) {
+                        currentType = 'MARKDOWN';
+                    }
+                }
+                else if (currentType === 'COMMENT') {
+                    if (line.includes('-->')) {
+                        currentType = 'MARKDOWN';
+                    }
+                }
+                if (currentType === 'MARKDOWN' && /^(-|\d\))/m.test(line) && line.toUpperCase().includes(command)) {
+                    continue;
+                }
+                newLines.push(line);
+            }
+        }
+        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; }
+        }
+        var newPipeline = spaceTrim__default["default"](newLines.join('\n'));
+        return newPipeline;
+    }
+
+    /**
+     * This error indicates that the promptbook object has valid syntax (=can be parsed) but contains logical errors (like circular dependencies)
+     *
+     * @public exported from `@promptbook/core`
+     */
+    var PipelineLogicError = /** @class */ (function (_super) {
+        __extends(PipelineLogicError, _super);
+        function PipelineLogicError(message) {
+            var _this = _super.call(this, message) || this;
+            _this.name = 'PipelineLogicError';
+            Object.setPrototypeOf(_this, PipelineLogicError.prototype);
+            return _this;
+        }
+        return PipelineLogicError;
+    }(Error));
+
+    /**
+     * Function `renamePipelineParameter` will find all usable parameters for given task
+     * In other words, it will find all parameters that are not used in the task itseld and all its dependencies
+     *
+     * @throws {PipelineLogicError} If the new parameter name is already used in the pipeline
+     * @public exported from `@promptbook/editable`
+     */
+    function renamePipelineParameter(options) {
+        var e_1, _a, e_2, _b;
+        var pipeline = options.pipeline, oldParameterName = options.oldParameterName, newParameterName = options.newParameterName;
+        if (pipeline.parameters.some(function (parameter) { return parameter.name === newParameterName; })) {
+            throw new PipelineLogicError("Can not replace {".concat(oldParameterName, "} to {").concat(newParameterName, "} because {").concat(newParameterName, "} is already used in the pipeline"));
+        }
+        var renamedPipeline = __assign(__assign({}, pipeline), { 
+            // <- TODO: [🪓] This should be without `as $PipelineJson`
+            parameters: __spreadArray([], __read(pipeline.parameters), false), tasks: __spreadArray([], __read(pipeline.tasks), false) });
+        try {
+            for (var _c = __values(renamedPipeline.parameters), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var parameter = _d.value;
+                if (parameter.name !== oldParameterName) {
+                    continue;
+                }
+                parameter.name = newParameterName;
+            }
+        }
+        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; }
+        }
+        try {
+            for (var _e = __values(renamedPipeline.tasks), _f = _e.next(); !_f.done; _f = _e.next()) {
+                var task = _f.value;
+                if (task.resultingParameterName === oldParameterName) {
+                    task.resultingParameterName = newParameterName;
+                }
+                task.dependentParameterNames = task.dependentParameterNames.map(function (dependentParameterName) {
+                    return dependentParameterName === oldParameterName ? newParameterName : dependentParameterName;
+                });
+                task.content = task.content.replace(new RegExp("{".concat(oldParameterName, "}"), 'g'), "{".concat(newParameterName, "}"));
+                task.title = task.title.replace(new RegExp("{".concat(oldParameterName, "}"), 'g'), "{".concat(newParameterName, "}"));
+                task.description =
+                    task.description === undefined
+                        ? undefined
+                        : task.description.replace(new RegExp("{".concat(oldParameterName, "}"), 'g'), "{".concat(newParameterName, "}"));
+            }
+        }
+        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 renamedPipeline;
+    }
+
     // <- TODO: Auto convert to type `import { ... } from 'type-fest';`
     /**
      * Tests if the value is [🚉] serializable as JSON
@@ -635,10 +4055,29 @@
      */
 
     exports.BOOK_LANGUAGE_VERSION = BOOK_LANGUAGE_VERSION;
+    exports.COMMANDS = COMMANDS;
     exports.PROMPTBOOK_ENGINE_VERSION = PROMPTBOOK_ENGINE_VERSION;
+    exports.actionCommandParser = actionCommandParser;
+    exports.bookVersionCommandParser = bookVersionCommandParser;
+    exports.expectCommandParser = expectCommandParser;
+    exports.foreachCommandParser = foreachCommandParser;
+    exports.formatCommandParser = formatCommandParser;
+    exports.formfactorCommandParser = formfactorCommandParser;
+    exports.getParserForCommand = getParserForCommand;
+    exports.instrumentCommandParser = instrumentCommandParser;
+    exports.jokerCommandParser = jokerCommandParser;
+    exports.knowledgeCommandParser = knowledgeCommandParser;
+    exports.knowledgeSourceContentToName = knowledgeSourceContentToName;
+    exports.modelCommandParser = modelCommandParser;
+    exports.parameterCommandParser = parameterCommandParser;
+    exports.parseCommand = parseCommand;
+    exports.personaCommandParser = personaCommandParser;
+    exports.postprocessCommandParser = postprocessCommandParser;
     exports.removePipelineCommand = removePipelineCommand;
     exports.renamePipelineParameter = renamePipelineParameter;
+    exports.sectionCommandParser = sectionCommandParser;
     exports.stringifyPipelineJson = stringifyPipelineJson;
+    exports.urlCommandParser = urlCommandParser;
 
     Object.defineProperty(exports, '__esModule', { value: true });