@promptbook/editable 0.86.10 → 0.86.22

package/esm/index.es.js

@@ -1,5 +1,5 @@
 import spaceTrim, { spaceTrim as spaceTrim$1 } from 'spacetrim';
-import { unparse, parse } from 'papaparse';
+import { parse, unparse } from 'papaparse';
 import { SHA256 } from 'crypto-js';
 import hexEncoder from 'crypto-js/enc-hex';
 
@@ -10,138 +10,19 @@ import hexEncoder from 'crypto-js/enc-hex';
  * @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.22';
 /**
  * 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.
@@ -169,38 +50,38 @@ function just(value) {
  *
  * @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: [🧜‍♂️]
 /**
  * @@@
@@ -224,11 +105,37 @@ Object.freeze({
  * @private private within the repository
  */
 function getErrorReportUrl(error) {
-    var report = {
-        title: "\uD83D\uDC1C Error report from ".concat(NAME),
-        body: spaceTrim(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((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);
@@ -241,32 +148,37 @@ function getErrorReportUrl(error) {
  *
  * @public exported from `@promptbook/core`
  */
-var UnexpectedError = /** @class */ (function (_super) {
-    __extends(UnexpectedError, _super);
-    function UnexpectedError(message) {
-        var _this = _super.call(this, spaceTrim$1(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$1((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`
  */
@@ -279,7 +191,7 @@ var ParseError = /** @class */ (function (_super) {
  * @see `documentationUrl` for more details
  * @private within the commands folder
  */
-var boilerplateCommandParser = {
+const boilerplateCommandParser = {
     /**
      * Name of the command
      */
@@ -296,7 +208,7 @@ var boilerplateCommandParser = {
     /**
      * Description of the BOILERPLATE command
      */
-    description: "@@",
+    description: `@@`,
     /**
      * Link to documentation
      */
@@ -308,18 +220,18 @@ var boilerplateCommandParser = {
     /**
      * 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,
         };
     },
     /**
@@ -327,40 +239,40 @@ var boilerplateCommandParser = {
      *
      * 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`);
     },
 };
 
@@ -369,16 +281,23 @@ var boilerplateCommandParser = {
  *
  * @public exported from `@promptbook/core`
  */
-var NotYetImplementedError = /** @class */ (function (_super) {
-    __extends(NotYetImplementedError, _super);
-    function NotYetImplementedError(message) {
-        var _this = _super.call(this, spaceTrim$1(function (block) { return "\n                    ".concat(block(message), "\n\n                    Note: This feature is not implemented yet but it will be soon.\n\n                    If you want speed up the implementation or just read more, look here:\n                    https://github.com/webgptorg/promptbook\n\n                    Or contact us on pavol@ptbk.io\n\n                "); })) || this;
-        _this.name = 'NotYetImplementedError';
-        Object.setPrototypeOf(_this, NotYetImplementedError.prototype);
-        return _this;
+class NotYetImplementedError extends Error {
+    constructor(message) {
+        super(spaceTrim$1((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
@@ -428,7 +347,7 @@ function isValidPromptbookVersion(version) {
  * @see `documentationUrl` for more details
  * @public exported from `@promptbook/editable`
  */
-var bookVersionCommandParser = {
+const bookVersionCommandParser = {
     /**
      * Name of the command
      */
@@ -442,7 +361,7 @@ var bookVersionCommandParser = {
     /**
      * 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
      */
@@ -450,21 +369,21 @@ var bookVersionCommandParser = {
     /**
      * 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',
@@ -476,7 +395,7 @@ var bookVersionCommandParser = {
      *
      * 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;
     },
@@ -485,16 +404,16 @@ var bookVersionCommandParser = {
      *
      * 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
     },
 };
 
@@ -504,7 +423,7 @@ var bookVersionCommandParser = {
  * @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
  */
@@ -521,7 +440,7 @@ var EXPECTATION_UNITS = ['CHARACTERS', 'WORDS', 'SENTENCES', 'LINES', 'PARAGRAPH
  * @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
     }
@@ -533,7 +452,7 @@ function parseNumber(value) {
         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
         }
@@ -548,11 +467,11 @@ function parseNumber(value) {
         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;
     }
@@ -560,15 +479,15 @@ function parseNumber(value) {
         return 0;
     }
     if (value.includes('E')) {
-        var _b = __read(value.split('E'), 2), significand = _b[0], exponent = _b[1];
-        return parseNumber(significand) * Math.pow(10, parseNumber(exponent));
+        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;
 }
@@ -583,7 +502,7 @@ function parseNumber(value) {
  * @see `documentationUrl` for more details
  * @public exported from `@promptbook/editable`
  */
-var expectCommandParser = {
+const expectCommandParser = {
     /**
      * Name of the command
      */
@@ -596,7 +515,10 @@ var expectCommandParser = {
     /**
      * Description of the FORMAT command
      */
-    description: spaceTrim("\n        Expect command describes the desired output of the task *(after post-processing)*\n        It can set limits for the maximum/minimum length of the output, measured in characters, words, sentences, paragraphs or some other shape of the output.\n    "),
+    description: spaceTrim(`
+        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
      */
@@ -614,12 +536,11 @@ var expectCommandParser = {
     /**
      * 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';
             }
@@ -630,59 +551,50 @@ var expectCommandParser = {
                 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(function (block) {
-                return "\n                            Invalid FORMAT command\n                            ".concat(block(error.message), ":\n                        ");
-            }));
+            throw new ParseError(spaceTrim((block) => `
+                            Invalid FORMAT command
+                            ${block(error.message)}:
+                        `));
         }
     },
     /**
@@ -690,20 +602,20 @@ var expectCommandParser = {
      *
      * 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;
         }
@@ -713,16 +625,16 @@ var expectCommandParser = {
      *
      * 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
     },
 };
 
@@ -734,40 +646,34 @@ var expectCommandParser = {
  *
  * @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',
 });
@@ -778,92 +684,76 @@ var MANDATORY_CSV_SETTINGS = Object.freeze({
  * @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 = parse(value, __assign(__assign({}, settings), MANDATORY_CSV_SETTINGS));
-                                if (csv.errors.length !== 0) {
-                                    throw new CsvFormatError(spaceTrim(function (block) { return "\n                                CSV parsing error\n\n                                Error(s) from CSV parsing:\n                                ".concat(block(csv.errors.map(function (error) { return error.message; }).join('\n\n')), "\n\n                                The CSV setings:\n                                ").concat(block(JSON.stringify(__assign(__assign({}, settings), MANDATORY_CSV_SETTINGS), null, 2)), "\n\n                                The CSV data:\n                                ").concat(block(value), "\n                            "); }));
-                                }
-                                return [4 /*yield*/, Promise.all(csv.data.map(function (row, index) { return __awaiter(_this, void 0, void 0, function () {
-                                        var _a, _b;
-                                        var _c;
-                                        return __generator(this, function (_d) {
-                                            switch (_d.label) {
-                                                case 0:
-                                                    if (row[outputParameterName]) {
-                                                        throw new CsvFormatError("Can not overwrite existing column \"".concat(outputParameterName, "\" in CSV row"));
-                                                    }
-                                                    _a = [__assign({}, row)];
-                                                    _c = {};
-                                                    _b = outputParameterName;
-                                                    return [4 /*yield*/, mapCallback(row, index)];
-                                                case 1: return [2 /*return*/, __assign.apply(void 0, _a.concat([(_c[_b] = _d.sent(), _c)]))];
-                                            }
-                                        });
-                                    }); }))];
-                            case 1:
-                                mappedData = _a.sent();
-                                return [2 /*return*/, unparse(mappedData, __assign(__assign({}, settings), MANDATORY_CSV_SETTINGS))];
-                        }
-                    });
-                });
+            async mapValues(value, outputParameterName, settings, mapCallback) {
+                // TODO: [👨🏾‍🤝‍👨🏼] DRY csv parsing
+                const csv = parse(value, { ...settings, ...MANDATORY_CSV_SETTINGS });
+                if (csv.errors.length !== 0) {
+                    throw new CsvFormatError(spaceTrim((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 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 = parse(value, __assign(__assign({}, settings), MANDATORY_CSV_SETTINGS));
-                                if (csv.errors.length !== 0) {
-                                    throw new CsvFormatError(spaceTrim(function (block) { return "\n                                CSV parsing error\n\n                                Error(s) from CSV parsing:\n                                ".concat(block(csv.errors.map(function (error) { return error.message; }).join('\n\n')), "\n\n                                The CSV setings:\n                                ").concat(block(JSON.stringify(__assign(__assign({}, settings), MANDATORY_CSV_SETTINGS), null, 2)), "\n\n                                The CSV data:\n                                ").concat(block(value), "\n                            "); }));
-                                }
-                                return [4 /*yield*/, Promise.all(csv.data.map(function (row, rowIndex) { return __awaiter(_this, void 0, void 0, function () {
-                                        var _this = this;
-                                        return __generator(this, function (_a) {
-                                            return [2 /*return*/, /* not await */ Promise.all(Object.entries(row).map(function (_a, columnIndex) {
-                                                    var _b = __read(_a, 2), key = _b[0], value = _b[1];
-                                                    return __awaiter(_this, void 0, void 0, function () {
-                                                        var index;
-                                                        var _c;
-                                                        return __generator(this, function (_d) {
-                                                            index = rowIndex * Object.keys(row).length + columnIndex;
-                                                            return [2 /*return*/, /* not await */ mapCallback((_c = {}, _c[key] = value, _c), index)];
-                                                        });
-                                                    });
-                                                }))];
-                                        });
-                                    }); }))];
-                            case 1:
-                                mappedData = _a.sent();
-                                return [2 /*return*/, unparse(mappedData, __assign(__assign({}, settings), MANDATORY_CSV_SETTINGS))];
-                        }
-                    });
-                });
+            async mapValues(value, outputParameterName, settings, mapCallback) {
+                // TODO: [👨🏾‍🤝‍👨🏼] DRY csv parsing
+                const csv = parse(value, { ...settings, ...MANDATORY_CSV_SETTINGS });
+                if (csv.errors.length !== 0) {
+                    throw new CsvFormatError(spaceTrim((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 unparse(mappedData, { ...settings, ...MANDATORY_CSV_SETTINGS });
             },
         },
     ],
@@ -902,16 +792,16 @@ function isValidJsonString(value /* <- [👨‍⚖️] */) {
  *
  * @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: [],
@@ -935,48 +825,37 @@ var JsonFormatDefinition = {
  *
  * @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
@@ -989,16 +868,16 @@ var TextFormatDefinition = {
  *
  * @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: [],
@@ -1020,7 +899,7 @@ var XmlFormatDefinition = {
  *
  * @private internal index of `...` <- TODO [🏢]
  */
-var FORMAT_DEFINITIONS = [
+const FORMAT_DEFINITIONS = [
     JsonFormatDefinition,
     XmlFormatDefinition,
     TextFormatDefinition,
@@ -1040,46 +919,35 @@ var FORMAT_DEFINITIONS = [
  * @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, '/');
@@ -1103,8 +971,11 @@ function normalizeTo_SCREAMING_CASE(text) {
  * @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;
 }
 
@@ -1118,26 +989,15 @@ function orderJson(options) {
  * @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;
@@ -1167,10 +1027,9 @@ function $deepFreeze(objectValue) {
  * @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;
@@ -1185,49 +1044,54 @@ function checkSerializableAsJson(options) {
         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(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((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(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((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]
@@ -1236,7 +1100,14 @@ function checkSerializableAsJson(options) {
                 if (!(error instanceof Error)) {
                     throw error;
                 }
-                throw new UnexpectedError(spaceTrim(function (block) { return "\n                            `".concat(name, "` is not serializable\n\n                            ").concat(block(error.stack || error.message), "\n\n                            Additional message for `").concat(name, "`:\n                            ").concat(block(message || '(nothing)'), "\n                        "); }));
+                throw new UnexpectedError(spaceTrim((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?
@@ -1261,7 +1132,12 @@ function checkSerializableAsJson(options) {
         }
     }
     else {
-        throw new UnexpectedError(spaceTrim(function (block) { return "\n                    `".concat(name, "` is unknown type\n\n                    Additional message for `").concat(name, "`:\n                    ").concat(block(message || '(nothing)'), "\n                "); }));
+        throw new UnexpectedError(spaceTrim((block) => `
+                    \`${name}\` is unknown type
+
+                    Additional message for \`${name}\`:
+                    ${block(message || '(nothing)')}
+                `));
     }
 }
 /**
@@ -1307,9 +1183,9 @@ function deepClone(objectValue) {
  * @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
@@ -1332,15 +1208,15 @@ function exportJson(options) {
  *
  * @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',
@@ -1367,53 +1243,41 @@ var RESERVED_PARAMETER_NAMES = exportJson({
  * @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;
 }
@@ -1421,7 +1285,7 @@ function normalizeTo_camelCase(text, _isFirstLetterCapital) {
  * 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',
@@ -1640,12 +1504,12 @@ var defaultDiacriticsRemovalMap = [
  *
  * @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;
     }
 }
@@ -1674,7 +1538,7 @@ for (var i = 0; i < defaultDiacriticsRemovalMap.length; i++) {
  */
 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;
     });
 }
@@ -1730,33 +1594,22 @@ function removeQuotes(text) {
  * @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 {
         /*
@@ -1766,10 +1619,10 @@ function validateParameterName(parameterName) {
         }
         */
         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(')') ||
@@ -1777,24 +1630,29 @@ function validateParameterName(parameterName) {
             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(function (block) { return "\n                    ".concat(block(error.message), "\n\n                    Tried to validate parameter name:\n                    ").concat(block(rawParameterName), "\n                "); }));
+        throw new ParseError(spaceTrim((block) => `
+                    ${block(error.message)}
+
+                    Tried to validate parameter name:
+                    ${block(rawParameterName)}
+                `));
     }
     return parameterName;
 }
@@ -1807,7 +1665,7 @@ function validateParameterName(parameterName) {
  * @see `documentationUrl` for more details
  * @public exported from `@promptbook/editable`
  */
-var foreachCommandParser = {
+const foreachCommandParser = {
     /**
      * Name of the command
      */
@@ -1824,7 +1682,7 @@ var foreachCommandParser = {
     /**
      * Description of the FOREACH command
      */
-    description: "@@",
+    description: `@@`,
     /**
      * Link to documentation
      */
@@ -1842,58 +1700,64 @@ var foreachCommandParser = {
     /**
      * 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(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((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(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((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
@@ -1904,16 +1768,22 @@ var foreachCommandParser = {
                 outputSubparameterName = 'newLine';
             }
             else {
-                throw new ParseError(spaceTrim("\n                        FOREACH ".concat(formatName, " ").concat(subformatName, " must specify output subparameter\n\n                        Correct example:\n                        - FOREACH ").concat(formatName, " ").concat(subformatName, " {").concat(parameterName, "} -> {inputSubparameterName1}, {inputSubparameterName2}, +{outputSubparameterName}\n\n                    ")));
+                throw new ParseError(spaceTrim(`
+                        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,
         };
     },
     /**
@@ -1921,16 +1791,16 @@ var foreachCommandParser = {
      *
      * 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
     },
@@ -1939,16 +1809,16 @@ var foreachCommandParser = {
      *
      * 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
     },
 };
 /**
@@ -1961,7 +1831,7 @@ var foreachCommandParser = {
  * @see `documentationUrl` for more details
  * @public exported from `@promptbook/editable`
  */
-var formatCommandParser = {
+const formatCommandParser = {
     /**
      * Name of the command
      */
@@ -1974,7 +1844,10 @@ var formatCommandParser = {
     /**
      * Description of the FORMAT command
      */
-    description: spaceTrim("\n        Format command describes the desired output of the task (after post-processing)\n        It can set limits for the maximum/minimum length of the output, measured in characters, words, sentences, paragraphs or some other shape of the output.\n    "),
+    description: spaceTrim(`
+        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
      */
@@ -1986,10 +1859,10 @@ var formatCommandParser = {
     /**
      * 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',
@@ -2003,9 +1876,10 @@ var formatCommandParser = {
      *
      * 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;
     },
@@ -2014,16 +1888,16 @@ var formatCommandParser = {
      *
      * 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
     },
 };
 
@@ -2032,31 +1906,31 @@ var formatCommandParser = {
  *
  * @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 },
         ],
     },
 };
@@ -2066,15 +1940,15 @@ var ChatbotFormfactorDefinition = {
  *
  * @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,
             },
@@ -2082,7 +1956,7 @@ var GeneratorFormfactorDefinition = {
         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,
             },
@@ -2097,7 +1971,7 @@ var GeneratorFormfactorDefinition = {
  *
  * @public exported from `@promptbook/core`
  */
-var GENERIC_PIPELINE_INTERFACE = {
+const GENERIC_PIPELINE_INTERFACE = {
     inputParameters: [],
     outputParameters: [],
 };
@@ -2110,10 +1984,10 @@ var GENERIC_PIPELINE_INTERFACE = {
  *
  * @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,
 };
 
@@ -2122,15 +1996,15 @@ var GenericFormfactorDefinition = {
  *
  * @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,
             },
@@ -2138,7 +2012,7 @@ var ImageGeneratorFormfactorDefinition = {
         outputParameters: [
             {
                 name: 'prompt',
-                description: "Prompt to be used for image generation",
+                description: `Prompt to be used for image generation`,
                 isInput: false,
                 isOutput: true,
             },
@@ -2151,10 +2025,10 @@ var ImageGeneratorFormfactorDefinition = {
  *
  * @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: [
             /* @@@ */
@@ -2176,16 +2050,16 @@ var MatcherFormfactorDefinition = {
  *
  * @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,
             },
@@ -2193,7 +2067,7 @@ var SheetsFormfactorDefinition = {
         outputParameters: [
             {
                 name: 'outputSheet',
-                description: "Output sheet as csv",
+                description: `Output sheet as csv`,
                 isInput: false,
                 isOutput: true,
             },
@@ -2206,15 +2080,15 @@ var SheetsFormfactorDefinition = {
  *
  * @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,
             },
@@ -2222,7 +2096,7 @@ var TranslatorFormfactorDefinition = {
         outputParameters: [
             {
                 name: 'outputMessage',
-                description: "Translated output message",
+                description: `Translated output message`,
                 isInput: false,
                 isOutput: true,
             },
@@ -2237,7 +2111,7 @@ var TranslatorFormfactorDefinition = {
  *
  * @public exported from `@promptbook/core`
  */
-var FORMFACTOR_DEFINITIONS = [
+const FORMFACTOR_DEFINITIONS = [
     GenericFormfactorDefinition,
     ChatbotFormfactorDefinition,
     TranslatorFormfactorDefinition,
@@ -2258,7 +2132,7 @@ var FORMFACTOR_DEFINITIONS = [
  * @see `documentationUrl` for more details
  * @public exported from `@promptbook/editable`
  */
-var formfactorCommandParser = {
+const formfactorCommandParser = {
     /**
      * Name of the command
      */
@@ -2275,7 +2149,7 @@ var formfactorCommandParser = {
     /**
      * Description of the FORMFACTOR command
      */
-    description: "@@",
+    description: `@@`,
     /**
      * Link to documentation
      */
@@ -2287,20 +2161,20 @@ var formfactorCommandParser = {
     /**
      * 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(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((block) => `
+                        Unknown formfactor name "${formfactorNameCandidate}"
+
+                        Available formfactors:
+                        ${block(FORMFACTOR_DEFINITIONS.map(({ name }) => `- ${name}`).join('\n'))}
+                    `));
         }
         return {
             type: 'FORMFACTOR',
@@ -2312,9 +2186,15 @@ var formfactorCommandParser = {
      *
      * 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("\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(`
+                    Redefinition of \`FORMFACTOR\` in the pipeline head
+
+                    You have used:
+                    1) FORMFACTOR \`${$pipelineJson.formfactorName}\`
+                    2) FORMFACTOR \`${command.formfactorName}\`
+                `));
         }
         $pipelineJson.formfactorName = command.formfactorName;
     },
@@ -2323,15 +2203,15 @@ var formfactorCommandParser = {
      *
      * 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',
@@ -2347,7 +2227,7 @@ var formfactorCommandParser = {
  * @see `documentationUrl` for more details
  * @public exported from `@promptbook/editable`
  */
-var jokerCommandParser = {
+const jokerCommandParser = {
     /**
      * Name of the command
      */
@@ -2360,7 +2240,7 @@ var jokerCommandParser = {
     /**
      * 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
      */
@@ -2372,16 +2252,16 @@ var jokerCommandParser = {
     /**
      * 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,
         };
     },
     /**
@@ -2389,7 +2269,7 @@ var jokerCommandParser = {
      *
      * 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);
     },
@@ -2398,16 +2278,16 @@ var jokerCommandParser = {
      *
      * 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
     },
 };
 
@@ -2428,7 +2308,7 @@ function isValidFilePath(filename) {
         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');
@@ -2478,7 +2358,7 @@ function isValidUrl(url) {
         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;
         }
@@ -2499,47 +2379,36 @@ function isValidUrl(url) {
  * @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('/');
@@ -2557,14 +2426,14 @@ function normalizeToKebabCase(text) {
  * @public exported from `@promptbook/editable`
  */
 function knowledgeSourceContentToName(knowledgeSourceContent) {
-    var hash = SHA256(hexEncoder.parse(JSON.stringify(knowledgeSourceContent)))
+    const hash = SHA256(hexEncoder.parse(JSON.stringify(knowledgeSourceContent)))
         //    <- TODO: [🥬] Encapsulate sha256 to some private utility function
         .toString( /* hex */)
         .substring(0, 20);
     //    <- TODO: [🥬] Make some system for hashes and ids of promptbook
-    var semanticName = normalizeToKebabCase(knowledgeSourceContent.substring(0, 20));
-    var pieces = ['source', semanticName, hash].filter(function (piece) { return piece !== ''; });
-    var name = pieces.join('-').split('--').join('-');
+    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;
 }
@@ -2578,7 +2447,7 @@ function knowledgeSourceContentToName(knowledgeSourceContent) {
  * @see `documentationUrl` for more details
  * @public exported from `@promptbook/editable`
  */
-var knowledgeCommandParser = {
+const knowledgeCommandParser = {
     /**
      * Name of the command
      */
@@ -2591,7 +2460,7 @@ var knowledgeCommandParser = {
     /**
      * Description of the KNOWLEDGE command
      */
-    description: "Tells promptbook which external knowledge to use",
+    description: `Tells promptbook which external knowledge to use`,
     /**
      * Link to documentation
      */
@@ -2610,27 +2479,27 @@ var knowledgeCommandParser = {
     /**
      * Parses the KNOWLEDGE command
      */
-    parse: function (input) {
-        var args = input.args;
-        var knowledgeSourceContent = spaceTrim(args[0] || '');
+    parse(input) {
+        const { args } = input;
+        const knowledgeSourceContent = spaceTrim(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,
         };
     },
     /**
@@ -2638,11 +2507,11 @@ var knowledgeCommandParser = {
      *
      * 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,
         });
     },
     /**
@@ -2650,16 +2519,16 @@ var knowledgeCommandParser = {
      *
      * 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
     },
 };
 /**
@@ -2671,7 +2540,7 @@ var knowledgeCommandParser = {
  *
  * @public exported from `@promptbook/core`
  */
-var MODEL_VARIANTS = ['COMPLETION', 'CHAT', 'EMBEDDING' /* <- TODO [🏳] */ /* <- [🤖] */];
+const MODEL_VARIANTS = ['COMPLETION', 'CHAT', 'EMBEDDING' /* <- TODO [🏳] */ /* <- [🤖] */];
 
 /**
  * Parses the model command
@@ -2680,7 +2549,7 @@ var MODEL_VARIANTS = ['COMPLETION', 'CHAT', 'EMBEDDING' /* <- TODO [🏳] */ /*
  * @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
      */
@@ -2693,7 +2562,7 @@ var modelCommandParser = {
     /**
      * 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
      */
@@ -2705,11 +2574,12 @@ var modelCommandParser = {
     /**
      * Parses the MODEL command
      */
-    parse: function (input) {
-        var args = input.args, normalized = input.normalized;
-        var availableVariantsMessage = spaceTrim(function (block) { return "\n              Available variants are:\n              ".concat(block(MODEL_VARIANTS.map(function (variantName) {
-            return "- ".concat(variantName).concat(variantName !== 'EMBEDDING' ? '' : ' (Not available in pipeline)');
-        }).join('\n')), "\n          "); });
+    parse(input) {
+        const { args, normalized } = input;
+        const availableVariantsMessage = spaceTrim((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') {
@@ -2728,10 +2598,18 @@ var modelCommandParser = {
                 // <- Note: [🤖]
             }
             else if (normalized.startsWith('MODEL_VARIANT_EMBED')) {
-                spaceTrim(function (block) { return "\n                        Embedding model can not be used in pipeline\n\n                        ".concat(block(availableVariantsMessage), "\n                    "); });
+                spaceTrim((block) => `
+                        Embedding model can not be used in pipeline
+
+                        ${block(availableVariantsMessage)}
+                    `);
             }
             else {
-                throw new ParseError(spaceTrim(function (block) { return "\n                            Unknown model variant in command:\n\n                            ".concat(block(availableVariantsMessage), "\n                        "); }));
+                throw new ParseError(spaceTrim((block) => `
+                            Unknown model variant in command:
+
+                            ${block(availableVariantsMessage)}
+                        `));
             }
         }
         if (normalized.startsWith('MODEL_NAME')) {
@@ -2742,7 +2620,16 @@ var modelCommandParser = {
             };
         }
         else {
-            throw new ParseError(spaceTrim(function (block) { return "\n                    Unknown model key in command.\n\n                    Supported model keys are:\n                    ".concat(block(['variant', 'name'].join(', ')), "\n\n                    Example:\n                    - MODEL VARIANT Chat\n                    - MODEL NAME gpt-4\n              "); }));
+            throw new ParseError(spaceTrim((block) => `
+                    Unknown model key in command.
+
+                    Supported model keys are:
+                    ${block(['variant', 'name'].join(', '))}
+
+                    Example:
+                    - MODEL VARIANT Chat
+                    - MODEL NAME gpt-4
+              `));
         }
     },
     /**
@@ -2750,16 +2637,22 @@ var modelCommandParser = {
      *
      * 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("\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(`
+                        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;
@@ -2769,26 +2662,40 @@ var modelCommandParser = {
      *
      * 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({
+                console.warn(`Multiple commands \`MODEL ${{
                     modelName: 'NAME',
                     modelVariant: 'VARIANT',
                     maxTokens: '???',
-                }[command.key], " ").concat(command.value, "` in the task \"").concat($taskJson.title || $taskJson.name, "\""));
+                }[command.key]} ${command.value}\` in the task "${$taskJson.title || $taskJson.name}"`);
             }
             else {
-                throw new ParseError(spaceTrim("\n                              Redefinition of MODEL `".concat(command.key, "` in the task \"").concat($taskJson.title || $taskJson.name, "\"\n\n                              You have used:\n                              - MODEL ").concat(command.key, " ").concat($taskJson.modelRequirements[command.key], "\n                              - MODEL ").concat(command.key, " ").concat(command.value, "\n                          ")));
+                throw new ParseError(spaceTrim(`
+                              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("\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(`
+                    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;
     },
@@ -2797,24 +2704,24 @@ var modelCommandParser = {
      *
      * 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
     },
 };
 
@@ -2824,7 +2731,7 @@ var modelCommandParser = {
  * @see `documentationUrl` for more details
  * @public exported from `@promptbook/editable`
  */
-var parameterCommandParser = {
+const parameterCommandParser = {
     /**
      * Name of the command
      */
@@ -2844,7 +2751,7 @@ var parameterCommandParser = {
     /**
      * Description of the PARAMETER command
      */
-    description: "Describes one parameter of the task",
+    description: `Describes one parameter of the task`,
     /**
      * Link to documentation
      */
@@ -2856,29 +2763,34 @@ var parameterCommandParser = {
     /**
      * 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(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((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,
         };
     },
     /**
@@ -2886,7 +2798,7 @@ var parameterCommandParser = {
      *
      * 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`
     },
     /**
@@ -2894,7 +2806,7 @@ var parameterCommandParser = {
      *
      * 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`
     },
     /**
@@ -2902,24 +2814,24 @@ var parameterCommandParser = {
      *
      * 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
     },
 };
 
@@ -2929,7 +2841,7 @@ var parameterCommandParser = {
  * @see `documentationUrl` for more details
  * @public exported from `@promptbook/editable`
  */
-var personaCommandParser = {
+const personaCommandParser = {
     /**
      * Name of the command
      */
@@ -2946,7 +2858,7 @@ var personaCommandParser = {
     /**
      * 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
      */
@@ -2958,21 +2870,21 @@ var personaCommandParser = {
     /**
      * 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,
         };
     },
     /**
@@ -2980,33 +2892,33 @@ var personaCommandParser = {
      *
      * 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
     },
 };
 /**
@@ -3015,14 +2927,14 @@ var personaCommandParser = {
  * 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,
@@ -3040,7 +2952,17 @@ function $applyToTaskJson(command, $taskJson, $pipelineJson) {
         persona.description = personaDescription;
         return;
     }
-    console.warn(spaceTrim("\n\n         Persona \"".concat(personaName, "\" is defined multiple times with different description:\n\n         First definition:\n         ").concat(persona.description, "\n\n         Second definition:\n         ").concat(personaDescription, "\n\n     ")));
+    console.warn(spaceTrim(`
+
+         Persona "${personaName}" is defined multiple times with different description:
+
+         First definition:
+         ${persona.description}
+
+         Second definition:
+         ${personaDescription}
+
+     `));
     persona.description += spaceTrim('\n\n' + personaDescription);
 }
 
@@ -3064,7 +2986,7 @@ function isValidJavascriptName(javascriptName) {
  * @see `documentationUrl` for more details
  * @public exported from `@promptbook/editable`
  */
-var postprocessCommandParser = {
+const postprocessCommandParser = {
     /**
      * Name of the command
      */
@@ -3078,7 +3000,7 @@ var postprocessCommandParser = {
     /**
      * 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
      */
@@ -3092,21 +3014,21 @@ var postprocessCommandParser = {
     /**
      * 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,
         };
     },
     /**
@@ -3114,7 +3036,7 @@ var postprocessCommandParser = {
      *
      * 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);
     },
@@ -3123,16 +3045,16 @@ var postprocessCommandParser = {
      *
      * 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
     },
 };
 
@@ -3145,7 +3067,7 @@ var postprocessCommandParser = {
  *
  * @public exported from `@promptbook/core`
  */
-var TaskTypes = [
+const TaskTypes = [
     'PROMPT',
     'SIMPLE',
     'SCRIPT',
@@ -3158,7 +3080,7 @@ var TaskTypes = [
  *
  * @public exported from `@promptbook/core`
  */
-var NonTaskSectionTypes = ['EXAMPLE', 'KNOWLEDGE', 'INSTRUMENT', 'ACTION'];
+const NonTaskSectionTypes = ['EXAMPLE', 'KNOWLEDGE', 'INSTRUMENT', 'ACTION'];
 /**
  * All available section types
  *
@@ -3168,7 +3090,10 @@ var NonTaskSectionTypes = ['EXAMPLE', 'KNOWLEDGE', 'INSTRUMENT', 'ACTION'];
  *
  * @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
@@ -3176,7 +3101,7 @@ var SectionTypes = __spreadArray(__spreadArray([], __read(TaskTypes.map(function
  * @see `documentationUrl` for more details
  * @public exported from `@promptbook/editable`
  */
-var sectionCommandParser = {
+const sectionCommandParser = {
     /**
      * Name of the command
      */
@@ -3207,7 +3132,7 @@ var sectionCommandParser = {
     /**
      * 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
      */
@@ -3253,21 +3178,24 @@ var sectionCommandParser = {
     /**
      * 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(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((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,
         };
     },
     /**
@@ -3275,27 +3203,30 @@ var sectionCommandParser = {
      *
      * 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("\n                    Section type is already defined in the section.\n                    It can be defined only once.\n                "));
+            throw new ParseError(spaceTrim(`
+                    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);
@@ -3329,16 +3260,16 @@ var sectionCommandParser = {
      *
      * 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
     },
 };
 /**
@@ -3391,7 +3322,7 @@ function isValidPipelineUrl(url) {
  * @see `documentationUrl` for more details
  * @public exported from `@promptbook/editable`
  */
-var urlCommandParser = {
+const urlCommandParser = {
     /**
      * Name of the command
      */
@@ -3409,7 +3340,7 @@ var urlCommandParser = {
     /**
      * Description of the URL command
      */
-    description: "Declares unique URL for the pipeline",
+    description: `Declares unique URL for the pipeline`,
     /**
      * Link to documentation
      */
@@ -3425,18 +3356,18 @@ var urlCommandParser = {
     /**
      * 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`:
@@ -3465,7 +3396,7 @@ var urlCommandParser = {
      *
      * Note: `$` is used to indicate that this function mutates given `pipelineJson`
      */
-    $applyToPipelineJson: function (command, $pipelineJson) {
+    $applyToPipelineJson(command, $pipelineJson) {
         $pipelineJson.pipelineUrl = command.pipelineUrl.href;
     },
     /**
@@ -3473,16 +3404,16 @@ var urlCommandParser = {
      *
      * 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
     },
 };
 
@@ -3492,7 +3423,7 @@ var urlCommandParser = {
  * @see `documentationUrl` for more details
  * @public exported from `@promptbook/editable`
  */
-var actionCommandParser = {
+const actionCommandParser = {
     /**
      * Name of the command
      */
@@ -3505,7 +3436,7 @@ var actionCommandParser = {
     /**
      * 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
      */
@@ -3517,8 +3448,7 @@ var actionCommandParser = {
     /**
      * Parses the ACTION command
      */
-    parse: function (input) {
-        input.args;
+    parse(input) {
         return {
             type: 'ACTION',
         };
@@ -3528,7 +3458,7 @@ var actionCommandParser = {
      *
      * 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'));
     },
     /**
@@ -3536,7 +3466,7 @@ var actionCommandParser = {
      *
      * Note: This is used in `pipelineJsonToString` utility
      */
-    stringify: function (command) {
+    stringify(command) {
         throw new NotYetImplementedError('[🛠] Actions are not implemented yet');
     },
     /**
@@ -3544,7 +3474,7 @@ var actionCommandParser = {
      *
      * Note: This is used in `pipelineJsonToString` utility
      */
-    takeFromPipelineJson: function (pipelineJson) {
+    takeFromPipelineJson(pipelineJson) {
         throw new NotYetImplementedError('[🛠] Actions are not implemented yet');
     },
 };
@@ -3558,7 +3488,7 @@ var actionCommandParser = {
  * @see `documentationUrl` for more details
  * @public exported from `@promptbook/editable`
  */
-var instrumentCommandParser = {
+const instrumentCommandParser = {
     /**
      * Name of the command
      */
@@ -3571,7 +3501,7 @@ var instrumentCommandParser = {
     /**
      * 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
      */
@@ -3583,8 +3513,7 @@ var instrumentCommandParser = {
     /**
      * Parses the INSTRUMENT command
      */
-    parse: function (input) {
-        input.args;
+    parse(input) {
         return {
             type: 'INSTRUMENT',
         };
@@ -3594,7 +3523,7 @@ var instrumentCommandParser = {
      *
      * 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'));
     },
     /**
@@ -3602,7 +3531,7 @@ var instrumentCommandParser = {
      *
      * Note: This is used in `pipelineJsonToString` utility
      */
-    stringify: function (command) {
+    stringify(command) {
         throw new NotYetImplementedError('[🛠] Instruments are not implemented yet');
     },
     /**
@@ -3610,7 +3539,7 @@ var instrumentCommandParser = {
      *
      * Note: This is used in `pipelineJsonToString` utility
      */
-    takeFromPipelineJson: function (pipelineJson) {
+    takeFromPipelineJson(pipelineJson) {
         throw new NotYetImplementedError('[🛠] Instruments are not implemented yet');
     },
 };
@@ -3623,7 +3552,7 @@ var instrumentCommandParser = {
  *
  * @public exported from `@promptbook/editable`
  */
-var COMMANDS = [
+const COMMANDS = [
     sectionCommandParser,
     expectCommandParser,
     formatCommandParser,
@@ -3655,12 +3584,16 @@ var COMMANDS = [
  * @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$1(function (block) { return "\n                    Command ".concat(command.type, " parser is not found\n\n                    ").concat(block(JSON.stringify(command, null, 4)
+        throw new UnexpectedError(spaceTrim$1((block) => `
+                    Command ${command.type} parser is not found
+
+                    ${block(JSON.stringify(command, null, 4)
             .split('\n')
-            .map(function (line) { return "> ".concat(line); })
-            .join('\n')), "\n                "); }));
+            .map((line) => `> ${line}`)
+            .join('\n'))}
+                `));
     }
     return commandParser;
 }
@@ -3695,7 +3628,7 @@ function parseCommand(raw, usagePlace) {
         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('');
@@ -3705,7 +3638,7 @@ function parseCommand(raw, usagePlace) {
     normalized = normalized.split('(').join('');
     normalized = normalized.split(')').join('');
     normalized = normalizeTo_SCREAMING_CASE(normalized);
-    var items = raw
+    const items = raw
         .trim()
         // Note: [🐡]
         .split(/^>/)
@@ -3724,25 +3657,30 @@ function parseCommand(raw, usagePlace) {
         .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$1(function (block) {
-            return "\n                        Malformed command:\n                        - ".concat(raw, "\n\n                        Supported commands are:\n                        ").concat(block(getSupportedCommandsMessage()), "\n\n                    ");
-        }));
+        throw new ParseError(spaceTrim$1((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;
         }
@@ -3750,78 +3688,79 @@ function parseCommand(raw, usagePlace) {
     // 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$1(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$1((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$1(function (block) {
-                    return "\n                              Invalid ".concat(commandName, " command:\n\n                              Your command:\n                              - ").concat(raw, "\n\n                              The detailed error:\n                              ").concat(block(error.message), "\n\n                              Usage of ").concat(commandName, ":\n                              ").concat(block(commandParser.examples.map(function (example) { return "- ".concat(example); }).join('\n')), "\n\n                              All supported commands are:\n                              ").concat(block(getSupportedCommandsMessage()), "\n\n                          ");
-                }));
+                throw new ParseError(spaceTrim$1((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;
 }
@@ -3855,13 +3794,13 @@ function validatePipelineString(pipelineString) {
         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;
@@ -3889,16 +3828,16 @@ function removeMarkdownComments(content) {
 function isFlatPipeline(pipelineString) {
     pipelineString = removeMarkdownComments(pipelineString);
     pipelineString = spaceTrim(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;
 }
 
@@ -3911,27 +3850,39 @@ function deflatePipeline(pipelineString) {
     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(pipelineStringLines.join('\n'));
-    var quotedPrompt;
+    const prompt = spaceTrim(pipelineStringLines.join('\n'));
+    let quotedPrompt;
     if (prompt.split('\n').length <= 1) {
-        quotedPrompt = "> ".concat(prompt);
+        quotedPrompt = `> ${prompt}`;
     }
     else {
-        quotedPrompt = spaceTrim(function (block) { return "\n                ```\n                ".concat(block(prompt.split('`').join('\\`')), "\n                ```\n            "); });
+        quotedPrompt = spaceTrim((block) => `
+                \`\`\`
+                ${block(prompt.split('`').join('\\`'))}
+                \`\`\`
+            `);
     }
-    pipelineString = validatePipelineString(spaceTrim(function (block) { return "\n                # ".concat(DEFAULT_BOOK_TITLE, "\n\n                ## Prompt\n\n                ").concat(block(quotedPrompt), "\n\n                ").concat(returnStatement, "\n            "); }));
+    pipelineString = validatePipelineString(spaceTrim((block) => `
+                # ${DEFAULT_BOOK_TITLE}
+
+                ## Prompt
+
+                ${block(quotedPrompt)}
+
+                ${returnStatement}
+            `));
     // <- TODO: Maybe use book` notation
     return pipelineString;
 }
@@ -3945,37 +3896,26 @@ function deflatePipeline(pipelineString) {
  * @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(
@@ -4015,47 +3955,36 @@ function addPipelineCommand(options) {
  * @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(newLines.join('\n'));
+    const newPipeline = spaceTrim(newLines.join('\n'));
     return newPipeline;
 }
 
@@ -4064,16 +3993,13 @@ function removePipelineCommand(options) {
  *
  * @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
@@ -4083,53 +4009,33 @@ var PipelineLogicError = /** @class */ (function (_super) {
  * @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;
 }
@@ -4159,7 +4065,7 @@ function renamePipelineParameter(options) {
  */
 function isSerializableAsJson(value) {
     try {
-        checkSerializableAsJson({ value: value });
+        checkSerializableAsJson({ value });
         return true;
     }
     catch (error) {
@@ -4181,11 +4087,17 @@ function isSerializableAsJson(value) {
  */
 function stringifyPipelineJson(pipeline) {
     if (!isSerializableAsJson(pipeline)) {
-        throw new UnexpectedError(spaceTrim("\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(`
+                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';