@promptbook/editable 0.82.0-3 → 0.83.0

package/esm/index.es.js

@@ -1,4 +1,7 @@
 import spaceTrim, { spaceTrim as spaceTrim$1 } from 'spacetrim';
+import { unparse, parse } from 'papaparse';
+import { SHA256 } from 'crypto-js';
+import hexEncoder from 'crypto-js/enc-hex';
 
 // ⚠️ WARNING: This code has been generated so that any manual changes will be overwritten
 /**
@@ -14,7 +17,7 @@ var BOOK_LANGUAGE_VERSION = '1.0.0';
  * @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
@@ -62,6 +65,44 @@ var __assign = function() {
     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);
@@ -102,128 +143,23 @@ function __spreadArray(to, from, pack) {
 }
 
 /**
- * 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(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;
 }
 
 /**
@@ -270,56 +206,6 @@ Object.freeze({
  * 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
  *
@@ -355,216 +241,3752 @@ var UnexpectedError = /** @class */ (function (_super) {
 }(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$1(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(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(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("\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(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(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(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 = parse(value, __assign(__assign({}, settings), MANDATORY_CSV_SETTINGS));
+                                if (csv.errors.length !== 0) {
+                                    throw new CsvFormatError(spaceTrim(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*/, 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 = parse(value, __assign(__assign({}, settings), MANDATORY_CSV_SETTINGS));
+                                if (csv.errors.length !== 0) {
+                                    throw new CsvFormatError(spaceTrim(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*/, 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(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(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(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(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(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(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(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("\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("\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(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("\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 = SHA256(hexEncoder.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(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(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(function (block) { return "\n                        Embedding model can not be used in pipeline\n\n                        ".concat(block(availableVariantsMessage), "\n                    "); });
+            }
+            else {
+                throw new ParseError(spaceTrim(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(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("\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("\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("\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(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("\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('\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(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("\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$1(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$1(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$1(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$1(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(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
@@ -626,5 +4048,5 @@ function stringifyPipelineJson(pipeline) {
  * TODO: [🍙] Make some standard order of json properties
  */
 
-export { BOOK_LANGUAGE_VERSION, PROMPTBOOK_ENGINE_VERSION, removePipelineCommand, renamePipelineParameter, stringifyPipelineJson };
+export { BOOK_LANGUAGE_VERSION, COMMANDS, PROMPTBOOK_ENGINE_VERSION, actionCommandParser, bookVersionCommandParser, expectCommandParser, foreachCommandParser, formatCommandParser, formfactorCommandParser, getParserForCommand, instrumentCommandParser, jokerCommandParser, knowledgeCommandParser, knowledgeSourceContentToName, modelCommandParser, parameterCommandParser, parseCommand, personaCommandParser, postprocessCommandParser, removePipelineCommand, renamePipelineParameter, sectionCommandParser, stringifyPipelineJson, urlCommandParser };
 //# sourceMappingURL=index.es.js.map