@promptbook/editable 0.86.10 → 0.86.30

package/umd/index.umd.js

@@ -16,138 +16,19 @@
      * @generated
      * @see https://github.com/webgptorg/book
      */
-    var BOOK_LANGUAGE_VERSION = '1.0.0';
+    const BOOK_LANGUAGE_VERSION = '1.0.0';
     /**
      * The version of the Promptbook engine
      *
      * @generated
      * @see https://github.com/webgptorg/promptbook
      */
-    var PROMPTBOOK_ENGINE_VERSION = '0.86.10';
+    const PROMPTBOOK_ENGINE_VERSION = '0.86.30';
     /**
      * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
      * Note: [💞] Ignore a discrepancy between file name and entity name
      */
 
-    /*! *****************************************************************************
-    Copyright (c) Microsoft Corporation.
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose with or without fee is hereby granted.
-
-    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-    PERFORMANCE OF THIS SOFTWARE.
-    ***************************************************************************** */
-    /* global Reflect, Promise */
-
-    var extendStatics = function(d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-
-    function __extends(d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    }
-
-    var __assign = function() {
-        __assign = Object.assign || function __assign(t) {
-            for (var s, i = 1, n = arguments.length; i < n; i++) {
-                s = arguments[i];
-                for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
-            }
-            return t;
-        };
-        return __assign.apply(this, arguments);
-    };
-
-    function __awaiter(thisArg, _arguments, P, generator) {
-        function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-        return new (P || (P = Promise))(function (resolve, reject) {
-            function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-            function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-            function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-            step((generator = generator.apply(thisArg, _arguments || [])).next());
-        });
-    }
-
-    function __generator(thisArg, body) {
-        var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-        return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-        function verb(n) { return function (v) { return step([n, v]); }; }
-        function step(op) {
-            if (f) throw new TypeError("Generator is already executing.");
-            while (_) try {
-                if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-                if (y = 0, t) op = [op[0] & 2, t.value];
-                switch (op[0]) {
-                    case 0: case 1: t = op; break;
-                    case 4: _.label++; return { value: op[1], done: false };
-                    case 5: _.label++; y = op[1]; op = [0]; continue;
-                    case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                    default:
-                        if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                        if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                        if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                        if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                        if (t[2]) _.ops.pop();
-                        _.trys.pop(); continue;
-                }
-                op = body.call(thisArg, _);
-            } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-            if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-        }
-    }
-
-    function __values(o) {
-        var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-        if (m) return m.call(o);
-        if (o && typeof o.length === "number") return {
-            next: function () {
-                if (o && i >= o.length) o = void 0;
-                return { value: o && o[i++], done: !o };
-            }
-        };
-        throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-    }
-
-    function __read(o, n) {
-        var m = typeof Symbol === "function" && o[Symbol.iterator];
-        if (!m) return o;
-        var i = m.call(o), r, ar = [], e;
-        try {
-            while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-        }
-        catch (error) { e = { error: error }; }
-        finally {
-            try {
-                if (r && !r.done && (m = i["return"])) m.call(i);
-            }
-            finally { if (e) throw e.error; }
-        }
-        return ar;
-    }
-
-    function __spreadArray(to, from, pack) {
-        if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-            if (ar || !(i in from)) {
-                if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-                ar[i] = from[i];
-            }
-        }
-        return to.concat(ar || Array.prototype.slice.call(from));
-    }
-
     /**
      * Returns the same value that is passed as argument.
      * No side effects.
@@ -175,38 +56,38 @@
      *
      * @public exported from `@promptbook/core`
      */
-    var NAME = "Promptbook";
+    const NAME = `Promptbook`;
     /**
      * Email of the responsible person
      *
      * @public exported from `@promptbook/core`
      */
-    var ADMIN_EMAIL = 'pavol@ptbk.io';
+    const ADMIN_EMAIL = 'pavol@ptbk.io';
     /**
      * Name of the responsible person for the Promptbook on GitHub
      *
      * @public exported from `@promptbook/core`
      */
-    var ADMIN_GITHUB_NAME = 'hejny';
+    const ADMIN_GITHUB_NAME = 'hejny';
     /**
      * When the title is not provided, the default title is used
      *
      * @public exported from `@promptbook/core`
      */
-    var DEFAULT_BOOK_TITLE = "\u2728 Untitled Book";
+    const DEFAULT_BOOK_TITLE = `✨ Untitled Book`;
     /**
      * When the pipeline is flat and no name of return parameter is provided, this name is used
      *
      * @public exported from `@promptbook/core`
      */
-    var DEFAULT_BOOK_OUTPUT_PARAMETER_NAME = 'result';
+    const DEFAULT_BOOK_OUTPUT_PARAMETER_NAME = 'result';
     // <- TODO: [🧠] Better system for generator warnings - not always "code" and "by `@promptbook/cli`"
     /**
      * The maximum number of iterations for a loops
      *
      * @private within the repository - too low-level in comparison with other `MAX_...`
      */
-    var LOOP_LIMIT = 1000;
+    const LOOP_LIMIT = 1000;
     // <- TODO: [🧜‍♂️]
     /**
      * @@@
@@ -230,11 +111,37 @@
      * @private private within the repository
      */
     function getErrorReportUrl(error) {
-        var report = {
-            title: "\uD83D\uDC1C Error report from ".concat(NAME),
-            body: spaceTrim__default["default"](function (block) { return "\n\n\n            `".concat(error.name || 'Error', "` has occurred in the [").concat(NAME, "], please look into it @").concat(ADMIN_GITHUB_NAME, ".\n\n            ```\n            ").concat(block(error.message || '(no error message)'), "\n            ```\n\n\n            ## More info:\n\n            - **Promptbook engine version:** ").concat(PROMPTBOOK_ENGINE_VERSION, "\n            - **Book language version:** ").concat(BOOK_LANGUAGE_VERSION, "\n            - **Time:** ").concat(new Date().toISOString(), "\n\n            <details>\n            <summary>Stack trace:</summary>\n\n            ## Stack trace:\n\n            ```stacktrace\n            ").concat(block(error.stack || '(empty)'), "\n            ```\n            </details>\n\n        "); }),
+        const report = {
+            title: `🐜 Error report from ${NAME}`,
+            body: spaceTrim__default["default"]((block) => `
+
+
+            \`${error.name || 'Error'}\` has occurred in the [${NAME}], please look into it @${ADMIN_GITHUB_NAME}.
+
+            \`\`\`
+            ${block(error.message || '(no error message)')}
+            \`\`\`
+
+
+            ## More info:
+
+            - **Promptbook engine version:** ${PROMPTBOOK_ENGINE_VERSION}
+            - **Book language version:** ${BOOK_LANGUAGE_VERSION}
+            - **Time:** ${new Date().toISOString()}
+
+            <details>
+            <summary>Stack trace:</summary>
+
+            ## Stack trace:
+
+            \`\`\`stacktrace
+            ${block(error.stack || '(empty)')}
+            \`\`\`
+            </details>
+
+        `),
         };
-        var reportUrl = new URL("https://github.com/webgptorg/promptbook/issues/new");
+        const reportUrl = new URL(`https://github.com/webgptorg/promptbook/issues/new`);
         reportUrl.searchParams.set('labels', 'bug');
         reportUrl.searchParams.set('assignees', ADMIN_GITHUB_NAME);
         reportUrl.searchParams.set('title', report.title);
@@ -247,32 +154,37 @@
      *
      * @public exported from `@promptbook/core`
      */
-    var UnexpectedError = /** @class */ (function (_super) {
-        __extends(UnexpectedError, _super);
-        function UnexpectedError(message) {
-            var _this = _super.call(this, spaceTrim.spaceTrim(function (block) { return "\n                    ".concat(block(message), "\n\n                    Note: This error should not happen.\n                    It's probbably a bug in the pipeline collection\n\n                    Please report issue:\n                    ").concat(block(getErrorReportUrl(new Error(message)).href), "\n\n                    Or contact us on ").concat(ADMIN_EMAIL, "\n\n                "); })) || this;
-            _this.name = 'UnexpectedError';
-            Object.setPrototypeOf(_this, UnexpectedError.prototype);
-            return _this;
+    class UnexpectedError extends Error {
+        constructor(message) {
+            super(spaceTrim.spaceTrim((block) => `
+                    ${block(message)}
+
+                    Note: This error should not happen.
+                    It's probbably a bug in the pipeline collection
+
+                    Please report issue:
+                    ${block(getErrorReportUrl(new Error(message)).href)}
+
+                    Or contact us on ${ADMIN_EMAIL}
+
+                `));
+            this.name = 'UnexpectedError';
+            Object.setPrototypeOf(this, UnexpectedError.prototype);
         }
-        return UnexpectedError;
-    }(Error));
+    }
 
     /**
      * This error indicates that the promptbook in a markdown format cannot be parsed into a valid promptbook object
      *
      * @public exported from `@promptbook/core`
      */
-    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;
+    class ParseError extends Error {
+        constructor(message) {
+            super(message);
+            this.name = 'ParseError';
+            Object.setPrototypeOf(this, ParseError.prototype);
         }
-        return ParseError;
-    }(Error));
+    }
     /**
      * TODO: Maybe split `ParseError` and `ApplyError`
      */
@@ -285,7 +197,7 @@
      * @see `documentationUrl` for more details
      * @private within the commands folder
      */
-    var boilerplateCommandParser = {
+    const boilerplateCommandParser = {
         /**
          * Name of the command
          */
@@ -302,7 +214,7 @@
         /**
          * Description of the BOILERPLATE command
          */
-        description: "@@",
+        description: `@@`,
         /**
          * Link to documentation
          */
@@ -314,18 +226,18 @@
         /**
          * Parses the BOILERPLATE command
          */
-        parse: function (input) {
-            var args = input.args;
+        parse(input) {
+            const { args } = input;
             if (args.length !== 1) {
-                throw new ParseError("BOILERPLATE command requires exactly one argument");
+                throw new ParseError(`BOILERPLATE command requires exactly one argument`);
             }
-            var value = args[0].toLowerCase();
+            const value = args[0].toLowerCase();
             if (value.includes('brr')) {
-                throw new ParseError("BOILERPLATE value can not contain brr");
+                throw new ParseError(`BOILERPLATE value can not contain brr`);
             }
             return {
                 type: 'BOILERPLATE',
-                value: value,
+                value,
             };
         },
         /**
@@ -333,40 +245,40 @@
          *
          * 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");
+        $applyToPipelineJson(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");
+        $applyToTaskJson(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
+        stringify(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");
+        takeFromPipelineJson(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");
+        takeFromTaskJson($taskJson) {
+            throw new ParseError(`BOILERPLATE command is only for testing purposes and should not be used in the .book.md file`);
         },
     };
 
@@ -375,16 +287,23 @@
      *
      * @public exported from `@promptbook/core`
      */
-    var NotYetImplementedError = /** @class */ (function (_super) {
-        __extends(NotYetImplementedError, _super);
-        function NotYetImplementedError(message) {
-            var _this = _super.call(this, spaceTrim.spaceTrim(function (block) { return "\n                    ".concat(block(message), "\n\n                    Note: This feature is not implemented yet but it will be soon.\n\n                    If you want speed up the implementation or just read more, look here:\n                    https://github.com/webgptorg/promptbook\n\n                    Or contact us on pavol@ptbk.io\n\n                "); })) || this;
-            _this.name = 'NotYetImplementedError';
-            Object.setPrototypeOf(_this, NotYetImplementedError.prototype);
-            return _this;
+    class NotYetImplementedError extends Error {
+        constructor(message) {
+            super(spaceTrim.spaceTrim((block) => `
+                    ${block(message)}
+
+                    Note: This feature is not implemented yet but it will be soon.
+
+                    If you want speed up the implementation or just read more, look here:
+                    https://github.com/webgptorg/promptbook
+
+                    Or contact us on pavol@ptbk.io
+
+                `));
+            this.name = 'NotYetImplementedError';
+            Object.setPrototypeOf(this, NotYetImplementedError.prototype);
         }
-        return NotYetImplementedError;
-    }(Error));
+    }
 
     /**
      * Tests if given string is valid semantic version
@@ -434,7 +353,7 @@
      * @see `documentationUrl` for more details
      * @public exported from `@promptbook/editable`
      */
-    var bookVersionCommandParser = {
+    const bookVersionCommandParser = {
         /**
          * Name of the command
          */
@@ -448,7 +367,7 @@
         /**
          * Description of the BOOK_VERSION command
          */
-        description: "Which version of the Book language is the .book.md using",
+        description: `Which version of the Book language is the .book.md using`,
         /**
          * Link to documentation
          */
@@ -456,21 +375,21 @@
         /**
          * Example usages of the BOOK_VERSION command
          */
-        examples: ["BOOK VERSION ".concat(BOOK_LANGUAGE_VERSION), "BOOK ".concat(BOOK_LANGUAGE_VERSION)],
+        examples: [`BOOK VERSION ${BOOK_LANGUAGE_VERSION}`, `BOOK ${BOOK_LANGUAGE_VERSION}`],
         /**
          * Parses the BOOK_VERSION command
          */
-        parse: function (input) {
-            var args = input.args;
-            var bookVersion = args.pop();
+        parse(input) {
+            const { args } = input;
+            const bookVersion = args.pop();
             if (bookVersion === undefined) {
-                throw new ParseError("Version is required");
+                throw new ParseError(`Version is required`);
             }
             if (!isValidPromptbookVersion(bookVersion)) {
-                throw new ParseError("Invalid Promptbook version \"".concat(bookVersion, "\""));
+                throw new ParseError(`Invalid Promptbook version "${bookVersion}"`);
             }
             if (args.length > 0 && !(((args.length === 1 && args[0]) || '').toUpperCase() === 'VERSION')) {
-                throw new ParseError("Can not have more than one Promptbook version");
+                throw new ParseError(`Can not have more than one Promptbook version`);
             }
             return {
                 type: 'BOOK_VERSION',
@@ -482,7 +401,7 @@
          *
          * Note: `$` is used to indicate that this function mutates given `pipelineJson`
          */
-        $applyToPipelineJson: function (command, $pipelineJson) {
+        $applyToPipelineJson(command, $pipelineJson) {
             // TODO: Warn if the version is overridden
             $pipelineJson.bookVersion = command.bookVersion;
         },
@@ -491,16 +410,16 @@
          *
          * Note: This is used in `pipelineJsonToString` utility
          */
-        stringify: function (command) {
-            return "---"; // <- TODO: [🛋] Implement
+        stringify(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
+        takeFromPipelineJson(pipelineJson) {
+            throw new NotYetImplementedError(`[🛋] Not implemented yet`); // <- TODO: [🛋] Implement
         },
     };
 
@@ -510,7 +429,7 @@
      * @see https://github.com/webgptorg/promptbook/discussions/30
      * @public exported from `@promptbook/core`
      */
-    var EXPECTATION_UNITS = ['CHARACTERS', 'WORDS', 'SENTENCES', 'LINES', 'PARAGRAPHS', 'PAGES'];
+    const EXPECTATION_UNITS = ['CHARACTERS', 'WORDS', 'SENTENCES', 'LINES', 'PARAGRAPHS', 'PAGES'];
     /**
      * TODO: [💝] Unite object for expecting amount and format - remove format
      */
@@ -527,7 +446,7 @@
      * @public exported from `@promptbook/utils`
      */
     function parseNumber(value) {
-        var originalValue = value;
+        const originalValue = value;
         if (typeof value === 'number') {
             value = value.toString(); // <- TODO: Maybe more efficient way to do this
         }
@@ -539,7 +458,7 @@
             return parseNumber(value.substring(1));
         }
         if (value.startsWith('-')) {
-            var number = parseNumber(value.substring(1));
+            const number = parseNumber(value.substring(1));
             if (number === 0) {
                 return 0; // <- Note: To prevent -0
             }
@@ -554,11 +473,11 @@
             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_);
+            const [numerator_, denominator_] = value.split('/');
+            const numerator = parseNumber(numerator_);
+            const denominator = parseNumber(denominator_);
             if (denominator === 0) {
-                throw new ParseError("Unable to parse number from \"".concat(originalValue, "\" because denominator is zero"));
+                throw new ParseError(`Unable to parse number from "${originalValue}" because denominator is zero`);
             }
             return numerator / denominator;
         }
@@ -566,15 +485,15 @@
             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));
+            const [significand, exponent] = value.split('E');
+            return parseNumber(significand) * 10 ** parseNumber(exponent);
         }
         if (!/^[0-9.]+$/.test(value) || value.split('.').length > 2) {
-            throw new ParseError("Unable to parse number from \"".concat(originalValue, "\""));
+            throw new ParseError(`Unable to parse number from "${originalValue}"`);
         }
-        var num = parseFloat(value);
+        const num = parseFloat(value);
         if (isNaN(num)) {
-            throw new ParseError("Unexpected NaN when parsing number from \"".concat(originalValue, "\""));
+            throw new ParseError(`Unexpected NaN when parsing number from "${originalValue}"`);
         }
         return num;
     }
@@ -589,7 +508,7 @@
      * @see `documentationUrl` for more details
      * @public exported from `@promptbook/editable`
      */
-    var expectCommandParser = {
+    const expectCommandParser = {
         /**
          * Name of the command
          */
@@ -602,7 +521,10 @@
         /**
          * Description of the FORMAT command
          */
-        description: spaceTrim__default["default"]("\n        Expect command describes the desired output of the task *(after post-processing)*\n        It can set limits for the maximum/minimum length of the output, measured in characters, words, sentences, paragraphs or some other shape of the output.\n    "),
+        description: spaceTrim__default["default"](`
+        Expect command describes the desired output of the task *(after post-processing)*
+        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.
+    `),
         /**
          * Link to documentation
          */
@@ -620,12 +542,11 @@
         /**
          * Parses the FORMAT command
          */
-        parse: function (input) {
-            var e_1, _a;
-            var args = input.args;
+        parse(input) {
+            const { args } = input;
             try {
-                var sign = void 0;
-                var signRaw = args.shift();
+                let sign;
+                const signRaw = args.shift();
                 if (/^exact/i.test(signRaw)) {
                     sign = 'EXACTLY';
                 }
@@ -636,59 +557,50 @@
                     sign = 'MAXIMUM';
                 }
                 else {
-                    throw new ParseError("Invalid sign \"".concat(signRaw, "\", expected EXACTLY, MIN or MAX"));
+                    throw new ParseError(`Invalid sign "${signRaw}", expected EXACTLY, MIN or MAX`);
                 }
-                var amountRaw = args.shift();
-                var amount = parseNumber(amountRaw);
+                const amountRaw = args.shift();
+                const 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 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;
-                        }
+                const unitRaw = args.shift();
+                let unit = undefined;
+                for (const existingUnit of EXPECTATION_UNITS) {
+                    let existingUnitText = existingUnit;
+                    existingUnitText = existingUnitText.substring(0, existingUnitText.length - 1);
+                    if (existingUnitText === 'CHARACTER') {
+                        existingUnitText = 'CHAR';
                     }
-                }
-                catch (e_1_1) { e_1 = { error: e_1_1 }; }
-                finally {
-                    try {
-                        if (EXPECTATION_UNITS_1_1 && !EXPECTATION_UNITS_1_1.done && (_a = EXPECTATION_UNITS_1.return)) _a.call(EXPECTATION_UNITS_1);
+                    if (new RegExp(`^${existingUnitText.toLowerCase()}`).test(unitRaw.toLowerCase()) ||
+                        new RegExp(`^${unitRaw.toLowerCase()}`).test(existingUnitText.toLowerCase())) {
+                        if (unit !== undefined) {
+                            throw new ParseError(`Ambiguous unit "${unitRaw}"`);
+                        }
+                        unit = existingUnit;
                     }
-                    finally { if (e_1) throw e_1.error; }
                 }
                 if (unit === undefined) {
-                    throw new ParseError("Invalid unit \"".concat(unitRaw, "\""));
+                    throw new ParseError(`Invalid unit "${unitRaw}"`);
                 }
                 return {
                     type: 'EXPECT',
-                    sign: sign,
-                    unit: unit,
-                    amount: amount,
+                    sign,
+                    unit,
+                    amount,
                 };
             }
             catch (error) {
                 if (!(error instanceof Error)) {
                     throw error;
                 }
-                throw new ParseError(spaceTrim__default["default"](function (block) {
-                    return "\n                            Invalid FORMAT command\n                            ".concat(block(error.message), ":\n                        ");
-                }));
+                throw new ParseError(spaceTrim__default["default"]((block) => `
+                            Invalid FORMAT command
+                            ${block(error.message)}:
+                        `));
             }
         },
         /**
@@ -696,20 +608,20 @@
          *
          * Note: `$` is used to indicate that this function mutates given `taskJson`
          */
-        $applyToTaskJson: function (command, $taskJson) {
+        $applyToTaskJson(command, $taskJson) {
             // eslint-disable-next-line no-case-declarations
-            var unit = command.unit.toLowerCase();
+            const 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));
+                    throw new ParseError(`Already defined minumum ${$taskJson.expectations[unit].min} ${command.unit.toLowerCase()}, now trying to redefine it to ${command.amount}`);
                 }
                 $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));
+                    throw new ParseError(`Already defined maximum ${$taskJson.expectations[unit].max} ${command.unit.toLowerCase()}, now trying to redefine it to ${command.amount}`);
                 }
                 $taskJson.expectations[unit].max = command.amount;
             }
@@ -719,16 +631,16 @@
          *
          * Note: This is used in `pipelineJsonToString` utility
          */
-        stringify: function (command) {
-            return "---"; // <- TODO: [🛋] Implement
+        stringify(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
+        takeFromTaskJson($taskJson) {
+            throw new NotYetImplementedError(`[🛋] Not implemented yet`); // <- TODO: [🛋] Implement
         },
     };
 
@@ -740,40 +652,34 @@
      *
      * @public exported from `@promptbook/core`
      */
-    var AbstractFormatError = /** @class */ (function (_super) {
-        __extends(AbstractFormatError, _super);
+    class AbstractFormatError extends Error {
         // 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;
+        constructor(message) {
+            super(message);
+            Object.setPrototypeOf(this, AbstractFormatError.prototype);
         }
-        return AbstractFormatError;
-    }(Error));
+    }
 
     /**
      * 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;
+    class CsvFormatError extends AbstractFormatError {
+        constructor(message) {
+            super(message);
+            this.name = 'CsvFormatError';
+            Object.setPrototypeOf(this, CsvFormatError.prototype);
         }
-        return CsvFormatError;
-    }(AbstractFormatError));
+    }
 
     /**
      * @@@
      *
      * @public exported from `@promptbook/core`
      */
-    var MANDATORY_CSV_SETTINGS = Object.freeze({
+    const MANDATORY_CSV_SETTINGS = Object.freeze({
         header: true,
         // encoding: 'utf-8',
     });
@@ -784,92 +690,76 @@
      * @public exported from `@promptbook/core`
      *                          <- TODO: [🏢] Export from package `@promptbook/csv`
      */
-    var CsvFormatDefinition = {
+    const CsvFormatDefinition = {
         formatName: 'CSV',
         aliases: ['SPREADSHEET', 'TABLE'],
-        isValid: function (value, settings, schema) {
+        isValid(value, settings, schema) {
             return true;
         },
-        canBeValid: function (partialValue, settings, schema) {
+        canBeValid(partialValue, settings, schema) {
             return true;
         },
-        heal: function (value, settings, schema) {
+        heal(value, settings, schema) {
             throw new Error('Not implemented');
         },
         subvalueDefinitions: [
             {
                 subvalueName: 'ROW',
-                mapValues: function (value, outputParameterName, settings, mapCallback) {
-                    return __awaiter(this, void 0, void 0, function () {
-                        var csv, mappedData;
-                        var _this = this;
-                        return __generator(this, function (_a) {
-                            switch (_a.label) {
-                                case 0:
-                                    csv = papaparse.parse(value, __assign(__assign({}, settings), MANDATORY_CSV_SETTINGS));
-                                    if (csv.errors.length !== 0) {
-                                        throw new CsvFormatError(spaceTrim__default["default"](function (block) { return "\n                                CSV parsing error\n\n                                Error(s) from CSV parsing:\n                                ".concat(block(csv.errors.map(function (error) { return error.message; }).join('\n\n')), "\n\n                                The CSV setings:\n                                ").concat(block(JSON.stringify(__assign(__assign({}, settings), MANDATORY_CSV_SETTINGS), null, 2)), "\n\n                                The CSV data:\n                                ").concat(block(value), "\n                            "); }));
-                                    }
-                                    return [4 /*yield*/, Promise.all(csv.data.map(function (row, index) { return __awaiter(_this, void 0, void 0, function () {
-                                            var _a, _b;
-                                            var _c;
-                                            return __generator(this, function (_d) {
-                                                switch (_d.label) {
-                                                    case 0:
-                                                        if (row[outputParameterName]) {
-                                                            throw new CsvFormatError("Can not overwrite existing column \"".concat(outputParameterName, "\" in CSV row"));
-                                                        }
-                                                        _a = [__assign({}, row)];
-                                                        _c = {};
-                                                        _b = outputParameterName;
-                                                        return [4 /*yield*/, mapCallback(row, index)];
-                                                    case 1: return [2 /*return*/, __assign.apply(void 0, _a.concat([(_c[_b] = _d.sent(), _c)]))];
-                                                }
-                                            });
-                                        }); }))];
-                                case 1:
-                                    mappedData = _a.sent();
-                                    return [2 /*return*/, papaparse.unparse(mappedData, __assign(__assign({}, settings), MANDATORY_CSV_SETTINGS))];
-                            }
-                        });
-                    });
+                async mapValues(value, outputParameterName, settings, mapCallback) {
+                    // TODO: [👨🏾‍🤝‍👨🏼] DRY csv parsing
+                    const csv = papaparse.parse(value, { ...settings, ...MANDATORY_CSV_SETTINGS });
+                    if (csv.errors.length !== 0) {
+                        throw new CsvFormatError(spaceTrim__default["default"]((block) => `
+                                CSV parsing error
+
+                                Error(s) from CSV parsing:
+                                ${block(csv.errors.map((error) => error.message).join('\n\n'))}
+
+                                The CSV setings:
+                                ${block(JSON.stringify({ ...settings, ...MANDATORY_CSV_SETTINGS }, null, 2))}
+
+                                The CSV data:
+                                ${block(value)}
+                            `));
+                    }
+                    const mappedData = await Promise.all(csv.data.map(async (row, index) => {
+                        if (row[outputParameterName]) {
+                            throw new CsvFormatError(`Can not overwrite existing column "${outputParameterName}" in CSV row`);
+                        }
+                        return {
+                            ...row,
+                            [outputParameterName]: await mapCallback(row, index),
+                        };
+                    }));
+                    return papaparse.unparse(mappedData, { ...settings, ...MANDATORY_CSV_SETTINGS });
                 },
             },
             {
                 subvalueName: 'CELL',
-                mapValues: function (value, outputParameterName, settings, mapCallback) {
-                    return __awaiter(this, void 0, void 0, function () {
-                        var csv, mappedData;
-                        var _this = this;
-                        return __generator(this, function (_a) {
-                            switch (_a.label) {
-                                case 0:
-                                    csv = papaparse.parse(value, __assign(__assign({}, settings), MANDATORY_CSV_SETTINGS));
-                                    if (csv.errors.length !== 0) {
-                                        throw new CsvFormatError(spaceTrim__default["default"](function (block) { return "\n                                CSV parsing error\n\n                                Error(s) from CSV parsing:\n                                ".concat(block(csv.errors.map(function (error) { return error.message; }).join('\n\n')), "\n\n                                The CSV setings:\n                                ").concat(block(JSON.stringify(__assign(__assign({}, settings), MANDATORY_CSV_SETTINGS), null, 2)), "\n\n                                The CSV data:\n                                ").concat(block(value), "\n                            "); }));
-                                    }
-                                    return [4 /*yield*/, Promise.all(csv.data.map(function (row, rowIndex) { return __awaiter(_this, void 0, void 0, function () {
-                                            var _this = this;
-                                            return __generator(this, function (_a) {
-                                                return [2 /*return*/, /* not await */ Promise.all(Object.entries(row).map(function (_a, columnIndex) {
-                                                        var _b = __read(_a, 2), key = _b[0], value = _b[1];
-                                                        return __awaiter(_this, void 0, void 0, function () {
-                                                            var index;
-                                                            var _c;
-                                                            return __generator(this, function (_d) {
-                                                                index = rowIndex * Object.keys(row).length + columnIndex;
-                                                                return [2 /*return*/, /* not await */ mapCallback((_c = {}, _c[key] = value, _c), index)];
-                                                            });
-                                                        });
-                                                    }))];
-                                            });
-                                        }); }))];
-                                case 1:
-                                    mappedData = _a.sent();
-                                    return [2 /*return*/, papaparse.unparse(mappedData, __assign(__assign({}, settings), MANDATORY_CSV_SETTINGS))];
-                            }
-                        });
-                    });
+                async mapValues(value, outputParameterName, settings, mapCallback) {
+                    // TODO: [👨🏾‍🤝‍👨🏼] DRY csv parsing
+                    const csv = papaparse.parse(value, { ...settings, ...MANDATORY_CSV_SETTINGS });
+                    if (csv.errors.length !== 0) {
+                        throw new CsvFormatError(spaceTrim__default["default"]((block) => `
+                                CSV parsing error
+
+                                Error(s) from CSV parsing:
+                                ${block(csv.errors.map((error) => error.message).join('\n\n'))}
+
+                                The CSV setings:
+                                ${block(JSON.stringify({ ...settings, ...MANDATORY_CSV_SETTINGS }, null, 2))}
+
+                                The CSV data:
+                                ${block(value)}
+                            `));
+                    }
+                    const mappedData = await Promise.all(csv.data.map(async (row, rowIndex) => {
+                        return /* not await */ Promise.all(Object.entries(row).map(async ([key, value], columnIndex) => {
+                            const index = rowIndex * Object.keys(row).length + columnIndex;
+                            return /* not await */ mapCallback({ [key]: value }, index);
+                        }));
+                    }));
+                    return papaparse.unparse(mappedData, { ...settings, ...MANDATORY_CSV_SETTINGS });
                 },
             },
         ],
@@ -908,16 +798,16 @@
      *
      * @private still in development [🏢]
      */
-    var JsonFormatDefinition = {
+    const JsonFormatDefinition = {
         formatName: 'JSON',
         mimeType: 'application/json',
-        isValid: function (value, settings, schema) {
+        isValid(value, settings, schema) {
             return isValidJsonString(value);
         },
-        canBeValid: function (partialValue, settings, schema) {
+        canBeValid(partialValue, settings, schema) {
             return true;
         },
-        heal: function (value, settings, schema) {
+        heal(value, settings, schema) {
             throw new Error('Not implemented');
         },
         subvalueDefinitions: [],
@@ -941,48 +831,37 @@
      *
      * @public exported from `@promptbook/core`
      */
-    var TextFormatDefinition = {
+    const TextFormatDefinition = {
         formatName: 'TEXT',
-        isValid: function (value) {
+        isValid(value) {
             return typeof value === 'string';
         },
-        canBeValid: function (partialValue) {
+        canBeValid(partialValue) {
             return typeof partialValue === 'string';
         },
-        heal: function () {
+        heal() {
             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')];
-                            }
-                        });
-                    });
+                async mapValues(value, outputParameterName, settings, mapCallback) {
+                    const lines = value.split('\n');
+                    const mappedLines = await Promise.all(lines.map((lineContent, lineNumber) => 
+                    // TODO: [🧠] Maybe option to skip empty line
+                    /* not await */ mapCallback({
+                        lineContent,
+                        // TODO: [🧠] Maybe also put here `lineNumber`
+                    }, lineNumber)));
+                    return mappedLines.join('\n');
                 },
             },
-            // <- TODO: [🧠][🤠] Here should be all words, characters, lines, paragraphs, pages aviable as subvalues
+            // <- TODO: [🧠][🤠] Here should be all words, characters, lines, paragraphs, pages available as subvalues
         ],
     };
     /**
      * TODO: [1] Make type for XML Text and Schema
-     * TODO: [🧠][🤠] Here should be all words, characters, lines, paragraphs, pages aviable as subvalues
+     * TODO: [🧠][🤠] Here should be all words, characters, lines, paragraphs, pages available as subvalues
      * TODO: [🍓] In `TextFormatDefinition` implement simple `isValid`
      * TODO: [🍓] In `TextFormatDefinition` implement partial `canBeValid`
      * TODO: [🍓] In `TextFormatDefinition` implement `heal
@@ -995,16 +874,16 @@
      *
      * @private still in development [🏢]
      */
-    var XmlFormatDefinition = {
+    const XmlFormatDefinition = {
         formatName: 'XML',
         mimeType: 'application/xml',
-        isValid: function (value, settings, schema) {
+        isValid(value, settings, schema) {
             return true;
         },
-        canBeValid: function (partialValue, settings, schema) {
+        canBeValid(partialValue, settings, schema) {
             return true;
         },
-        heal: function (value, settings, schema) {
+        heal(value, settings, schema) {
             throw new Error('Not implemented');
         },
         subvalueDefinitions: [],
@@ -1026,7 +905,7 @@
      *
      * @private internal index of `...` <- TODO [🏢]
      */
-    var FORMAT_DEFINITIONS = [
+    const FORMAT_DEFINITIONS = [
         JsonFormatDefinition,
         XmlFormatDefinition,
         TextFormatDefinition,
@@ -1046,46 +925,35 @@
      * @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;
+        let charType;
+        let lastCharType = 'OTHER';
+        let normalizedName = '';
+        for (const char of text) {
+            let normalizedChar;
+            if (/^[a-z]$/.test(char)) {
+                charType = 'LOWERCASE';
+                normalizedChar = char.toUpperCase();
             }
-        }
-        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);
+            else if (/^[A-Z]$/.test(char)) {
+                charType = 'UPPERCASE';
+                normalizedChar = char;
             }
-            finally { if (e_1) throw e_1.error; }
+            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;
         }
         normalizedName = normalizedName.replace(/_+/g, '_');
         normalizedName = normalizedName.replace(/_?\/_?/g, '/');
@@ -1109,8 +977,11 @@
      * @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);
+        const { value, order } = options;
+        const orderedValue = {
+            ...(order === undefined ? {} : Object.fromEntries(order.map((key) => [key, undefined]))),
+            ...value,
+        };
         return orderedValue;
     }
 
@@ -1124,26 +995,15 @@
      * @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); }));
+            return Object.freeze(objectValue.map((item) => $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);
+        const propertyNames = Object.getOwnPropertyNames(objectValue);
+        for (const propertyName of propertyNames) {
+            const value = objectValue[propertyName];
+            if (value && typeof value === 'object') {
+                $deepFreeze(value);
             }
-            finally { if (e_1) throw e_1.error; }
         }
         Object.freeze(objectValue);
         return objectValue;
@@ -1173,10 +1033,9 @@
      * @public exported from `@promptbook/utils`
      */
     function checkSerializableAsJson(options) {
-        var e_1, _a;
-        var value = options.value, name = options.name, message = options.message;
+        const { value, name, message } = options;
         if (value === undefined) {
-            throw new UnexpectedError("".concat(name, " is undefined"));
+            throw new UnexpectedError(`${name} is undefined`);
         }
         else if (value === null) {
             return;
@@ -1191,49 +1050,54 @@
             return;
         }
         else if (typeof value === 'symbol') {
-            throw new UnexpectedError("".concat(name, " is symbol"));
+            throw new UnexpectedError(`${name} is symbol`);
         }
         else if (typeof value === 'function') {
-            throw new UnexpectedError("".concat(name, " is function"));
+            throw new UnexpectedError(`${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 });
+            for (let i = 0; i < value.length; i++) {
+                checkSerializableAsJson({ name: `${name}[${i}]`, value: value[i], message });
             }
         }
         else if (typeof value === 'object') {
             if (value instanceof Date) {
-                throw new UnexpectedError(spaceTrim__default["default"](function (block) { return "\n                        `".concat(name, "` is Date\n\n                        Use `string_date_iso8601` instead\n\n                        Additional message for `").concat(name, "`:\n                        ").concat(block(message || '(nothing)'), "\n                    "); }));
+                throw new UnexpectedError(spaceTrim__default["default"]((block) => `
+                        \`${name}\` is Date
+
+                        Use \`string_date_iso8601\` instead
+
+                        Additional message for \`${name}\`:
+                        ${block(message || '(nothing)')}
+                    `));
             }
             else if (value instanceof Map) {
-                throw new UnexpectedError("".concat(name, " is Map"));
+                throw new UnexpectedError(`${name} is Map`);
             }
             else if (value instanceof Set) {
-                throw new UnexpectedError("".concat(name, " is Set"));
+                throw new UnexpectedError(`${name} is Set`);
             }
             else if (value instanceof RegExp) {
-                throw new UnexpectedError("".concat(name, " is RegExp"));
+                throw new UnexpectedError(`${name} is RegExp`);
             }
             else if (value instanceof Error) {
-                throw new UnexpectedError(spaceTrim__default["default"](function (block) { return "\n                        `".concat(name, "` is unserialized Error\n\n                        Use function `serializeError`\n\n                        Additional message for `").concat(name, "`:\n                        ").concat(block(message || '(nothing)'), "\n\n                    "); }));
+                throw new UnexpectedError(spaceTrim__default["default"]((block) => `
+                        \`${name}\` is unserialized Error
+
+                        Use function \`serializeError\`
+
+                        Additional message for \`${name}\`:
+                        ${block(message || '(nothing)')}
+
+                    `));
             }
             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 });
+                for (const [subName, subValue] of Object.entries(value)) {
+                    if (subValue === undefined) {
+                        // Note: undefined in object is serializable - it is just omited
+                        continue;
                     }
-                }
-                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; }
+                    checkSerializableAsJson({ name: `${name}.${subName}`, value: subValue, message });
                 }
                 try {
                     JSON.stringify(value); // <- TODO: [0]
@@ -1242,7 +1106,14 @@
                     if (!(error instanceof Error)) {
                         throw error;
                     }
-                    throw new UnexpectedError(spaceTrim__default["default"](function (block) { return "\n                            `".concat(name, "` is not serializable\n\n                            ").concat(block(error.stack || error.message), "\n\n                            Additional message for `").concat(name, "`:\n                            ").concat(block(message || '(nothing)'), "\n                        "); }));
+                    throw new UnexpectedError(spaceTrim__default["default"]((block) => `
+                            \`${name}\` is not serializable
+
+                            ${block(error.stack || error.message)}
+
+                            Additional message for \`${name}\`:
+                            ${block(message || '(nothing)')}
+                        `));
                 }
                 /*
                 TODO: [0] Is there some more elegant way to check circular references?
@@ -1267,7 +1138,12 @@
             }
         }
         else {
-            throw new UnexpectedError(spaceTrim__default["default"](function (block) { return "\n                    `".concat(name, "` is unknown type\n\n                    Additional message for `").concat(name, "`:\n                    ").concat(block(message || '(nothing)'), "\n                "); }));
+            throw new UnexpectedError(spaceTrim__default["default"]((block) => `
+                    \`${name}\` is unknown type
+
+                    Additional message for \`${name}\`:
+                    ${block(message || '(nothing)')}
+                `));
         }
     }
     /**
@@ -1313,9 +1189,9 @@
      * @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 = 
+        const { name, value, order, message } = options;
+        checkSerializableAsJson({ name, value, message });
+        const orderedValue = 
         // TODO: Fix error "Type instantiation is excessively deep and possibly infinite."
         // eslint-disable-next-line @typescript-eslint/ban-ts-comment
         // @ts-ignore
@@ -1338,15 +1214,15 @@
      *
      * @private within the repository
      */
-    var REPLACING_NONCE = 'ptbkauk42kV2dzao34faw7FudQUHYPtW';
+    const REPLACING_NONCE = 'ptbkauk42kV2dzao34faw7FudQUHYPtW';
     /**
      * The names of the parameters that are reserved for special purposes
      *
      * @public exported from `@promptbook/core`
      */
-    var RESERVED_PARAMETER_NAMES = exportJson({
+    const RESERVED_PARAMETER_NAMES = exportJson({
         name: 'RESERVED_PARAMETER_NAMES',
-        message: "The names of the parameters that are reserved for special purposes",
+        message: `The names of the parameters that are reserved for special purposes`,
         value: [
             'content',
             'context',
@@ -1373,53 +1249,41 @@
      * @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
+    function normalizeTo_camelCase(text, _isFirstLetterCapital = false) {
+        let charType;
+        let lastCharType = null;
+        let normalizedName = '';
+        for (const char of text) {
+            let normalizedChar;
+            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
                 }
-                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);
+            else if (charType !== lastCharType &&
+                !(charType === 'LOWERCASE' && lastCharType === 'UPPERCASE') &&
+                !(lastCharType === 'NUMBER') &&
+                !(charType === 'NUMBER')) {
+                normalizedChar = normalizedChar.toUpperCase(); //TODO: [🌺] DRY
             }
-            finally { if (e_1) throw e_1.error; }
+            normalizedName += normalizedChar;
+            lastCharType = charType;
         }
         return normalizedName;
     }
@@ -1427,7 +1291,7 @@
      * TODO: [🌺] Use some intermediate util splitWords
      */
 
-    var defaultDiacriticsRemovalMap = [
+    const 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',
@@ -1646,12 +1510,12 @@
      *
      * @public exported from `@promptbook/utils`
      */
-    var DIACRITIC_VARIANTS_LETTERS = {};
+    const DIACRITIC_VARIANTS_LETTERS = {};
     // tslint:disable-next-line: prefer-for-of
-    for (var i = 0; i < defaultDiacriticsRemovalMap.length; i++) {
-        var letters = defaultDiacriticsRemovalMap[i].letters;
+    for (let i = 0; i < defaultDiacriticsRemovalMap.length; i++) {
+        const letters = defaultDiacriticsRemovalMap[i].letters;
         // tslint:disable-next-line: prefer-for-of
-        for (var j = 0; j < letters.length; j++) {
+        for (let j = 0; j < letters.length; j++) {
             DIACRITIC_VARIANTS_LETTERS[letters[j]] = defaultDiacriticsRemovalMap[i].base;
         }
     }
@@ -1680,7 +1544,7 @@
      */
     function removeDiacritics(input) {
         /*eslint no-control-regex: "off"*/
-        return input.replace(/[^\u0000-\u007E]/g, function (a) {
+        return input.replace(/[^\u0000-\u007E]/g, (a) => {
             return DIACRITIC_VARIANTS_LETTERS[a] || a;
         });
     }
@@ -1736,33 +1600,22 @@
      * @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
+        const rawParameterName = parameterName;
+        for (const [start, end] of [
+            ['`', '`'],
+            ['{', '}'],
+            ['[', ']'],
+            ['(', ')'],
+            ['<', '>'],
+        ]) {
+            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
-                ) {
-                    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 {
             /*
@@ -1772,10 +1625,10 @@
             }
             */
             if (parameterName.includes('.')) {
-                throw new ParseError("Parameter name cannot contain dots");
+                throw new ParseError(`Parameter name cannot contain dots`);
             }
             if (parameterName.includes('/') || parameterName.includes('\\')) {
-                throw new ParseError("Parameter name cannot contain slashes");
+                throw new ParseError(`Parameter name cannot contain slashes`);
             }
             if (parameterName.includes('(') ||
                 parameterName.includes(')') ||
@@ -1783,24 +1636,29 @@
                 parameterName.includes('}') ||
                 parameterName.includes('[') ||
                 parameterName.includes(']')) {
-                throw new ParseError("Parameter name cannot contain braces");
+                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");
+                throw new ParseError(`Parameter name cannot be empty`);
             }
             if (RESERVED_PARAMETER_NAMES.includes(parameterName)) {
-                throw new ParseError("{".concat(parameterName, "} is a reserved parameter name"));
+                throw new ParseError(`{${parameterName}} is a reserved parameter name`);
             }
         }
         catch (error) {
             if (!(error instanceof ParseError)) {
                 throw error;
             }
-            throw new ParseError(spaceTrim__default["default"](function (block) { return "\n                    ".concat(block(error.message), "\n\n                    Tried to validate parameter name:\n                    ").concat(block(rawParameterName), "\n                "); }));
+            throw new ParseError(spaceTrim__default["default"]((block) => `
+                    ${block(error.message)}
+
+                    Tried to validate parameter name:
+                    ${block(rawParameterName)}
+                `));
         }
         return parameterName;
     }
@@ -1813,7 +1671,7 @@
      * @see `documentationUrl` for more details
      * @public exported from `@promptbook/editable`
      */
-    var foreachCommandParser = {
+    const foreachCommandParser = {
         /**
          * Name of the command
          */
@@ -1830,7 +1688,7 @@
         /**
          * Description of the FOREACH command
          */
-        description: "@@",
+        description: `@@`,
         /**
          * Link to documentation
          */
@@ -1848,58 +1706,64 @@
         /**
          * 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);
-            });
+        parse(input) {
+            const { args } = input;
+            const formatName = normalizeTo_SCREAMING_CASE(args[0] || '');
+            const subformatName = normalizeTo_SCREAMING_CASE(args[1] || '');
+            const parameterNameArg = args[2] || '';
+            const assignSign = args[3];
+            const formatDefinition = FORMAT_DEFINITIONS.find((formatDefinition) => [formatDefinition.formatName, ...(formatDefinition.aliases || [])].includes(formatName));
             if (formatDefinition === undefined) {
-                throw new ParseError(spaceTrim__default["default"](function (block) { return "\n                        Unsupported format \"".concat(formatName, "\"\n\n                        Available formats:\n                        ").concat(block(FORMAT_DEFINITIONS.map(function (formatDefinition) { return formatDefinition.formatName; })
-                    .map(function (formatName) { return "- ".concat(formatName); })
-                    .join('\n')), "\n                    "); }));
+                throw new ParseError(spaceTrim__default["default"]((block) => `
+                        Unsupported format "${formatName}"
+
+                        Available formats:
+                        ${block(FORMAT_DEFINITIONS.map((formatDefinition) => formatDefinition.formatName)
+                .map((formatName) => `- ${formatName}`)
+                .join('\n'))}
+                    `));
                 // <- TODO: [🏢] List all supported format names
             }
-            var subvalueDefinition = formatDefinition.subvalueDefinitions.find(function (subvalueDefinition) {
-                return __spreadArray([subvalueDefinition.subvalueName], __read((subvalueDefinition.aliases || [])), false).includes(subformatName);
-            });
+            const subvalueDefinition = formatDefinition.subvalueDefinitions.find((subvalueDefinition) => [subvalueDefinition.subvalueName, ...(subvalueDefinition.aliases || [])].includes(subformatName));
             if (subvalueDefinition === undefined) {
-                throw new ParseError(spaceTrim__default["default"](function (block) { return "\n                        Unsupported subformat name \"".concat(subformatName, "\" for format \"").concat(formatName, "\"\n\n                        Available subformat names for format \"").concat(formatDefinition.formatName, "\":\n                        ").concat(block(formatDefinition.subvalueDefinitions
-                    .map(function (subvalueDefinition) { return subvalueDefinition.subvalueName; })
-                    .map(function (subvalueName) { return "- ".concat(subvalueName); })
-                    .join('\n')), "\n                    "); }));
+                throw new ParseError(spaceTrim__default["default"]((block) => `
+                        Unsupported subformat name "${subformatName}" for format "${formatName}"
+
+                        Available subformat names for format "${formatDefinition.formatName}":
+                        ${block(formatDefinition.subvalueDefinitions
+                .map((subvalueDefinition) => subvalueDefinition.subvalueName)
+                .map((subvalueName) => `- ${subvalueName}`)
+                .join('\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");
+                throw new ParseError(`FOREACH command must have '->' to assign the value to the parameter`);
             }
-            var parameterName = validateParameterName(parameterNameArg);
-            var outputSubparameterName = null;
+            const parameterName = validateParameterName(parameterNameArg);
+            let outputSubparameterName = null;
             // TODO: [4] DRY
-            var inputSubparameterNames = args
+            const inputSubparameterNames = args
                 .slice(4)
-                .map(function (parameterName) { return parameterName.split(',').join(' ').trim(); })
-                .filter(function (parameterName) { return !parameterName.includes('+'); })
-                .filter(function (parameterName) { return parameterName !== ''; })
+                .map((parameterName) => parameterName.split(',').join(' ').trim())
+                .filter((parameterName) => !parameterName.includes('+'))
+                .filter((parameterName) => parameterName !== '')
                 .map(validateParameterName);
             // TODO: [4] DRY
-            var outputSubparameterNames = args
+            const 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((parameterName) => parameterName.split(',').join(' ').trim())
+                .filter((parameterName) => parameterName.includes('+'))
+                .map((parameterName) => 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");
+                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");
+                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
@@ -1910,16 +1774,22 @@
                     outputSubparameterName = 'newLine';
                 }
                 else {
-                    throw new ParseError(spaceTrim__default["default"]("\n                        FOREACH ".concat(formatName, " ").concat(subformatName, " must specify output subparameter\n\n                        Correct example:\n                        - FOREACH ").concat(formatName, " ").concat(subformatName, " {").concat(parameterName, "} -> {inputSubparameterName1}, {inputSubparameterName2}, +{outputSubparameterName}\n\n                    ")));
+                    throw new ParseError(spaceTrim__default["default"](`
+                        FOREACH ${formatName} ${subformatName} must specify output subparameter
+
+                        Correct example:
+                        - FOREACH ${formatName} ${subformatName} {${parameterName}} -> {inputSubparameterName1}, {inputSubparameterName2}, +{outputSubparameterName}
+
+                    `));
                 }
             }
             return {
                 type: 'FOREACH',
-                formatName: formatName,
-                subformatName: subformatName,
-                parameterName: parameterName,
-                inputSubparameterNames: inputSubparameterNames,
-                outputSubparameterName: outputSubparameterName,
+                formatName,
+                subformatName,
+                parameterName,
+                inputSubparameterNames,
+                outputSubparameterName,
             };
         },
         /**
@@ -1927,16 +1797,16 @@
          *
          * 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;
+        $applyToTaskJson(command, $taskJson, $pipelineJson) {
+            const { formatName, subformatName, parameterName, inputSubparameterNames, outputSubparameterName } = command;
             // 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,
+                formatName,
+                subformatName,
+                parameterName,
+                inputSubparameterNames,
+                outputSubparameterName,
             };
             // Note: [🍭] FOREACH apply has some sideeffects on different places in codebase
         },
@@ -1945,16 +1815,16 @@
          *
          * Note: This is used in `pipelineJsonToString` utility
          */
-        stringify: function (command) {
-            return "---"; // <- TODO: [🛋] Implement
+        stringify(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
+        takeFromTaskJson($taskJson) {
+            throw new NotYetImplementedError(`[🛋] Not implemented yet`); // <- TODO: [🛋] Implement
         },
     };
     /**
@@ -1967,7 +1837,7 @@
      * @see `documentationUrl` for more details
      * @public exported from `@promptbook/editable`
      */
-    var formatCommandParser = {
+    const formatCommandParser = {
         /**
          * Name of the command
          */
@@ -1980,7 +1850,10 @@
         /**
          * Description of the FORMAT command
          */
-        description: spaceTrim__default["default"]("\n        Format command describes the desired output of the task (after post-processing)\n        It can set limits for the maximum/minimum length of the output, measured in characters, words, sentences, paragraphs or some other shape of the output.\n    "),
+        description: spaceTrim__default["default"](`
+        Format command describes the desired output of the task (after post-processing)
+        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.
+    `),
         /**
          * Link to documentation
          */
@@ -1992,10 +1865,10 @@
         /**
          * Parses the FORMAT command
          */
-        parse: function (input) {
-            var normalized = input.normalized;
+        parse(input) {
+            const { normalized } = input;
             if (!normalized.startsWith('FORMAT_JSON')) {
-                throw new ParseError("For now only JSON format is supported, in future we will support more formats");
+                throw new ParseError(`For now only JSON format is supported, in future we will support more formats`);
             }
             return {
                 type: 'FORMAT',
@@ -2009,9 +1882,10 @@
          *
          * Note: `$` is used to indicate that this function mutates given `taskJson`
          */
-        $applyToTaskJson: function (command, $taskJson) {
+        $applyToTaskJson(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, "\""));
+                throw new ParseError(`Format format is already defined to "${$taskJson.format}".
+                Now you try to redefine it by "${command.format}"`);
             }
             $taskJson.format = command.format;
         },
@@ -2020,16 +1894,16 @@
          *
          * Note: This is used in `pipelineJsonToString` utility
          */
-        stringify: function (command) {
-            return "---"; // <- TODO: [🛋] Implement
+        stringify(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
+        takeFromTaskJson($taskJson) {
+            throw new NotYetImplementedError(`[🛋] Not implemented yet`); // <- TODO: [🛋] Implement
         },
     };
 
@@ -2038,31 +1912,31 @@
      *
      * @public exported from `@promptbook/core`
      */
-    var ChatbotFormfactorDefinition = {
+    const ChatbotFormfactorDefinition = {
         name: 'CHATBOT',
         aliasNames: ['CHAT'],
-        description: "@@@",
-        documentationUrl: "https://github.com/webgptorg/promptbook/discussions/174",
+        description: `@@@`,
+        documentationUrl: `https://github.com/webgptorg/promptbook/discussions/174`,
         pipelineInterface: {
             inputParameters: [
                 {
                     name: 'previousTitle',
-                    description: "Previous title of the conversation",
+                    description: `Previous title of the conversation`,
                     isInput: true,
                     isOutput: false,
                 },
                 {
                     name: 'previousConversationSummary',
-                    description: "Previous conversation summary",
+                    description: `Previous conversation summary`,
                     isInput: true,
                     isOutput: false,
                 },
-                { name: 'userMessage', description: "User message", 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 },
+                { 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 },
             ],
         },
     };
@@ -2072,15 +1946,15 @@
      *
      * @public exported from `@promptbook/core`
      */
-    var GeneratorFormfactorDefinition = {
+    const 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",
+        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",
+                    description: `Input message to be image made from`,
                     isInput: true,
                     isOutput: false,
                 },
@@ -2088,7 +1962,7 @@
             outputParameters: [
                 {
                     name: 'result',
-                    description: "Result in HTML to be shown to user",
+                    description: `Result in HTML to be shown to user`,
                     isInput: false,
                     isOutput: true,
                 },
@@ -2103,7 +1977,7 @@
      *
      * @public exported from `@promptbook/core`
      */
-    var GENERIC_PIPELINE_INTERFACE = {
+    const GENERIC_PIPELINE_INTERFACE = {
         inputParameters: [],
         outputParameters: [],
     };
@@ -2116,10 +1990,10 @@
      *
      * @public exported from `@promptbook/core`
      */
-    var GenericFormfactorDefinition = {
+    const GenericFormfactorDefinition = {
         name: 'GENERIC',
-        description: "@@@",
-        documentationUrl: "https://github.com/webgptorg/promptbook/discussions/173",
+        description: `@@@`,
+        documentationUrl: `https://github.com/webgptorg/promptbook/discussions/173`,
         pipelineInterface: GENERIC_PIPELINE_INTERFACE,
     };
 
@@ -2128,15 +2002,15 @@
      *
      * @public exported from `@promptbook/core`
      */
-    var ImageGeneratorFormfactorDefinition = {
+    const ImageGeneratorFormfactorDefinition = {
         name: 'IMAGE_GENERATOR',
-        description: "Generates prompt for image generation from input message",
-        documentationUrl: "https://github.com/webgptorg/promptbook/discussions/184",
+        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",
+                    description: `Input message to be image made from`,
                     isInput: true,
                     isOutput: false,
                 },
@@ -2144,7 +2018,7 @@
             outputParameters: [
                 {
                     name: 'prompt',
-                    description: "Prompt to be used for image generation",
+                    description: `Prompt to be used for image generation`,
                     isInput: false,
                     isOutput: true,
                 },
@@ -2157,10 +2031,10 @@
      *
      * @public exported from `@promptbook/core`
      */
-    var MatcherFormfactorDefinition = {
+    const MatcherFormfactorDefinition = {
         name: 'EXPERIMENTAL_MATCHER',
-        description: "@@@",
-        documentationUrl: "https://github.com/webgptorg/promptbook/discussions/177",
+        description: `@@@`,
+        documentationUrl: `https://github.com/webgptorg/promptbook/discussions/177`,
         pipelineInterface: {
             inputParameters: [
                 /* @@@ */
@@ -2182,16 +2056,16 @@
      *
      * @public exported from `@promptbook/core`
      */
-    var SheetsFormfactorDefinition = {
+    const SheetsFormfactorDefinition = {
         name: 'SHEETS',
         aliasNames: ['SHEETS', 'SHEET'],
-        description: "@@@",
-        documentationUrl: "https://github.com/webgptorg/promptbook/discussions/176",
+        description: `@@@`,
+        documentationUrl: `https://github.com/webgptorg/promptbook/discussions/176`,
         pipelineInterface: {
             inputParameters: [
                 {
                     name: 'inputSheet',
-                    description: "Input sheet to be processed as csv",
+                    description: `Input sheet to be processed as csv`,
                     isInput: true,
                     isOutput: false,
                 },
@@ -2199,7 +2073,7 @@
             outputParameters: [
                 {
                     name: 'outputSheet',
-                    description: "Output sheet as csv",
+                    description: `Output sheet as csv`,
                     isInput: false,
                     isOutput: true,
                 },
@@ -2212,15 +2086,15 @@
      *
      * @public exported from `@promptbook/core`
      */
-    var TranslatorFormfactorDefinition = {
+    const TranslatorFormfactorDefinition = {
         name: 'TRANSLATOR',
-        description: "@@@",
-        documentationUrl: "https://github.com/webgptorg/promptbook/discussions/175",
+        description: `@@@`,
+        documentationUrl: `https://github.com/webgptorg/promptbook/discussions/175`,
         pipelineInterface: {
             inputParameters: [
                 {
                     name: 'inputMessage',
-                    description: "Input message to be translated",
+                    description: `Input message to be translated`,
                     isInput: true,
                     isOutput: false,
                 },
@@ -2228,7 +2102,7 @@
             outputParameters: [
                 {
                     name: 'outputMessage',
-                    description: "Translated output message",
+                    description: `Translated output message`,
                     isInput: false,
                     isOutput: true,
                 },
@@ -2243,7 +2117,7 @@
      *
      * @public exported from `@promptbook/core`
      */
-    var FORMFACTOR_DEFINITIONS = [
+    const FORMFACTOR_DEFINITIONS = [
         GenericFormfactorDefinition,
         ChatbotFormfactorDefinition,
         TranslatorFormfactorDefinition,
@@ -2264,7 +2138,7 @@
      * @see `documentationUrl` for more details
      * @public exported from `@promptbook/editable`
      */
-    var formfactorCommandParser = {
+    const formfactorCommandParser = {
         /**
          * Name of the command
          */
@@ -2281,7 +2155,7 @@
         /**
          * Description of the FORMFACTOR command
          */
-        description: "@@",
+        description: `@@`,
         /**
          * Link to documentation
          */
@@ -2293,20 +2167,20 @@
         /**
          * Parses the FORMFACTOR command
          */
-        parse: function (input) {
-            var args = input.args;
+        parse(input) {
+            const { args } = input;
             if (args.length !== 1) {
-                throw new ParseError("FORMFACTOR command requires exactly one argument");
+                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);
-            });
+            const formfactorNameCandidate = args[0].toUpperCase();
+            const formfactor = FORMFACTOR_DEFINITIONS.find((definition) => [definition.name, ...{ aliasNames: [], ...definition }.aliasNames].includes(formfactorNameCandidate));
             if (formfactor === undefined) {
-                throw new ParseError(spaceTrim__default["default"](function (block) { return "\n                        Unknown formfactor name \"".concat(formfactorNameCandidate, "\"\n\n                        Available formfactors:\n                        ").concat(block(FORMFACTOR_DEFINITIONS.map(function (_a) {
-                    var name = _a.name;
-                    return "- ".concat(name);
-                }).join('\n')), "\n                    "); }));
+                throw new ParseError(spaceTrim__default["default"]((block) => `
+                        Unknown formfactor name "${formfactorNameCandidate}"
+
+                        Available formfactors:
+                        ${block(FORMFACTOR_DEFINITIONS.map(({ name }) => `- ${name}`).join('\n'))}
+                    `));
             }
             return {
                 type: 'FORMFACTOR',
@@ -2318,9 +2192,15 @@
          *
          * Note: `$` is used to indicate that this function mutates given `pipelineJson`
          */
-        $applyToPipelineJson: function (command, $pipelineJson) {
+        $applyToPipelineJson(command, $pipelineJson) {
             if ($pipelineJson.formfactorName !== undefined && $pipelineJson.formfactorName !== command.formfactorName) {
-                throw new ParseError(spaceTrim__default["default"]("\n                    Redefinition of `FORMFACTOR` in the pipeline head\n\n                    You have used:\n                    1) FORMFACTOR `".concat($pipelineJson.formfactorName, "`\n                    2) FORMFACTOR `").concat(command.formfactorName, "`\n                ")));
+                throw new ParseError(spaceTrim__default["default"](`
+                    Redefinition of \`FORMFACTOR\` in the pipeline head
+
+                    You have used:
+                    1) FORMFACTOR \`${$pipelineJson.formfactorName}\`
+                    2) FORMFACTOR \`${command.formfactorName}\`
+                `));
             }
             $pipelineJson.formfactorName = command.formfactorName;
         },
@@ -2329,15 +2209,15 @@
          *
          * Note: This is used in `pipelineJsonToString` utility
          */
-        stringify: function (command) {
-            return "FORMFACTOR ".concat(command.formfactorName);
+        stringify(command) {
+            return `FORMFACTOR ${command.formfactorName}`;
         },
         /**
          * Reads the FORMFACTOR command from the `PipelineJson`
          *
          * Note: This is used in `pipelineJsonToString` utility
          */
-        takeFromPipelineJson: function (pipelineJson) {
+        takeFromPipelineJson(pipelineJson) {
             return [
                 {
                     type: 'FORMFACTOR',
@@ -2353,7 +2233,7 @@
      * @see `documentationUrl` for more details
      * @public exported from `@promptbook/editable`
      */
-    var jokerCommandParser = {
+    const jokerCommandParser = {
         /**
          * Name of the command
          */
@@ -2366,7 +2246,7 @@
         /**
          * Description of the JOKER command
          */
-        description: "Joker parameter is used instead of executing the task result if jokers value meets the expectations requirements",
+        description: `Joker parameter is used instead of executing the task result if jokers value meets the expectations requirements`,
         /**
          * Link to documentation
          */
@@ -2378,16 +2258,16 @@
         /**
          * Parses the JOKER command
          */
-        parse: function (input) {
-            var args = input.args;
+        parse(input) {
+            const { args } = input;
             if (args.length !== 1) {
-                throw new ParseError("JOKE command expects exactly one parameter name");
+                throw new ParseError(`JOKE command expects exactly one parameter name`);
             }
-            var parameterNameArg = args[0] || '';
-            var parameterName = validateParameterName(parameterNameArg);
+            const parameterNameArg = args[0] || '';
+            const parameterName = validateParameterName(parameterNameArg);
             return {
                 type: 'JOKER',
-                parameterName: parameterName,
+                parameterName,
             };
         },
         /**
@@ -2395,7 +2275,7 @@
          *
          * Note: `$` is used to indicate that this function mutates given `taskJson`
          */
-        $applyToTaskJson: function (command, $taskJson) {
+        $applyToTaskJson(command, $taskJson) {
             $taskJson.jokerParameterNames = $taskJson.jokerParameterNames || [];
             $taskJson.jokerParameterNames.push(command.parameterName);
         },
@@ -2404,16 +2284,16 @@
          *
          * Note: This is used in `pipelineJsonToString` utility
          */
-        stringify: function (command) {
-            return "---"; // <- TODO: [🛋] Implement
+        stringify(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
+        takeFromTaskJson($taskJson) {
+            throw new NotYetImplementedError(`[🛋] Not implemented yet`); // <- TODO: [🛋] Implement
         },
     };
 
@@ -2434,7 +2314,7 @@
             5 /* <- TODO: [🧠][🈷] Make some better non-arbitrary way how to distinct filenames from informational texts */) {
             return false;
         }
-        var filenameSlashes = filename.split('\\').join('/');
+        const filenameSlashes = filename.split('\\').join('/');
         // Absolute Unix path: /hello.txt
         if (/^(\/)/i.test(filenameSlashes)) {
             // console.log(filename, 'Absolute Unix path: /hello.txt');
@@ -2484,7 +2364,7 @@
             if (url.startsWith('blob:')) {
                 url = url.replace(/^blob:/, '');
             }
-            var urlObject = new URL(url /* because fail is handled */);
+            const urlObject = new URL(url /* because fail is handled */);
             if (!['http:', 'https:', 'data:'].includes(urlObject.protocol)) {
                 return false;
             }
@@ -2505,47 +2385,36 @@
      * @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;
+        let charType;
+        let lastCharType = 'OTHER';
+        let normalizedName = '';
+        for (const char of text) {
+            let normalizedChar;
+            if (/^[a-z]$/.test(char)) {
+                charType = 'LOWERCASE';
+                normalizedChar = char;
             }
-        }
-        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);
+            else if (/^[A-Z]$/.test(char)) {
+                charType = 'UPPERCASE';
+                normalizedChar = char.toLowerCase();
+            }
+            else if (/^[0-9]$/.test(char)) {
+                charType = 'NUMBER';
+                normalizedChar = char;
             }
-            finally { if (e_1) throw e_1.error; }
+            else {
+                charType = 'OTHER';
+                normalizedChar = '-';
+            }
+            if (charType !== lastCharType &&
+                !(lastCharType === 'UPPERCASE' && charType === 'LOWERCASE') &&
+                !(lastCharType === 'NUMBER') &&
+                !(charType === 'NUMBER')) {
+                normalizedName += '-';
+            }
+            normalizedName += normalizedChar;
+            lastCharType = charType;
         }
         normalizedName = normalizedName.split(/-+/g).join('-');
         normalizedName = normalizedName.split(/-?\/-?/g).join('/');
@@ -2563,14 +2432,14 @@
      * @public exported from `@promptbook/editable`
      */
     function knowledgeSourceContentToName(knowledgeSourceContent) {
-        var hash = cryptoJs.SHA256(hexEncoder__default["default"].parse(JSON.stringify(knowledgeSourceContent)))
+        const hash = cryptoJs.SHA256(hexEncoder__default["default"].parse(JSON.stringify(knowledgeSourceContent)))
             //    <- TODO: [🥬] Encapsulate sha256 to some private utility function
             .toString( /* hex */)
             .substring(0, 20);
         //    <- TODO: [🥬] Make some system for hashes and ids of promptbook
-        var semanticName = normalizeToKebabCase(knowledgeSourceContent.substring(0, 20));
-        var pieces = ['source', semanticName, hash].filter(function (piece) { return piece !== ''; });
-        var name = pieces.join('-').split('--').join('-');
+        const semanticName = normalizeToKebabCase(knowledgeSourceContent.substring(0, 20));
+        const pieces = ['source', semanticName, hash].filter((piece) => piece !== '');
+        const name = pieces.join('-').split('--').join('-');
         // <- TODO: Use MAX_FILENAME_LENGTH
         return name;
     }
@@ -2584,7 +2453,7 @@
      * @see `documentationUrl` for more details
      * @public exported from `@promptbook/editable`
      */
-    var knowledgeCommandParser = {
+    const knowledgeCommandParser = {
         /**
          * Name of the command
          */
@@ -2597,7 +2466,7 @@
         /**
          * Description of the KNOWLEDGE command
          */
-        description: "Tells promptbook which external knowledge to use",
+        description: `Tells promptbook which external knowledge to use`,
         /**
          * Link to documentation
          */
@@ -2616,27 +2485,27 @@
         /**
          * Parses the KNOWLEDGE command
          */
-        parse: function (input) {
-            var args = input.args;
-            var knowledgeSourceContent = spaceTrim__default["default"](args[0] || '');
+        parse(input) {
+            const { args } = input;
+            const knowledgeSourceContent = spaceTrim__default["default"](args[0] || '');
             if (knowledgeSourceContent === '') {
-                throw new ParseError("Source is not defined");
+                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");
+                throw new ParseError(`Source is not secure`);
             }
             if (!(isValidFilePath(knowledgeSourceContent) || isValidUrl(knowledgeSourceContent))) {
-                throw new ParseError("Source not valid");
+                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");
+                throw new ParseError(`Source cannot be outside of the .book.md folder`);
             }
             return {
                 type: 'KNOWLEDGE',
-                knowledgeSourceContent: knowledgeSourceContent,
+                knowledgeSourceContent,
             };
         },
         /**
@@ -2644,11 +2513,11 @@
          *
          * Note: `$` is used to indicate that this function mutates given `pipelineJson`
          */
-        $applyToPipelineJson: function (command, $pipelineJson) {
-            var knowledgeSourceContent = command.knowledgeSourceContent;
+        $applyToPipelineJson(command, $pipelineJson) {
+            const { knowledgeSourceContent } = command;
             $pipelineJson.knowledgeSources.push({
                 name: knowledgeSourceContentToName(knowledgeSourceContent),
-                knowledgeSourceContent: knowledgeSourceContent,
+                knowledgeSourceContent,
             });
         },
         /**
@@ -2656,16 +2525,16 @@
          *
          * Note: This is used in `pipelineJsonToString` utility
          */
-        stringify: function (command) {
-            return "---"; // <- TODO: [🛋] Implement
+        stringify(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
+        takeFromPipelineJson(pipelineJson) {
+            throw new NotYetImplementedError(`[🛋] Not implemented yet`); // <- TODO: [🛋] Implement
         },
     };
     /**
@@ -2677,7 +2546,7 @@
      *
      * @public exported from `@promptbook/core`
      */
-    var MODEL_VARIANTS = ['COMPLETION', 'CHAT', 'EMBEDDING' /* <- TODO [🏳] */ /* <- [🤖] */];
+    const MODEL_VARIANTS = ['COMPLETION', 'CHAT', 'EMBEDDING' /* <- TODO [🏳] */ /* <- [🤖] */];
 
     /**
      * Parses the model command
@@ -2686,7 +2555,7 @@
      * @deprecated Option to manually set the model requirements is not recommended to use, use `PERSONA` instead
      * @public exported from `@promptbook/editable`
      */
-    var modelCommandParser = {
+    const modelCommandParser = {
         /**
          * Name of the command
          */
@@ -2699,7 +2568,7 @@
         /**
          * Description of the MODEL command
          */
-        description: "Tells which `modelRequirements` (for example which model) to use for the prompt task execution",
+        description: `Tells which \`modelRequirements\` (for example which model) to use for the prompt task execution`,
         /**
          * Link to documentation
          */
@@ -2711,11 +2580,12 @@
         /**
          * Parses the MODEL command
          */
-        parse: function (input) {
-            var args = input.args, normalized = input.normalized;
-            var availableVariantsMessage = spaceTrim__default["default"](function (block) { return "\n              Available variants are:\n              ".concat(block(MODEL_VARIANTS.map(function (variantName) {
-                return "- ".concat(variantName).concat(variantName !== 'EMBEDDING' ? '' : ' (Not available in pipeline)');
-            }).join('\n')), "\n          "); });
+        parse(input) {
+            const { args, normalized } = input;
+            const availableVariantsMessage = spaceTrim__default["default"]((block) => `
+              Available variants are:
+              ${block(MODEL_VARIANTS.map((variantName) => `- ${variantName}${variantName !== 'EMBEDDING' ? '' : ' (Not available in pipeline)'}`).join('\n'))}
+          `);
             // TODO: Make this more elegant and dynamically
             if (normalized.startsWith('MODEL_VARIANT')) {
                 if (normalized === 'MODEL_VARIANT_CHAT') {
@@ -2734,10 +2604,18 @@
                     // <- Note: [🤖]
                 }
                 else if (normalized.startsWith('MODEL_VARIANT_EMBED')) {
-                    spaceTrim__default["default"](function (block) { return "\n                        Embedding model can not be used in pipeline\n\n                        ".concat(block(availableVariantsMessage), "\n                    "); });
+                    spaceTrim__default["default"]((block) => `
+                        Embedding model can not be used in pipeline
+
+                        ${block(availableVariantsMessage)}
+                    `);
                 }
                 else {
-                    throw new ParseError(spaceTrim__default["default"](function (block) { return "\n                            Unknown model variant in command:\n\n                            ".concat(block(availableVariantsMessage), "\n                        "); }));
+                    throw new ParseError(spaceTrim__default["default"]((block) => `
+                            Unknown model variant in command:
+
+                            ${block(availableVariantsMessage)}
+                        `));
                 }
             }
             if (normalized.startsWith('MODEL_NAME')) {
@@ -2748,7 +2626,16 @@
                 };
             }
             else {
-                throw new ParseError(spaceTrim__default["default"](function (block) { return "\n                    Unknown model key in command.\n\n                    Supported model keys are:\n                    ".concat(block(['variant', 'name'].join(', ')), "\n\n                    Example:\n                    - MODEL VARIANT Chat\n                    - MODEL NAME gpt-4\n              "); }));
+                throw new ParseError(spaceTrim__default["default"]((block) => `
+                    Unknown model key in command.
+
+                    Supported model keys are:
+                    ${block(['variant', 'name'].join(', '))}
+
+                    Example:
+                    - MODEL VARIANT Chat
+                    - MODEL NAME gpt-4
+              `));
             }
         },
         /**
@@ -2756,16 +2643,22 @@
          *
          * Note: `$` is used to indicate that this function mutates given `pipelineJson`
          */
-        $applyToPipelineJson: function (command, $pipelineJson) {
+        $applyToPipelineJson(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"));
+                    console.warn(`Multiple commands \`MODEL ${command.key} ${command.value}\` in the pipeline head`);
                     // <- TODO: [🚎][💩] Some better way how to get warnings from pipeline parsing / logic
                 }
                 else {
-                    throw new ParseError(spaceTrim__default["default"]("\n                        Redefinition of `MODEL ".concat(command.key, "` in the pipeline head\n\n                        You have used:\n                        1) `MODEL ").concat(command.key, " ").concat($pipelineJson.defaultModelRequirements[command.key], "`\n                        2) `MODEL ").concat(command.key, " ").concat(command.value, "`\n                    ")));
+                    throw new ParseError(spaceTrim__default["default"](`
+                        Redefinition of \`MODEL ${command.key}\` in the pipeline head
+
+                        You have used:
+                        1) \`MODEL ${command.key} ${$pipelineJson.defaultModelRequirements[command.key]}\`
+                        2) \`MODEL ${command.key} ${command.value}\`
+                    `));
                 }
             }
             $pipelineJson.defaultModelRequirements[command.key] = command.value;
@@ -2775,26 +2668,40 @@
          *
          * Note: `$` is used to indicate that this function mutates given `taskJson`
          */
-        $applyToTaskJson: function (command, $taskJson, $pipelineJson) {
+        $applyToTaskJson(command, $taskJson, $pipelineJson) {
             if ($taskJson.taskType !== 'PROMPT_TASK') {
-                throw new ParseError("MODEL command can only be used in PROMPT_TASK block");
+                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, "\""));
+                    console.warn(`Multiple commands \`MODEL ${{
+                    modelName: 'NAME',
+                    modelVariant: 'VARIANT',
+                    maxTokens: '???',
+                }[command.key]} ${command.value}\` in the task "${$taskJson.title || $taskJson.name}"`);
                 }
                 else {
-                    throw new ParseError(spaceTrim__default["default"]("\n                              Redefinition of MODEL `".concat(command.key, "` in the task \"").concat($taskJson.title || $taskJson.name, "\"\n\n                              You have used:\n                              - MODEL ").concat(command.key, " ").concat($taskJson.modelRequirements[command.key], "\n                              - MODEL ").concat(command.key, " ").concat(command.value, "\n                          ")));
+                    throw new ParseError(spaceTrim__default["default"](`
+                              Redefinition of MODEL \`${command.key}\` in the task "${$taskJson.title || $taskJson.name}"
+
+                              You have used:
+                              - MODEL ${command.key} ${$taskJson.modelRequirements[command.key]}
+                              - MODEL ${command.key} ${command.value}
+                          `));
                 }
             }
             if (command.value === ($pipelineJson.defaultModelRequirements || {})[command.key]) {
-                console.log(spaceTrim__default["default"]("\n                    Setting MODEL `".concat(command.key, "` in the task \"").concat($taskJson.title || $taskJson.name, "\" to the same value as in the pipeline head\n\n                    In pipeline head:\n                    - MODEL ").concat(command.key, " ").concat(($pipelineJson.defaultModelRequirements || {})[command.key], "\n\n                    But same value is used in the task:\n                    - MODEL ").concat(command.key, " ").concat(command.value, "\n                ")));
+                console.log(spaceTrim__default["default"](`
+                    Setting MODEL \`${command.key}\` in the task "${$taskJson.title || $taskJson.name}" to the same value as in the pipeline head
+
+                    In pipeline head:
+                    - MODEL ${command.key} ${($pipelineJson.defaultModelRequirements || {})[command.key]}
+
+                    But same value is used in the task:
+                    - MODEL ${command.key} ${command.value}
+                `));
             }
             $taskJson.modelRequirements[command.key] = command.value;
         },
@@ -2803,24 +2710,24 @@
          *
          * Note: This is used in `pipelineJsonToString` utility
          */
-        stringify: function (command) {
-            return "---"; // <- TODO: [🛋] Implement
+        stringify(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
+        takeFromPipelineJson(pipelineJson) {
+            throw new NotYetImplementedError(`[🛋] 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
+        takeFromTaskJson($taskJson) {
+            throw new NotYetImplementedError(`[🛋] Not implemented yet`); // <- TODO: [🛋] Implement
         },
     };
 
@@ -2830,7 +2737,7 @@
      * @see `documentationUrl` for more details
      * @public exported from `@promptbook/editable`
      */
-    var parameterCommandParser = {
+    const parameterCommandParser = {
         /**
          * Name of the command
          */
@@ -2850,7 +2757,7 @@
         /**
          * Description of the PARAMETER command
          */
-        description: "Describes one parameter of the task",
+        description: `Describes one parameter of the task`,
         /**
          * Link to documentation
          */
@@ -2862,29 +2769,34 @@
         /**
          * 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(' ');
+        parse(input) {
+            const { normalized, args, raw } = input;
+            const parameterNameRaw = args.shift() || '';
+            const parameterDescriptionRaw = args.join(' ');
             // <- TODO: When [🥶] fixed, change to:
             //        >   const parameterDescriptionRaw = rawArgs.split(parameterNameRaw).join('').trim();
             if (parameterDescriptionRaw && parameterDescriptionRaw.match(/\{(?<embeddedParameterName>[a-z0-9_]+)\}/im)) {
-                throw new ParseError(spaceTrim__default["default"](function (block) { return "\n                        Parameter `{".concat(parameterNameRaw, "}` can not contain another parameter in description\n\n                        The description:\n                        ").concat(block(parameterDescriptionRaw), "\n                    "); }));
+                throw new ParseError(spaceTrim__default["default"]((block) => `
+                        Parameter \`{${parameterNameRaw}}\` can not contain another parameter in description
+
+                        The description:
+                        ${block(parameterDescriptionRaw)}
+                    `));
             }
-            var isInput = normalized.startsWith('INPUT');
-            var isOutput = normalized.startsWith('OUTPUT');
+            let isInput = normalized.startsWith('INPUT');
+            let isOutput = normalized.startsWith('OUTPUT');
             if (raw.startsWith('> {')) {
                 isInput = false;
                 isOutput = false;
             }
-            var parameterName = validateParameterName(parameterNameRaw);
-            var parameterDescription = parameterDescriptionRaw.trim() || null;
+            const parameterName = validateParameterName(parameterNameRaw);
+            const parameterDescription = parameterDescriptionRaw.trim() || null;
             return {
                 type: 'PARAMETER',
-                parameterName: parameterName,
-                parameterDescription: parameterDescription,
-                isInput: isInput,
-                isOutput: isOutput,
+                parameterName,
+                parameterDescription,
+                isInput,
+                isOutput,
             };
         },
         /**
@@ -2892,7 +2804,7 @@
          *
          * Note: `$` is used to indicate that this function mutates given `pipelineJson`
          */
-        $applyToPipelineJson: function (command, $pipelineJson) {
+        $applyToPipelineJson(command, $pipelineJson) {
             // Note: [🍣] Do nothing, its application is implemented separately in `parsePipeline`
         },
         /**
@@ -2900,7 +2812,7 @@
          *
          * Note: `$` is used to indicate that this function mutates given `taskJson`
          */
-        $applyToTaskJson: function (command, $taskJson, $pipelineJson) {
+        $applyToTaskJson(command, $taskJson, $pipelineJson) {
             // Note: [🍣] Do nothing, its application is implemented separately in `parsePipeline`
         },
         /**
@@ -2908,24 +2820,24 @@
          *
          * Note: This is used in `pipelineJsonToString` utility
          */
-        stringify: function (command) {
-            return "---"; // <- TODO: [🛋] Implement
+        stringify(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
+        takeFromPipelineJson(pipelineJson) {
+            throw new NotYetImplementedError(`[🛋] 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
+        takeFromTaskJson($taskJson) {
+            throw new NotYetImplementedError(`[🛋] Not implemented yet`); // <- TODO: [🛋] Implement
         },
     };
 
@@ -2935,7 +2847,7 @@
      * @see `documentationUrl` for more details
      * @public exported from `@promptbook/editable`
      */
-    var personaCommandParser = {
+    const personaCommandParser = {
         /**
          * Name of the command
          */
@@ -2952,7 +2864,7 @@
         /**
          * 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,...",
+        description: `Persona command is used to specify who the system is, it will be transformed into system message, top_t,...`,
         /**
          * Link to documentation
          */
@@ -2964,21 +2876,21 @@
         /**
          * 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();
+        parse(input) {
+            const { rawArgs } = input;
+            const [personaNameRaw, personaDescriptionRaw] = rawArgs.split(/[,;:]/, 2);
+            const personaName = (personaNameRaw || '').trim();
             if (personaName === '') {
-                throw new ParseError("You must set name for the persona");
+                throw new ParseError(`You must set name for the persona`);
             }
-            var personaDescription = (personaDescriptionRaw || '').trim();
+            let personaDescription = (personaDescriptionRaw || '').trim();
             if (personaDescription === '') {
                 personaDescription = null;
             }
             return {
                 type: 'PERSONA',
-                personaName: personaName,
-                personaDescription: personaDescription,
+                personaName,
+                personaDescription,
             };
         },
         /**
@@ -2986,33 +2898,33 @@
          *
          * Note: `$` is used to indicate that this function mutates given `pipelineJson`
          */
-        $applyToPipelineJson: function (command, $pipelineJson) {
+        $applyToPipelineJson(command, $pipelineJson) {
             $applyToTaskJson(command, null, $pipelineJson);
         },
-        $applyToTaskJson: $applyToTaskJson,
+        $applyToTaskJson,
         /**
          * Converts the PERSONA command back to string
          *
          * Note: This is used in `pipelineJsonToString` utility
          */
-        stringify: function (command) {
-            return "---"; // <- TODO: [🛋] Implement
+        stringify(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
+        takeFromPipelineJson(pipelineJson) {
+            throw new NotYetImplementedError(`[🛋] 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
+        takeFromTaskJson($taskJson) {
+            throw new NotYetImplementedError(`[🛋] Not implemented yet`); // <- TODO: [🛋] Implement
         },
     };
     /**
@@ -3021,14 +2933,14 @@
      * Note: `$` is used to indicate that this function mutates given `taskJson`
      */
     function $applyToTaskJson(command, $taskJson, $pipelineJson) {
-        var personaName = command.personaName, personaDescription = command.personaDescription;
+        const { personaName, personaDescription } = command;
         if ($taskJson !== null) {
             if ($taskJson.taskType !== 'PROMPT_TASK') {
-                throw new ParseError("PERSONA command can be used only in PROMPT_TASK block");
+                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; });
+        const persona = $pipelineJson.personas.find((persona) => persona.name === personaName);
         if (persona === undefined) {
             $pipelineJson.personas.push({
                 name: personaName,
@@ -3046,7 +2958,17 @@
             persona.description = personaDescription;
             return;
         }
-        console.warn(spaceTrim__default["default"]("\n\n         Persona \"".concat(personaName, "\" is defined multiple times with different description:\n\n         First definition:\n         ").concat(persona.description, "\n\n         Second definition:\n         ").concat(personaDescription, "\n\n     ")));
+        console.warn(spaceTrim__default["default"](`
+
+         Persona "${personaName}" is defined multiple times with different description:
+
+         First definition:
+         ${persona.description}
+
+         Second definition:
+         ${personaDescription}
+
+     `));
         persona.description += spaceTrim__default["default"]('\n\n' + personaDescription);
     }
 
@@ -3070,7 +2992,7 @@
      * @see `documentationUrl` for more details
      * @public exported from `@promptbook/editable`
      */
-    var postprocessCommandParser = {
+    const postprocessCommandParser = {
         /**
          * Name of the command
          */
@@ -3084,7 +3006,7 @@
         /**
          * Description of the POSTPROCESS command
          */
-        description: "Defines the postprocess function to be used on the result from LLM and before the result is validated",
+        description: `Defines the postprocess function to be used on the result from LLM and before the result is validated`,
         /**
          * Link to documentation
          */
@@ -3098,21 +3020,21 @@
         /**
          * Parses the POSTPROCESS command
          */
-        parse: function (input) {
-            var args = input.args;
-            var functionName = args.pop();
+        parse(input) {
+            const { args } = input;
+            const functionName = args.pop();
             if (functionName === undefined) {
-                throw new ParseError("Postprocess function name is required");
+                throw new ParseError(`Postprocess function name is required`);
             }
             if (!isValidJavascriptName(functionName)) {
-                throw new ParseError("Invalid postprocess function name \"".concat(functionName, "\""));
+                throw new ParseError(`Invalid postprocess function name "${functionName}"`);
             }
             if (args.length > 0) {
-                throw new ParseError("Can not have more than one postprocess function");
+                throw new ParseError(`Can not have more than one postprocess function`);
             }
             return {
                 type: 'POSTPROCESS',
-                functionName: functionName,
+                functionName,
             };
         },
         /**
@@ -3120,7 +3042,7 @@
          *
          * Note: `$` is used to indicate that this function mutates given `taskJson`
          */
-        $applyToTaskJson: function (command, $taskJson) {
+        $applyToTaskJson(command, $taskJson) {
             $taskJson.postprocessingFunctionNames = $taskJson.postprocessingFunctionNames || [];
             $taskJson.postprocessingFunctionNames.push(command.functionName);
         },
@@ -3129,16 +3051,16 @@
          *
          * Note: This is used in `pipelineJsonToString` utility
          */
-        stringify: function (command) {
-            return "---"; // <- TODO: [🛋] Implement
+        stringify(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
+        takeFromTaskJson($taskJson) {
+            throw new NotYetImplementedError(`[🛋] Not implemented yet`); // <- TODO: [🛋] Implement
         },
     };
 
@@ -3151,7 +3073,7 @@
      *
      * @public exported from `@promptbook/core`
      */
-    var TaskTypes = [
+    const TaskTypes = [
         'PROMPT',
         'SIMPLE',
         'SCRIPT',
@@ -3164,7 +3086,7 @@
      *
      * @public exported from `@promptbook/core`
      */
-    var NonTaskSectionTypes = ['EXAMPLE', 'KNOWLEDGE', 'INSTRUMENT', 'ACTION'];
+    const NonTaskSectionTypes = ['EXAMPLE', 'KNOWLEDGE', 'INSTRUMENT', 'ACTION'];
     /**
      * All available section types
      *
@@ -3174,7 +3096,10 @@
      *
      * @public exported from `@promptbook/core`
      */
-    var SectionTypes = __spreadArray(__spreadArray([], __read(TaskTypes.map(function (TaskType) { return "".concat(TaskType, "_TASK"); })), false), __read(NonTaskSectionTypes), false);
+    const SectionTypes = [
+        ...TaskTypes.map((TaskType) => `${TaskType}_TASK`),
+        ...NonTaskSectionTypes,
+    ];
 
     /**
      * Parses the section command
@@ -3182,7 +3107,7 @@
      * @see `documentationUrl` for more details
      * @public exported from `@promptbook/editable`
      */
-    var sectionCommandParser = {
+    const sectionCommandParser = {
         /**
          * Name of the command
          */
@@ -3213,7 +3138,7 @@
         /**
          * Description of the SECTION command
          */
-        description: "Defines the purpose of the markdown section - if its a task and which type or something else",
+        description: `Defines the purpose of the markdown section - if its a task and which type or something else`,
         /**
          * Link to documentation
          */
@@ -3259,21 +3184,24 @@
         /**
          * Parses the SECTION command
          */
-        parse: function (input) {
-            var normalized = input.normalized;
+        parse(input) {
+            let { normalized } = input;
             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(''));
-            });
+            const taskTypes = SectionTypes.filter((sectionType) => normalized.includes(sectionType.split('_TASK').join('')));
             if (taskTypes.length !== 1) {
-                throw new ParseError(spaceTrim__default["default"](function (block) { return "\n                        Unknown section type \"".concat(normalized, "\"\n\n                        Supported section types are:\n                        ").concat(block(SectionTypes.join(', ')), "\n                    "); }));
+                throw new ParseError(spaceTrim__default["default"]((block) => `
+                        Unknown section type "${normalized}"
+
+                        Supported section types are:
+                        ${block(SectionTypes.join(', '))}
+                    `));
             }
-            var taskType = taskTypes[0];
+            const taskType = taskTypes[0];
             return {
                 type: 'SECTION',
-                taskType: taskType,
+                taskType,
             };
         },
         /**
@@ -3281,27 +3209,30 @@
          *
          * Note: `$` is used to indicate that this function mutates given `taskJson`
          */
-        $applyToTaskJson: function (command, $taskJson, $pipelineJson) {
+        $applyToTaskJson(command, $taskJson, $pipelineJson) {
             if ($taskJson.isSectionTypeSet === true) {
-                throw new ParseError(spaceTrim__default["default"]("\n                    Section type is already defined in the section.\n                    It can be defined only once.\n                "));
+                throw new ParseError(spaceTrim__default["default"](`
+                    Section type is already defined in the section.
+                    It can be defined only once.
+                `));
             }
             $taskJson.isSectionTypeSet = true;
             // TODO: [🍧][💩] Rearrange better - but at bottom and unwrap from function
-            var expectResultingParameterName = function () {
+            const expectResultingParameterName = () => {
                 if ($taskJson.resultingParameterName) {
                     return;
                 }
-                throw new ParseError("Task section and example section must end with return statement -> {parameterName}");
+                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");
+                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; });
+                const parameter = $pipelineJson.parameters.find((param) => 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"));
+                    throw new ParseError(`Parameter \`{${$taskJson.resultingParameterName}}\` is not defined so can not define example value of it`);
                 }
                 parameter.exampleValues = parameter.exampleValues || [];
                 parameter.exampleValues.push($taskJson.content);
@@ -3335,16 +3266,16 @@
          *
          * Note: This is used in `pipelineJsonToString` utility
          */
-        stringify: function (command) {
-            return "---"; // <- TODO: [🛋] Implement
+        stringify(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
+        takeFromTaskJson($taskJson) {
+            throw new NotYetImplementedError(`[🛋] Not implemented yet`); // <- TODO: [🛋] Implement
         },
     };
     /**
@@ -3397,7 +3328,7 @@
      * @see `documentationUrl` for more details
      * @public exported from `@promptbook/editable`
      */
-    var urlCommandParser = {
+    const urlCommandParser = {
         /**
          * Name of the command
          */
@@ -3415,7 +3346,7 @@
         /**
          * Description of the URL command
          */
-        description: "Declares unique URL for the pipeline",
+        description: `Declares unique URL for the pipeline`,
         /**
          * Link to documentation
          */
@@ -3431,18 +3362,18 @@
         /**
          * Parses the URL command
          */
-        parse: function (input) {
-            var args = input.args;
-            var pipelineUrl = args.pop();
+        parse(input) {
+            const { args } = input;
+            const pipelineUrl = args.pop();
             if (pipelineUrl === undefined) {
-                throw new ParseError("URL is required");
+                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, "\""));
+                throw new ParseError(`Invalid pipeline URL "${pipelineUrl}"`);
             }
             if (args.length > 0) {
-                throw new ParseError("Can not have more than one pipeline URL");
+                throw new ParseError(`Can not have more than one pipeline URL`);
             }
             /*
             TODO: [🐠 Maybe more info from `isValidPipelineUrl`:
@@ -3471,7 +3402,7 @@
          *
          * Note: `$` is used to indicate that this function mutates given `pipelineJson`
          */
-        $applyToPipelineJson: function (command, $pipelineJson) {
+        $applyToPipelineJson(command, $pipelineJson) {
             $pipelineJson.pipelineUrl = command.pipelineUrl.href;
         },
         /**
@@ -3479,16 +3410,16 @@
          *
          * Note: This is used in `pipelineJsonToString` utility
          */
-        stringify: function (command) {
-            return "---"; // <- TODO: [🛋] Implement
+        stringify(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
+        takeFromPipelineJson(pipelineJson) {
+            throw new NotYetImplementedError(`[🛋] Not implemented yet`); // <- TODO: [🛋] Implement
         },
     };
 
@@ -3498,7 +3429,7 @@
      * @see `documentationUrl` for more details
      * @public exported from `@promptbook/editable`
      */
-    var actionCommandParser = {
+    const actionCommandParser = {
         /**
          * Name of the command
          */
@@ -3511,7 +3442,7 @@
         /**
          * 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.",
+        description: `Actions influences from the pipeline or task into external world. Like turning on a light, sending an email, etc.`,
         /**
          * Link to documentation
          */
@@ -3523,8 +3454,7 @@
         /**
          * Parses the ACTION command
          */
-        parse: function (input) {
-            input.args;
+        parse(input) {
             return {
                 type: 'ACTION',
             };
@@ -3534,7 +3464,7 @@
          *
          * Note: `$` is used to indicate that this function mutates given `pipelineJson`
          */
-        $applyToPipelineJson: function (command, $pipelineJson) {
+        $applyToPipelineJson(command, $pipelineJson) {
             console.error(new NotYetImplementedError('[🛠] Actions are not implemented yet'));
         },
         /**
@@ -3542,7 +3472,7 @@
          *
          * Note: This is used in `pipelineJsonToString` utility
          */
-        stringify: function (command) {
+        stringify(command) {
             throw new NotYetImplementedError('[🛠] Actions are not implemented yet');
         },
         /**
@@ -3550,7 +3480,7 @@
          *
          * Note: This is used in `pipelineJsonToString` utility
          */
-        takeFromPipelineJson: function (pipelineJson) {
+        takeFromPipelineJson(pipelineJson) {
             throw new NotYetImplementedError('[🛠] Actions are not implemented yet');
         },
     };
@@ -3564,7 +3494,7 @@
      * @see `documentationUrl` for more details
      * @public exported from `@promptbook/editable`
      */
-    var instrumentCommandParser = {
+    const instrumentCommandParser = {
         /**
          * Name of the command
          */
@@ -3577,7 +3507,7 @@
         /**
          * 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.",
+        description: `Instrument command is used to specify the instrument to be used in the pipeline or task like search, calculate, etc.`,
         /**
          * Link to documentation
          */
@@ -3589,8 +3519,7 @@
         /**
          * Parses the INSTRUMENT command
          */
-        parse: function (input) {
-            input.args;
+        parse(input) {
             return {
                 type: 'INSTRUMENT',
             };
@@ -3600,7 +3529,7 @@
          *
          * Note: `$` is used to indicate that this function mutates given `pipelineJson`
          */
-        $applyToPipelineJson: function (command, $pipelineJson) {
+        $applyToPipelineJson(command, $pipelineJson) {
             console.error(new NotYetImplementedError('[🛠] Instruments are not implemented yet'));
         },
         /**
@@ -3608,7 +3537,7 @@
          *
          * Note: This is used in `pipelineJsonToString` utility
          */
-        stringify: function (command) {
+        stringify(command) {
             throw new NotYetImplementedError('[🛠] Instruments are not implemented yet');
         },
         /**
@@ -3616,7 +3545,7 @@
          *
          * Note: This is used in `pipelineJsonToString` utility
          */
-        takeFromPipelineJson: function (pipelineJson) {
+        takeFromPipelineJson(pipelineJson) {
             throw new NotYetImplementedError('[🛠] Instruments are not implemented yet');
         },
     };
@@ -3629,7 +3558,7 @@
      *
      * @public exported from `@promptbook/editable`
      */
-    var COMMANDS = [
+    const COMMANDS = [
         sectionCommandParser,
         expectCommandParser,
         formatCommandParser,
@@ -3661,12 +3590,16 @@
      * @public exported from `@promptbook/editable`
      */
     function getParserForCommand(command) {
-        var commandParser = COMMANDS.find(function (commandParser) { return commandParser.name === command.type; });
+        const commandParser = COMMANDS.find((commandParser) => commandParser.name === command.type);
         if (commandParser === undefined) {
-            throw new UnexpectedError(spaceTrim.spaceTrim(function (block) { return "\n                    Command ".concat(command.type, " parser is not found\n\n                    ").concat(block(JSON.stringify(command, null, 4)
-                .split('\n')
-                .map(function (line) { return "> ".concat(line); })
-                .join('\n')), "\n                "); }));
+            throw new UnexpectedError(spaceTrim.spaceTrim((block) => `
+                    Command ${command.type} parser is not found
+
+                    ${block(JSON.stringify(command, null, 4)
+            .split('\n')
+            .map((line) => `> ${line}`)
+            .join('\n'))}
+                `));
         }
         return commandParser;
     }
@@ -3701,7 +3634,7 @@
             throw new ParseError('Command can not contain new line characters' /* <- TODO: [🚞] */);
         }
         // TODO: Unit test all this processing and parsing
-        var normalized = raw.trim();
+        let normalized = raw.trim();
         normalized = normalized.split('`').join('');
         normalized = normalized.split('"').join('');
         normalized = normalized.split("'").join('');
@@ -3711,7 +3644,7 @@
         normalized = normalized.split('(').join('');
         normalized = normalized.split(')').join('');
         normalized = normalizeTo_SCREAMING_CASE(normalized);
-        var items = raw
+        const items = raw
             .trim()
             // Note: [🐡]
             .split(/^>/)
@@ -3730,25 +3663,30 @@
             .join('PARAMETER {')
             // ---
             .split(' ')
-            .map(function (part) { return part.trim(); })
-            .filter(function (item) { return item !== ''; })
+            .map((part) => part.trim())
+            .filter((item) => item !== '')
             .map(removeMarkdownFormatting)
-            .map(function (item) { return item.trim(); });
+            .map((item) => item.trim());
         if (items.length === 0 || items[0] === '') {
-            throw new ParseError(spaceTrim.spaceTrim(function (block) {
-                return "\n                        Malformed command:\n                        - ".concat(raw, "\n\n                        Supported commands are:\n                        ").concat(block(getSupportedCommandsMessage()), "\n\n                    ");
-            }));
+            throw new ParseError(spaceTrim.spaceTrim((block) => `
+                        Malformed command:
+                        - ${raw}
+
+                        Supported commands are:
+                        ${block(getSupportedCommandsMessage())}
+
+                    `));
         }
         // 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
+        for (let commandNameSegmentsCount = 0; commandNameSegmentsCount < Math.min(items.length, 3); commandNameSegmentsCount++) {
+            const commandNameRaw = items.slice(0, commandNameSegmentsCount + 1).join('_');
+            const args = items.slice(commandNameSegmentsCount + 1);
+            const rawArgs = raw
                 .substring(commandNameRaw.length)
                 .trim();
-            var command = parseCommandVariant({ usagePlace: usagePlace, raw: raw, rawArgs: rawArgs, normalized: normalized, args: args, commandNameRaw: commandNameRaw });
+            const command = parseCommandVariant({ usagePlace, raw, rawArgs, normalized, args, commandNameRaw });
             if (command !== null) {
                 return command;
             }
@@ -3756,78 +3694,79 @@
         // 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
+            const commandNameRaw = items.slice(-1).join('_');
+            const args = items.slice(0, -1); // <- Note: This is probbably not correct
+            const rawArgs = raw
                 .substring(0, raw.length - commandNameRaw.length)
                 .trim();
-            var command = parseCommandVariant({ usagePlace: usagePlace, raw: raw, rawArgs: rawArgs, normalized: normalized, args: args, commandNameRaw: commandNameRaw });
+            const command = parseCommandVariant({ usagePlace, raw, rawArgs, normalized, args, commandNameRaw });
             if (command !== null) {
                 return command;
             }
         }
-        throw new ParseError(spaceTrim.spaceTrim(function (block) {
-            return "\n                  Malformed or unknown command:\n                  - ".concat(raw, "\n\n                  Supported commands are:\n                  ").concat(block(getSupportedCommandsMessage()), "\n\n              ");
-        }));
+        throw new ParseError(spaceTrim.spaceTrim((block) => `
+                  Malformed or unknown command:
+                  - ${raw}
+
+                  Supported commands are:
+                  ${block(getSupportedCommandsMessage())}
+
+              `));
     }
     /**
      * @@@
      */
     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');
+        return COMMANDS.flatMap(({ name, aliasNames, description, documentationUrl }) => 
+        //                                                                        <- Note: [🦦] Its strange that this type assertion is needed
+        [
+            `- **${name}** ${description}, see [discussion](${documentationUrl})`,
+            ...(aliasNames || []).map((aliasName) => `    - **${aliasName}** Alias for **${name}**`),
+        ]).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) {
+        const { commandNameRaw, usagePlace, normalized, args, raw, rawArgs } = input;
+        const commandName = normalizeTo_SCREAMING_CASE(commandNameRaw);
+        for (const commandParser of COMMANDS) {
             //                               <- 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;
+            const { name, isUsedInPipelineHead, isUsedInPipelineTask, aliasNames, deprecatedNames, parse } = commandParser;
             if (just(false)) ;
             else if (usagePlace === 'PIPELINE_HEAD' && !isUsedInPipelineHead) {
-                return "continue";
+                continue;
             }
             else if (usagePlace === 'PIPELINE_TASK' && !isUsedInPipelineTask) {
-                return "continue";
+                continue;
             }
-            var names = __spreadArray(__spreadArray([name_1], __read((aliasNames || [])), false), __read((deprecatedNames || [])), false);
+            const names = [name, ...(aliasNames || []), ...(deprecatedNames || [])];
             if (names.includes(commandName)) {
                 try {
-                    return { value: parse({ usagePlace: usagePlace, raw: raw, rawArgs: rawArgs, normalized: normalized, args: args }) };
+                    return parse({ usagePlace, raw, rawArgs, normalized, args }); // <- Note: [🦦]
                 }
                 catch (error) {
                     if (!(error instanceof ParseError)) {
                         throw error;
                     }
-                    throw new ParseError(spaceTrim.spaceTrim(function (block) {
-                        return "\n                              Invalid ".concat(commandName, " command:\n\n                              Your command:\n                              - ").concat(raw, "\n\n                              The detailed error:\n                              ").concat(block(error.message), "\n\n                              Usage of ").concat(commandName, ":\n                              ").concat(block(commandParser.examples.map(function (example) { return "- ".concat(example); }).join('\n')), "\n\n                              All supported commands are:\n                              ").concat(block(getSupportedCommandsMessage()), "\n\n                          ");
-                    }));
+                    throw new ParseError(spaceTrim.spaceTrim((block) => `
+                              Invalid ${commandName} command:
+
+                              Your command:
+                              - ${raw}
+
+                              The detailed error:
+                              ${block(error.message)}
+
+                              Usage of ${commandName}:
+                              ${block(commandParser.examples.map((example) => `- ${example}`).join('\n'))}
+
+                              All supported commands are:
+                              ${block(getSupportedCommandsMessage())}
+
+                          `));
                 }
             }
-        };
-        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;
     }
@@ -3861,13 +3800,13 @@
             throw new ParseError('Expected a book, but got a JSON string');
         }
         else if (isValidUrl(pipelineString)) {
-            throw new ParseError("Expected a book, but got just the URL \"".concat(pipelineString, "\""));
+            throw new ParseError(`Expected a book, but got just the URL "${pipelineString}"`);
         }
         else if (isValidFilePath(pipelineString)) {
-            throw new ParseError("Expected a book, but got just the file path \"".concat(pipelineString, "\""));
+            throw new ParseError(`Expected a book, but got just the file path "${pipelineString}"`);
         }
         else if (isValidEmail(pipelineString)) {
-            throw new ParseError("Expected a book, but got just the email \"".concat(pipelineString, "\""));
+            throw new ParseError(`Expected a book, but got just the email "${pipelineString}"`);
         }
         // <- TODO: Implement the validation + add tests when the pipeline logic considered as invalid
         return pipelineString;
@@ -3895,16 +3834,16 @@
     function isFlatPipeline(pipelineString) {
         pipelineString = removeMarkdownComments(pipelineString);
         pipelineString = spaceTrim__default["default"](pipelineString);
-        var isMarkdownBeginningWithHeadline = pipelineString.startsWith('# ');
+        const isMarkdownBeginningWithHeadline = pipelineString.startsWith('# ');
         //const isLastLineReturnStatement = pipelineString.split('\n').pop()!.split('`').join('').startsWith('->');
-        var isBacktickBlockUsed = pipelineString.includes('```');
-        var isQuoteBlocksUsed = /^>\s+/m.test(pipelineString);
-        var isBlocksUsed = isBacktickBlockUsed || isQuoteBlocksUsed;
+        const isBacktickBlockUsed = pipelineString.includes('```');
+        const isQuoteBlocksUsed = /^>\s+/m.test(pipelineString);
+        const isBlocksUsed = isBacktickBlockUsed || isQuoteBlocksUsed;
         // TODO: [🧉] Also (double)check
         // > const usedCommands
         // > const isBlocksUsed
         // > const returnStatementCount
-        var isFlat = !isMarkdownBeginningWithHeadline && !isBlocksUsed; /* && isLastLineReturnStatement */
+        const isFlat = !isMarkdownBeginningWithHeadline && !isBlocksUsed; /* && isLastLineReturnStatement */
         return isFlat;
     }
 
@@ -3917,27 +3856,39 @@
         if (!isFlatPipeline(pipelineString)) {
             return pipelineString;
         }
-        var pipelineStringLines = pipelineString.split('\n');
-        var potentialReturnStatement = pipelineStringLines.pop();
-        var returnStatement;
+        const pipelineStringLines = pipelineString.split('\n');
+        const potentialReturnStatement = pipelineStringLines.pop();
+        let returnStatement;
         if (/(-|=)>\s*\{.*\}/.test(potentialReturnStatement)) {
             // Note: Last line is return statement
             returnStatement = potentialReturnStatement;
         }
         else {
             // Note: Last line is not a return statement
-            returnStatement = "-> {".concat(DEFAULT_BOOK_OUTPUT_PARAMETER_NAME, "}");
+            returnStatement = `-> {${DEFAULT_BOOK_OUTPUT_PARAMETER_NAME}}`;
             pipelineStringLines.push(potentialReturnStatement);
         }
-        var prompt = spaceTrim__default["default"](pipelineStringLines.join('\n'));
-        var quotedPrompt;
+        const prompt = spaceTrim__default["default"](pipelineStringLines.join('\n'));
+        let quotedPrompt;
         if (prompt.split('\n').length <= 1) {
-            quotedPrompt = "> ".concat(prompt);
+            quotedPrompt = `> ${prompt}`;
         }
         else {
-            quotedPrompt = spaceTrim__default["default"](function (block) { return "\n                ```\n                ".concat(block(prompt.split('`').join('\\`')), "\n                ```\n            "); });
+            quotedPrompt = spaceTrim__default["default"]((block) => `
+                \`\`\`
+                ${block(prompt.split('`').join('\\`'))}
+                \`\`\`
+            `);
         }
-        pipelineString = validatePipelineString(spaceTrim__default["default"](function (block) { return "\n                # ".concat(DEFAULT_BOOK_TITLE, "\n\n                ## Prompt\n\n                ").concat(block(quotedPrompt), "\n\n                ").concat(returnStatement, "\n            "); }));
+        pipelineString = validatePipelineString(spaceTrim__default["default"]((block) => `
+                # ${DEFAULT_BOOK_TITLE}
+
+                ## Prompt
+
+                ${block(quotedPrompt)}
+
+                ${returnStatement}
+            `));
         // <- TODO: Maybe use book` notation
         return pipelineString;
     }
@@ -3951,37 +3902,26 @@
      * @public exported from `@promptbook/editable`
      */
     function addPipelineCommand(options) {
-        var e_1, _a;
-        var commandString = options.commandString, pipelineString = options.pipelineString;
-        var deflatedPipelineString = deflatePipeline(pipelineString);
-        var lines = deflatedPipelineString.split('\n');
-        var newLines = [];
-        var isCommandAdded = false;
-        try {
-            for (var lines_1 = __values(lines), lines_1_1 = lines_1.next(); !lines_1_1.done; lines_1_1 = lines_1.next()) {
-                var line = lines_1_1.value;
-                // Add command before second (or more) heading
-                if (!isCommandAdded && line.startsWith('##')) {
-                    newLines.push("-   ".concat(commandString));
-                    newLines.push('');
-                    isCommandAdded = true;
-                }
-                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);
+        const { commandString, pipelineString } = options;
+        const deflatedPipelineString = deflatePipeline(pipelineString);
+        const lines = deflatedPipelineString.split('\n');
+        const newLines = [];
+        let isCommandAdded = false;
+        for (const line of lines) {
+            // Add command before second (or more) heading
+            if (!isCommandAdded && line.startsWith('##')) {
+                newLines.push(`-   ${commandString}`);
+                newLines.push('');
+                isCommandAdded = true;
             }
-            finally { if (e_1) throw e_1.error; }
+            newLines.push(line);
         }
         if (!isCommandAdded) {
             // Note: Only situation when this should happen is when pipeline has no tasks
             if ((newLines[newLines.length - 1] || '').startsWith('#')) {
                 newLines.push('');
             }
-            newLines.push("-   ".concat(commandString));
+            newLines.push(`-   ${commandString}`);
             /*
             TODO: [🧠] Is this error relevant:
             throw new UnexpectedError(
@@ -4021,47 +3961,36 @@
      * @public exported from `@promptbook/editable`
      */
     function removePipelineCommand(options) {
-        var e_1, _a;
-        var command = options.command, pipelineString = options.pipelineString;
-        var lines = pipelineString.split('\n');
+        const { command, pipelineString } = options;
+        const lines = pipelineString.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';
-                    }
+        let currentType = 'MARKDOWN';
+        const newLines = [];
+        for (const line of lines) {
+            if (currentType === 'MARKDOWN') {
+                if (line.startsWith('```')) {
+                    currentType = 'CODE_BLOCK';
                 }
-                else if (currentType === 'CODE_BLOCK') {
-                    if (line.startsWith('```')) {
-                        currentType = 'MARKDOWN';
-                    }
+                else if (line.includes('<!--')) {
+                    currentType = 'COMMENT';
                 }
-                else if (currentType === 'COMMENT') {
-                    if (line.includes('-->')) {
-                        currentType = 'MARKDOWN';
-                    }
+            }
+            else if (currentType === 'CODE_BLOCK') {
+                if (line.startsWith('```')) {
+                    currentType = 'MARKDOWN';
                 }
-                if (currentType === 'MARKDOWN' && /^(-|\d\))/m.test(line) && line.toUpperCase().includes(command)) {
-                    continue;
+            }
+            else if (currentType === 'COMMENT') {
+                if (line.includes('-->')) {
+                    currentType = 'MARKDOWN';
                 }
-                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);
+            if (currentType === 'MARKDOWN' && /^(-|\d\))/m.test(line) && line.toUpperCase().includes(command)) {
+                continue;
             }
-            finally { if (e_1) throw e_1.error; }
+            newLines.push(line);
         }
-        var newPipeline = spaceTrim__default["default"](newLines.join('\n'));
+        const newPipeline = spaceTrim__default["default"](newLines.join('\n'));
         return newPipeline;
     }
 
@@ -4070,16 +3999,13 @@
      *
      * @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;
+    class PipelineLogicError extends Error {
+        constructor(message) {
+            super(message);
+            this.name = 'PipelineLogicError';
+            Object.setPrototypeOf(this, PipelineLogicError.prototype);
         }
-        return PipelineLogicError;
-    }(Error));
+    }
 
     /**
      * Function `renamePipelineParameter` will find all usable parameters for given task
@@ -4089,53 +4015,33 @@
      * @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"));
+        const { pipeline: pipeline, oldParameterName, newParameterName } = options;
+        if (pipeline.parameters.some((parameter) => parameter.name === newParameterName)) {
+            throw new PipelineLogicError(`Can not replace {${oldParameterName}} to {${newParameterName}} because {${newParameterName}} is already used in the pipeline`);
         }
-        var renamedPipeline = __assign(__assign({}, pipeline), { 
+        const renamedPipeline = {
+            ...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, "}"));
+            parameters: [...pipeline.parameters],
+            tasks: [...pipeline.tasks],
+        };
+        for (const parameter of renamedPipeline.parameters) {
+            if (parameter.name !== oldParameterName) {
+                continue;
             }
+            parameter.name = newParameterName;
         }
-        catch (e_2_1) { e_2 = { error: e_2_1 }; }
-        finally {
-            try {
-                if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+        for (const task of renamedPipeline.tasks) {
+            if (task.resultingParameterName === oldParameterName) {
+                task.resultingParameterName = newParameterName;
             }
-            finally { if (e_2) throw e_2.error; }
+            task.dependentParameterNames = task.dependentParameterNames.map((dependentParameterName) => dependentParameterName === oldParameterName ? newParameterName : dependentParameterName);
+            task.content = task.content.replace(new RegExp(`{${oldParameterName}}`, 'g'), `{${newParameterName}}`);
+            task.title = task.title.replace(new RegExp(`{${oldParameterName}}`, 'g'), `{${newParameterName}}`);
+            task.description =
+                task.description === undefined
+                    ? undefined
+                    : task.description.replace(new RegExp(`{${oldParameterName}}`, 'g'), `{${newParameterName}}`);
         }
         return renamedPipeline;
     }
@@ -4165,7 +4071,7 @@
      */
     function isSerializableAsJson(value) {
         try {
-            checkSerializableAsJson({ value: value });
+            checkSerializableAsJson({ value });
             return true;
         }
         catch (error) {
@@ -4187,11 +4093,17 @@
      */
     function stringifyPipelineJson(pipeline) {
         if (!isSerializableAsJson(pipeline)) {
-            throw new UnexpectedError(spaceTrim__default["default"]("\n                Cannot stringify the pipeline, because it is not serializable as JSON\n\n                There can be multiple reasons:\n                1) The pipeline contains circular references\n                2) It is not a valid PipelineJson\n            "));
+            throw new UnexpectedError(spaceTrim__default["default"](`
+                Cannot stringify the pipeline, because it is not serializable as JSON
+
+                There can be multiple reasons:
+                1) The pipeline contains circular references
+                2) It is not a valid PipelineJson
+            `));
         }
-        var pipelineJsonStringified = JSON.stringify(pipeline, null, 4);
-        for (var i = 0; i < LOOP_LIMIT; i++) {
-            pipelineJsonStringified = pipelineJsonStringified.replace(/(-?0\.\d+),[\n\s]+(-?0\.\d+)/gms, "$1".concat(REPLACING_NONCE, "$2"));
+        let pipelineJsonStringified = JSON.stringify(pipeline, null, 4);
+        for (let i = 0; i < LOOP_LIMIT; i++) {
+            pipelineJsonStringified = pipelineJsonStringified.replace(/(-?0\.\d+),[\n\s]+(-?0\.\d+)/gms, `$1${REPLACING_NONCE}$2`);
         }
         pipelineJsonStringified = pipelineJsonStringified.split(REPLACING_NONCE).join(', ');
         pipelineJsonStringified += '\n';