pareto-core 0.1.0

package/dist/__internals/sync/expression/special.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.location_to_string = exports.iterate = void 0;
+exports.assert = assert;
+exports.deprecated_block = deprecated_block;
+exports.deprecated_cc = deprecated_cc;
+exports.panic = panic;
+exports.unreachable_code_path = unreachable_code_path;
+function assert(abort_callback, tester, normal_flow) {
+    const test_result = tester();
+    test_result.__extract_data(($) => {
+        abort_callback($);
+    }, () => {
+    });
+    return normal_flow();
+}
+/**
+ *
+ * this function allows to create a statement block in an expression (without changing the context)
+ *
+ * example:
+ *
+ * const result = 5 + (() => {
+ *     const intermediate_variable = 4
+ *     return intermediate_variable
+ * })
+ */
+function deprecated_block(callback) {
+    return callback();
+}
+/**
+ * cc means 'change context'. It creates a new scope in which a variable name can be used again
+ * (usually '$', a variable name that indicates the current context in exupery)
+ *
+ * example:
+ *
+ * cc($[1], ($) => {
+ *     //here $[1] has become $
+ * })
+ *
+ * @param input
+ * @param callback
+ * @returns
+ */
+function deprecated_cc(input, callback) {
+    return callback(input);
+}
+const iterate = ($, handler) => {
+    const length = $.__get_number_of_elements();
+    let position = 0;
+    return handler({
+        'look': () => {
+            return $.__get_element_at_raw(position);
+        },
+        'look ahead': (offset) => {
+            return $.__get_element_at_raw(position + offset);
+        },
+        'consume': (callback, abort) => {
+            const current = $.__get_element_at(position, () => abort(position));
+            position += 1;
+            const result = callback(current, position);
+            return result;
+        },
+        'discard': (callback) => {
+            position += 1;
+            return callback();
+        },
+        'get position': () => {
+            return position;
+        },
+        'assert finished': (callback, abort) => {
+            const result = callback();
+            if (position < length) {
+                return abort(null);
+            }
+            return result;
+        }
+    });
+};
+exports.iterate = iterate;
+const location_to_string = ($) => {
+    return `${$.file}:${$.line}:${$.column}`;
+};
+exports.location_to_string = location_to_string;
+/**
+ * call this function if an error is en encountered that is unrecoverable
+ * and the application should terminate immediately
+ * this avoids throwing an Error because those can always be caught, which could lead to
+ * misuse of library functionality
+ *
+ * @param message message to be printed on stderr
+ */
+function panic(...message) {
+    throw new Error(`PANIC: ${message.join(" ")}`);
+}
+/**
+ * call this function if an error is en encountered that is unrecoverable
+ * and the application should terminate immediately
+ * this avoids throwing an Error because those can always be caught, which could lead to
+ * misuse of library functionality
+ *
+ * @param message message to be printed on stderr
+ */
+function unreachable_code_path() {
+    throw new Error(`PANIC; this should have been an unreachable code path`);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/__internals/sync/extracts/literal.d.ts

@@ -0,0 +1,20 @@
+import { $$ as dictionary_literal } from "../expression/literals/dictionary";
+import { $$ as list_literal } from "../expression/literals/list";
+import * as initialize from "../expression/initialize";
+export declare namespace dictionary {
+    const literal: typeof dictionary_literal;
+}
+export declare namespace integer {
+}
+export declare namespace list {
+    const literal: typeof list_literal;
+    const nested_literal: <T extends initialize.list.NonUndefined | {}>(lists: (undefined | T[] | import("../../../interface").List<T>)[]) => import("../../../interface").List<T>;
+}
+export declare namespace natural {
+}
+export declare namespace optional {
+    const set: typeof import("../expression/literals/optional").set;
+    const not_set: typeof import("../expression/literals/optional").not_set;
+}
+export declare namespace text {
+}

package/dist/__internals/sync/extracts/literal.js

@@ -0,0 +1,54 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.optional = exports.list = exports.dictionary = void 0;
+const dictionary_1 = require("../expression/literals/dictionary");
+const list_1 = require("../expression/literals/list");
+const initialize = __importStar(require("../expression/initialize"));
+var dictionary;
+(function (dictionary) {
+    dictionary.literal = dictionary_1.$$;
+})(dictionary || (exports.dictionary = dictionary = {}));
+var list;
+(function (list) {
+    list.literal = list_1.$$;
+    list.nested_literal = initialize.list.nested_literal_old;
+})(list || (exports.list = list = {}));
+var optional;
+(function (optional) {
+    optional.set = initialize.optional.set;
+    optional.not_set = initialize.optional.not_set;
+})(optional || (exports.optional = optional = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGl0ZXJhbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9fX2ludGVybmFscy9zeW5jL2V4dHJhY3RzL2xpdGVyYWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBQ0Esa0VBQTRFO0FBQzVFLHNEQUFnRTtBQUNoRSxxRUFBc0Q7QUFFdEQsSUFBaUIsVUFBVSxDQUkxQjtBQUpELFdBQWlCLFVBQVU7SUFFVixrQkFBTyxHQUFHLGVBQWtCLENBQUE7QUFFN0MsQ0FBQyxFQUpnQixVQUFVLDBCQUFWLFVBQVUsUUFJMUI7QUFNRCxJQUFpQixJQUFJLENBS3BCO0FBTEQsV0FBaUIsSUFBSTtJQUVKLFlBQU8sR0FBRyxTQUFZLENBQUE7SUFDdEIsbUJBQWMsR0FBRyxVQUFVLENBQUMsSUFBSSxDQUFDLGtCQUFrQixDQUFBO0FBRXBFLENBQUMsRUFMZ0IsSUFBSSxvQkFBSixJQUFJLFFBS3BCO0FBTUQsSUFBaUIsUUFBUSxDQUt4QjtBQUxELFdBQWlCLFFBQVE7SUFFUixZQUFHLEdBQUcsVUFBVSxDQUFDLFFBQVEsQ0FBQyxHQUFHLENBQUE7SUFDN0IsZ0JBQU8sR0FBRyxVQUFVLENBQUMsUUFBUSxDQUFDLE9BQU8sQ0FBQTtBQUV0RCxDQUFDLEVBTGdCLFFBQVEsd0JBQVIsUUFBUSxRQUt4QiJ9

package/dist/__internals/sync/get_location_info.d.ts

@@ -0,0 +1,8 @@
+import * as _pi from "../../interface";
+/**
+ * provides the source location (filepath and line number) of the source code file where this function is called,
+ * or if the depth is bigger than 0, the source location of the function at that stack depth
+ * @param depth
+ * @returns
+ */
+export declare function $$(depth: number): _pi.Deprecated_Source_Location;

package/dist/__internals/sync/get_location_info.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$$ = $$;
+/**
+ * provides the source location (filepath and line number) of the source code file where this function is called,
+ * or if the depth is bigger than 0, the source location of the function at that stack depth
+ * @param depth
+ * @returns
+ */
+function $$(depth) {
+    //we create an error, not to be thrown but to be disected for its stack
+    const e = new Error(); //don't move this statement to another function, it will change the depth of its stack
+    function get_line(e, depth) {
+        if (e.stack === undefined) {
+            throw new Error(`NO STACK INFO`);
+        }
+        const line = e.stack.split("\n")[depth + 2]; //get the right line from the stack (the first two lines are "Error" and this function call)
+        const regex = /\((.*)\)$/; //matches the content inside parentheses at the end of a line (the file path with line and column)
+        const match = regex.exec(line);
+        if (match !== null) {
+            //we have a match
+            return match[1];
+        }
+        const begin = "    at /";
+        if (line.startsWith(begin)) {
+            return line.substring(begin.length - 1);
+        }
+        throw new Error(`COULD NOT PARSE STACK LINE: ${line}`);
+    }
+    const line = get_line(e, depth);
+    const split = line.split(":");
+    if (split.length !== 3) {
+        throw new Error(`UNEXPECTED LOCATION FORMAT (CHECK THE DEPTH PARAMETER): ${line} (Expected 'file:line:column')`);
+    }
+    return {
+        'file': split[0],
+        'line': Number(split[1]),
+        'column': Number(split[2]),
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0X2xvY2F0aW9uX2luZm8uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvX19pbnRlcm5hbHMvc3luYy9nZXRfbG9jYXRpb25faW5mby50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQVFBLGdCQTJDQztBQWpERDs7Ozs7R0FLRztBQUNILFNBQWdCLEVBQUUsQ0FBQyxLQUFhO0lBRTVCLHVFQUF1RTtJQUN2RSxNQUFNLENBQUMsR0FBRyxJQUFJLEtBQUssRUFBRSxDQUFDLENBQUMsc0ZBQXNGO0lBRzdHLFNBQVMsUUFBUSxDQUFDLENBQVEsRUFBRSxLQUFhO1FBR3JDLElBQUksQ0FBQyxDQUFDLEtBQUssS0FBSyxTQUFTLEVBQUUsQ0FBQztZQUN4QixNQUFNLElBQUksS0FBSyxDQUFDLGVBQWUsQ0FBQyxDQUFBO1FBQ3BDLENBQUM7UUFDRCxNQUFNLElBQUksR0FBRyxDQUFDLENBQUMsS0FBSyxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsQ0FBQyxLQUFLLEdBQUcsQ0FBQyxDQUFDLENBQUEsQ0FBRSw0RkFBNEY7UUFFekksTUFBTSxLQUFLLEdBQUcsV0FBVyxDQUFBLENBQUMsa0dBQWtHO1FBRTVILE1BQU0sS0FBSyxHQUFHLEtBQUssQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUM7UUFFL0IsSUFBSSxLQUFLLEtBQUssSUFBSSxFQUFFLENBQUM7WUFDakIsaUJBQWlCO1lBQ2pCLE9BQU8sS0FBSyxDQUFDLENBQUMsQ0FBQyxDQUFBO1FBQ25CLENBQUM7UUFFRCxNQUFNLEtBQUssR0FBRyxVQUFVLENBQUE7UUFDeEIsSUFBSSxJQUFJLENBQUMsVUFBVSxDQUFDLEtBQUssQ0FBQyxFQUFFLENBQUM7WUFDekIsT0FBTyxJQUFJLENBQUMsU0FBUyxDQUFDLEtBQUssQ0FBQyxNQUFNLEdBQUcsQ0FBQyxDQUFDLENBQUE7UUFDM0MsQ0FBQztRQUVELE1BQU0sSUFBSSxLQUFLLENBQUMsK0JBQStCLElBQUksRUFBRSxDQUFDLENBQUE7SUFHMUQsQ0FBQztJQUVELE1BQU0sSUFBSSxHQUFHLFFBQVEsQ0FBQyxDQUFDLEVBQUUsS0FBSyxDQUFDLENBQUE7SUFDL0IsTUFBTSxLQUFLLEdBQUcsSUFBSSxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsQ0FBQTtJQUM3QixJQUFJLEtBQUssQ0FBQyxNQUFNLEtBQUssQ0FBQyxFQUFFLENBQUM7UUFDckIsTUFBTSxJQUFJLEtBQUssQ0FBQywyREFBMkQsSUFBSSxnQ0FBZ0MsQ0FBQyxDQUFBO0lBQ3BILENBQUM7SUFDRCxPQUFPO1FBQ0gsTUFBTSxFQUFFLEtBQUssQ0FBQyxDQUFDLENBQUM7UUFDaEIsTUFBTSxFQUFFLE1BQU0sQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLENBQUM7UUFDeEIsUUFBUSxFQUFFLE1BQU0sQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLENBQUM7S0FDN0IsQ0FBQTtBQUNMLENBQUMifQ==

package/dist/command/Command_Block.d.ts

@@ -0,0 +1,3 @@
+import * as _pi from "../interface";
+export type Command_Block<Error> = _pi.Command_Promise<Error>[];
+export type Parametrized_Command_Block<Error, Parameter> = ($: Parameter) => Command_Block<Error>;

package/dist/command/Command_Block.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ29tbWFuZF9CbG9jay5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jb21tYW5kL0NvbW1hbmRfQmxvY2sudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/dist/command/command.d.ts

@@ -0,0 +1,2 @@
+import * as _pi from "../interface";
+export declare const __command: <Error, Parameters, Query_Resources, Command_Resources>(handler: ($: Parameters) => _pi.Command_Promise<Error>) => _pi.Command<Error, Parameters>;

package/dist/command/command.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.__command = void 0;
+const command_promise_1 = require("./command_promise");
+const __command = (handler) => {
+    return {
+        'execute': (parameters, error_transformer) => {
+            return (0, command_promise_1.__command_promise)({
+                'execute': (on_success, on_error) => {
+                    handler(parameters).__start(on_success, (error) => {
+                        on_error(error_transformer(error));
+                    });
+                }
+            });
+        },
+    };
+};
+exports.__command = __command;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tbWFuZC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jb21tYW5kL2NvbW1hbmQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQ0EsdURBQXFEO0FBRTlDLE1BQU0sU0FBUyxHQUFHLENBQ3JCLE9BQXNELEVBQ3hCLEVBQUU7SUFDaEMsT0FBTztRQUVILFNBQVMsRUFBRSxDQUFDLFVBQVUsRUFBRSxpQkFBaUIsRUFBRSxFQUFFO1lBQ3pDLE9BQU8sSUFBQSxtQ0FBaUIsRUFBQztnQkFDckIsU0FBUyxFQUFFLENBQUMsVUFBVSxFQUFFLFFBQVEsRUFBRSxFQUFFO29CQUNoQyxPQUFPLENBQUMsVUFBVSxDQUFDLENBQUMsT0FBTyxDQUN2QixVQUFVLEVBQ1YsQ0FBQyxLQUFLLEVBQUUsRUFBRTt3QkFDTixRQUFRLENBQ0osaUJBQWlCLENBQUMsS0FBSyxDQUFDLENBQzNCLENBQUE7b0JBQ0wsQ0FBQyxDQUNKLENBQUE7Z0JBQ0wsQ0FBQzthQUNKLENBQUMsQ0FBQTtRQUNOLENBQUM7S0FDSixDQUFBO0FBQ0wsQ0FBQyxDQUFBO0FBcEJZLFFBQUEsU0FBUyxhQW9CckIifQ==

package/dist/command/command_procedure.d.ts

@@ -0,0 +1,3 @@
+import * as _pi from "../interface";
+import { Command_Block } from "./Command_Block";
+export declare const command_procedure: <Error, Parameters, Command_Resources, Query_Resources>(execution_handler: ($p: Parameters, $cr: Command_Resources, $qr: Query_Resources) => Command_Block<Error>) => _pi.Command_Procedure<_pi.Command<Error, Parameters>, Command_Resources, Query_Resources>;

package/dist/command/command_procedure.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command_procedure = void 0;
+const command_promise_1 = require("./command_promise");
+const handle_command_block_1 = require("./handle_command_block");
+const command_procedure = (execution_handler) => {
+    return ($cr, $qr) => {
+        return {
+            'execute': (parameters, error_transformer) => {
+                return (0, command_promise_1.__command_promise)({
+                    'execute': (on_success, on_error) => {
+                        (0, handle_command_block_1.__handle_command_block)(execution_handler(parameters, $cr, $qr)).__start(on_success, ($) => {
+                            on_error(error_transformer($));
+                        });
+                    }
+                });
+            },
+        };
+    };
+};
+exports.command_procedure = command_procedure;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tbWFuZF9wcm9jZWR1cmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY29tbWFuZC9jb21tYW5kX3Byb2NlZHVyZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFHQSx1REFBcUQ7QUFDckQsaUVBQStEO0FBR3hELE1BQU0saUJBQWlCLEdBQUcsQ0FDN0IsaUJBSXlCLEVBQ2dFLEVBQUU7SUFDM0YsT0FBTyxDQUFDLEdBQUcsRUFBRSxHQUFHLEVBQUUsRUFBRTtRQUNoQixPQUFPO1lBQ0gsU0FBUyxFQUFFLENBQUMsVUFBVSxFQUFFLGlCQUFpQixFQUFFLEVBQUU7Z0JBQ3pDLE9BQU8sSUFBQSxtQ0FBaUIsRUFBQztvQkFDckIsU0FBUyxFQUFFLENBQUMsVUFBVSxFQUFFLFFBQVEsRUFBRSxFQUFFO3dCQUVoQyxJQUFBLDZDQUFzQixFQUFDLGlCQUFpQixDQUFDLFVBQVUsRUFBRSxHQUFHLEVBQUUsR0FBRyxDQUFDLENBQUMsQ0FBQyxPQUFPLENBQ25FLFVBQVUsRUFDVixDQUFDLENBQUMsRUFBRSxFQUFFOzRCQUNGLFFBQVEsQ0FDSixpQkFBaUIsQ0FBQyxDQUFDLENBQUMsQ0FDdkIsQ0FBQTt3QkFDTCxDQUFDLENBQ0osQ0FBQTtvQkFDTCxDQUFDO2lCQUNKLENBQUMsQ0FBQTtZQUNOLENBQUM7U0FDSixDQUFBO0lBQ0wsQ0FBQyxDQUFBO0FBQ0wsQ0FBQyxDQUFBO0FBMUJZLFFBQUEsaUJBQWlCLHFCQTBCN0IifQ==

package/dist/command/command_promise.d.ts

@@ -0,0 +1,17 @@
+import * as _pi from "../interface";
+/**
+ * this function contains the body in which the async value or error is executed
+ * after the execution, either the on_value or on_error callback will be called
+ * @param on_value the callback to call when a value is produced
+ * @param on_error the callback to call when an error is produced
+ */
+type Executer<E> = {
+    'execute': (on_success: () => void, on_error: ($: E) => void) => void;
+};
+/**
+ * returns an {@link Async_Value }
+ * @param executer the function that produces the eventual value
+ * @returns
+ */
+export declare function __command_promise<E>(executer: Executer<E>): _pi.Command_Promise<E>;
+export {};

package/dist/command/command_promise.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.__command_promise = __command_promise;
+class Command_Promise_Class {
+    constructor(executer) {
+        this.executer = executer;
+    }
+    __start(on_success, on_error) {
+        this.executer.execute(on_success, on_error);
+    }
+    map_error(handle_error) {
+        return new Command_Promise_Class({
+            'execute': (on_success, on_error) => {
+                this.executer.execute(on_success, (error) => {
+                    on_error(handle_error(error));
+                });
+            }
+        });
+    }
+}
+/**
+ * returns an {@link Async_Value }
+ * @param executer the function that produces the eventual value
+ * @returns
+ */
+function __command_promise(executer) {
+    return new Command_Promise_Class(executer);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tbWFuZF9wcm9taXNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2NvbW1hbmQvY29tbWFuZF9wcm9taXNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBa0RBLDhDQUtDO0FBdkNELE1BQU0scUJBQXFCO0lBRXZCLFlBQVksUUFBcUI7UUFDN0IsSUFBSSxDQUFDLFFBQVEsR0FBRyxRQUFRLENBQUE7SUFDNUIsQ0FBQztJQUVELE9BQU8sQ0FDSCxVQUFzQixFQUN0QixRQUF3QjtRQUV4QixJQUFJLENBQUMsUUFBUSxDQUFDLE9BQU8sQ0FBQyxVQUFVLEVBQUUsUUFBUSxDQUFDLENBQUE7SUFDL0MsQ0FBQztJQUVELFNBQVMsQ0FDTCxZQUE4QjtRQUU5QixPQUFPLElBQUkscUJBQXFCLENBQUs7WUFDakMsU0FBUyxFQUFFLENBQUMsVUFBVSxFQUFFLFFBQVEsRUFBRSxFQUFFO2dCQUNoQyxJQUFJLENBQUMsUUFBUSxDQUFDLE9BQU8sQ0FDakIsVUFBVSxFQUNWLENBQUMsS0FBSyxFQUFFLEVBQUU7b0JBQ04sUUFBUSxDQUFDLFlBQVksQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFBO2dCQUNqQyxDQUFDLENBQ0osQ0FBQTtZQUNMLENBQUM7U0FDSixDQUFDLENBQUE7SUFDTixDQUFDO0NBQ0o7QUFFRDs7OztHQUlHO0FBQ0gsU0FBZ0IsaUJBQWlCLENBQzdCLFFBQXFCO0lBRXJCLE9BQU8sSUFBSSxxQkFBcUIsQ0FBSSxRQUFRLENBQUMsQ0FBQTtBQUVqRCxDQUFDIn0=

package/dist/command/handle_command_block.d.ts

@@ -0,0 +1,3 @@
+import * as _pi from "../interface";
+import { Command_Block } from './Command_Block';
+export declare const __handle_command_block: <Error>(block: Command_Block<Error>) => _pi.Command_Promise<Error>;

package/dist/command/handle_command_block.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.__handle_command_block = void 0;
+const command_promise_1 = require("./command_promise");
+const __handle_command_block = (block) => {
+    return (0, command_promise_1.__command_promise)({
+        'execute': (on_success, on_error) => {
+            const length = block.length;
+            const runStep = (index) => {
+                if (index >= length) {
+                    on_success();
+                    return;
+                }
+                block[index].__start(() => runStep(index + 1), on_error);
+            };
+            runStep(0);
+        }
+    });
+};
+exports.__handle_command_block = __handle_command_block;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGFuZGxlX2NvbW1hbmRfYmxvY2suanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY29tbWFuZC9oYW5kbGVfY29tbWFuZF9ibG9jay50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFDQSx1REFBcUQ7QUFHOUMsTUFBTSxzQkFBc0IsR0FBRyxDQUNsQyxLQUEyQixFQUNELEVBQUU7SUFDNUIsT0FBTyxJQUFBLG1DQUFpQixFQUFDO1FBQ3JCLFNBQVMsRUFBRSxDQUNQLFVBQVUsRUFDVixRQUFRLEVBQ1YsRUFBRTtZQUVBLE1BQU0sTUFBTSxHQUFHLEtBQUssQ0FBQyxNQUFNLENBQUE7WUFDM0IsTUFBTSxPQUFPLEdBQUcsQ0FBQyxLQUFhLEVBQUUsRUFBRTtnQkFDOUIsSUFBSSxLQUFLLElBQUksTUFBTSxFQUFFLENBQUM7b0JBQ2xCLFVBQVUsRUFBRSxDQUFBO29CQUNaLE9BQU07Z0JBQ1YsQ0FBQztnQkFDRCxLQUFLLENBQUMsS0FBSyxDQUFDLENBQUMsT0FBTyxDQUNoQixHQUFHLEVBQUUsQ0FBQyxPQUFPLENBQUMsS0FBSyxHQUFHLENBQUMsQ0FBQyxFQUN4QixRQUFRLENBQ1gsQ0FBQTtZQUNMLENBQUMsQ0FBQTtZQUNELE9BQU8sQ0FBQyxDQUFDLENBQUMsQ0FBQTtRQUNkLENBQUM7S0FDSixDQUFDLENBQUE7QUFDTixDQUFDLENBQUE7QUF2QlksUUFBQSxzQkFBc0IsMEJBdUJsQyJ9

package/dist/command/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * these functions coming from core-internals should be exposed for command development
+ */
+export { deprecated_cc } from "../__internals/sync/expression/special";
+export * from "../__internals/sync/expression/decide";
+export * from "../__internals/sync/extracts/literal";
+export * from "./command_procedure";
+export * from "./command_promise";
+export * from "./command";
+export * from "./statement";

package/dist/command/index.js

@@ -0,0 +1,29 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deprecated_cc = void 0;
+/**
+ * these functions coming from core-internals should be exposed for command development
+ */
+var special_1 = require("../__internals/sync/expression/special");
+Object.defineProperty(exports, "deprecated_cc", { enumerable: true, get: function () { return special_1.deprecated_cc; } });
+__exportStar(require("../__internals/sync/expression/decide"), exports); //for handling instructions
+__exportStar(require("../__internals/sync/extracts/literal"), exports);
+__exportStar(require("./command_procedure"), exports);
+__exportStar(require("./command_promise"), exports);
+__exportStar(require("./command"), exports);
+__exportStar(require("./statement"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY29tbWFuZC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7OztBQUVBOztHQUVHO0FBQ0gsa0VBQXNFO0FBQTdELHdHQUFBLGFBQWEsT0FBQTtBQUV0Qix3RUFBcUQsQ0FBQywyQkFBMkI7QUFDakYsdUVBQW9EO0FBQ3BELHNEQUFtQztBQUNuQyxvREFBaUM7QUFDakMsNENBQXlCO0FBQ3pCLDhDQUEyQiJ9

package/dist/command/statement.d.ts

@@ -0,0 +1,27 @@
+import * as _pi from "../interface";
+import { Command_Block } from "./Command_Block";
+export declare namespace listx {
+    const serie: <Error>(array: _pi.List<_pi.Command_Promise<Error>>) => _pi.Command_Promise<Error>;
+}
+export declare namespace dictionaryx {
+    const parallel: <T, Error, Entry_Error>(dictionary: _pi.Dictionary<T>, parametrized_command_block: (value: T, key: string) => Command_Block<Entry_Error>, aggregate_errors: _pi.Transformer<_pi.Dictionary<Entry_Error>, Error>) => _pi.Command_Promise<Error>;
+    namespace deprecated_parallel {
+        const query: <T, Error, Entry_Error>(query_result: _pi.Query_Result<_pi.Dictionary<T>, Error>, parametrized_command_block: (value: T, key: string) => Command_Block<Entry_Error>, aggregate_errors: _pi.Transformer<_pi.Dictionary<Entry_Error>, Error>) => _pi.Command_Promise<Error>;
+    }
+}
+export declare const create_error_handling_context: <Target_Error, Block_Error>(command_block: Command_Block<Block_Error>, parametrized_command_block: ($v: Block_Error) => Command_Block<Target_Error>, new_error: Target_Error) => _pi.Command_Promise<Target_Error>;
+export declare const nothing: <Error>() => _pi.Command_Promise<Error>;
+export declare const fail: <Error>(error: Error) => _pi.Command_Promise<Error>;
+export declare const query: <Error, Query_Output, Refine_Output>(query_result: _pi.Query_Result<Query_Output, Error>, refine: _pi.Refiner<Refine_Output, Error, Query_Output>, parametrized_command_block: ($v: Refine_Output) => Command_Block<Error>) => _pi.Command_Promise<Error>;
+export declare const query_stacked: <Error, Staging_Output, Parent_Data>(query_result: _pi.Query_Result<Staging_Output, Error>, parent_data: Parent_Data, parametrized_command_block: ($v: Staging_Output, $parent: Parent_Data) => Command_Block<Error>) => _pi.Command_Promise<Error>;
+export declare const refine_without_error_transformation: <Error, Staging_Output>(//I doubt that this one is needed. Either parameters are refined or query results.. parameters should already be refined. 
+callback: (abort: _pi.Abort<Error>) => Staging_Output, parametrized_command_block: ($v: Staging_Output) => Command_Block<Error>) => _pi.Command_Promise<Error>;
+export declare const refine_stacked: <Error, Staging_Output, Parent_Data>(callback: (abort: _pi.Abort<Error>) => Staging_Output, parent_data: Parent_Data, parametrized_command_block: ($v: Staging_Output, $parent: Parent_Data) => Command_Block<Error>) => _pi.Command_Promise<Error>;
+export declare namespace if_ {
+    const direct: <Error>(precondition: boolean, command_block: Command_Block<Error>, else_command_block?: Command_Block<Error>) => _pi.Command_Promise<Error>;
+    const query: <Error>(precondition: _pi.Query_Result<boolean, Error>, command_block: Command_Block<Error>, else_command_block?: Command_Block<Error>) => _pi.Command_Promise<Error>;
+}
+export declare namespace assert {
+    const direct: <Error>(assertion: boolean, error_if_failed: Error) => _pi.Command_Promise<Error>;
+    const query: <Error>(assertion: _pi.Query_Result<boolean, Error>, error_if_failed: Error) => _pi.Command_Promise<Error>;
+}