pareto-core 0.1.0

package/dist/interface/interfaces.d.ts

@@ -0,0 +1,54 @@
+import { Raw_Optional_Value } from "./Raw_Optional_Value";
+import { Transformer } from "./algorithm_signatures/Transformer";
+import { Circular_Dependency } from "./data/Circular_Dependency";
+export type Abort<Error> = (error: Error) => never;
+export type Acyclic_Lookup<Type> = {
+    'get entry': (key: string, abort: {
+        'no context lookup': Abort<null>;
+        'no such entry': Abort<string>;
+        'cyclic': Abort<string[]>;
+    }) => Type;
+    'get possible entry': (key: string, abort: {
+        'no context lookup': Abort<null>;
+        'cyclic': Abort<string[]>;
+    }) => Raw_Optional_Value<Type>;
+};
+export type Cyclic_Lookup<Type> = {
+    'get entry': (key: string, abort: {
+        'no context lookup': Abort<null>;
+        'no such entry': Abort<string>;
+        'accessing cyclic before resolved': Abort<null>;
+    }) => Circular_Dependency<Type>;
+};
+export type Iterator<Element> = {
+    'look': () => Raw_Optional_Value<Element>;
+    'look ahead': (offset: number) => Raw_Optional_Value<Element>;
+    'consume': <T>(callback: (value: Element, position: number) => T, abort: Abort<number>) => T;
+    'discard': <T>(callback: () => T) => T;
+    'get position': () => number;
+    'assert finished': <T>(callback: () => T, abort: Abort<null>) => T;
+};
+export type Queryer<Output, Error, Input> = ($: Input) => Query_Result<Output, Error>;
+export interface Query_Result<Output, Error> {
+    query_result: null;
+    transform_result<New_Output>(transformer: Transformer<Output, New_Output>): Query_Result<New_Output, Error>;
+    query_without_error_transformation<New_Output>(query: Queryer<New_Output, Error, Output>): Query_Result<New_Output, Error>;
+    refine_without_error_transformation<New_Output>(callback: ($: Output, abort: Abort<Error>) => New_Output): Query_Result<New_Output, Error>;
+    rework_error_temp<New_Error, Rework_Error>(error_reworker: Queryer<New_Error, Rework_Error, Error>, 
+    /**
+     * if the reworker fails, we need to transform *that* error into the New_Error
+     */
+    rework_error_transformer: Transformer<Rework_Error, New_Error>): Query_Result<Output, New_Error>;
+    __extract_data: (on_success: ($: Output) => void, on_error: ($: Error) => void) => void;
+}
+export type Stack_Lookup<Type> = {
+    'get entry': (key: string, abort: {
+        'no context lookup': Abort<null>;
+        'no such entry': Abort<string>;
+        'cyclic': Abort<string[]>;
+    }) => Type;
+};
+export type Text_Builder = {
+    'add snippet': ($: string) => void;
+    'add character': ($: number) => void;
+};

package/dist/interface/interfaces.js

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

package/dist/query/expression.d.ts

@@ -0,0 +1,6 @@
+import * as _pi from "../interface";
+export declare namespace dictionaryx {
+    const parallel: <Result, Error, Entry_Error>(dictionary: _pi.Dictionary<_pi.Query_Result<Result, Entry_Error>>, aggregate_errors: _pi.Transformer<_pi.Dictionary<Entry_Error>, Error>) => _pi.Query_Result<_pi.Dictionary<Result>, Error>;
+}
+export declare const direct_result: <Result, Error>(result: Result) => _pi.Query_Result<Result, Error>;
+export declare const direct_error: <T, E>($: E) => _pi.Query_Result<T, E>;

package/dist/query/expression.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.direct_error = exports.direct_result = exports.dictionaryx = void 0;
+const query_result_1 = require("./query_result");
+const asynchronous_collection_builder_1 = require("../__internals/async/asynchronous_collection_builder");
+const create_asynchronous_processes_monitor_1 = require("../__internals/async/create_asynchronous_processes_monitor");
+var dictionaryx;
+(function (dictionaryx) {
+    dictionaryx.parallel = (dictionary, aggregate_errors) => {
+        return (0, query_result_1.__query_result)((on_success, on_error) => {
+            let has_errors = false;
+            const errors_builder = (0, asynchronous_collection_builder_1.create_asynchronous_dictionary_builder)();
+            const results_builder = (0, asynchronous_collection_builder_1.create_asynchronous_dictionary_builder)();
+            (0, create_asynchronous_processes_monitor_1.create_asynchronous_processes_monitor)((monitor) => {
+                dictionary.__d_map(($, key) => {
+                    monitor['report process started']();
+                    $.__extract_data(($) => {
+                        results_builder['add entry'](key, $);
+                        monitor['report process finished']();
+                    }, ($) => {
+                        has_errors = true;
+                        errors_builder['add entry'](key, $);
+                        monitor['report process finished']();
+                    });
+                });
+            }, () => {
+                if (has_errors) {
+                    on_error(aggregate_errors(errors_builder['get dictionary']()));
+                }
+                else {
+                    on_success(results_builder['get dictionary']());
+                }
+            });
+        });
+    };
+})(dictionaryx || (exports.dictionaryx = dictionaryx = {}));
+const direct_result = (result) => {
+    return (0, query_result_1.__query_result)((on_success, on_error) => {
+        on_success(result);
+    });
+};
+exports.direct_result = direct_result;
+const direct_error = ($) => {
+    return (0, query_result_1.__query_result)((on_value, on_error) => {
+        on_error($);
+    });
+};
+exports.direct_error = direct_error;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/query/index.d.ts

@@ -0,0 +1,6 @@
+export * from "../__internals/sync/expression/decide";
+export * from "../__internals/sync/extracts/literal";
+export * from "./expression";
+export * from "./query_function";
+export * from "./query_result";
+export * from "./query";

package/dist/query/index.js

@@ -0,0 +1,23 @@
+"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 });
+__exportStar(require("../__internals/sync/expression/decide"), exports);
+__exportStar(require("../__internals/sync/extracts/literal"), exports);
+__exportStar(require("./expression"), exports);
+__exportStar(require("./query_function"), exports);
+__exportStar(require("./query_result"), exports);
+__exportStar(require("./query"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcXVlcnkvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLHdFQUFxRDtBQUNyRCx1RUFBb0Q7QUFDcEQsK0NBQTRCO0FBQzVCLG1EQUFnQztBQUNoQyxpREFBOEI7QUFDOUIsMENBQXVCIn0=

package/dist/query/query.d.ts

@@ -0,0 +1,4 @@
+import * as _pi from "../interface";
+type Queryer<Output, Error, Input> = ($: Input) => _pi.Query_Result<Output, Error>;
+export declare const __query: <Result, Error, Parameters, Resources>(handler: Queryer<Result, Error, Parameters>) => _pi.Query<Result, Error, Parameters>;
+export {};

package/dist/query/query.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.__query = void 0;
+const query_result_1 = require("./query_result");
+const __query = (handler) => {
+    return (parameters, error_transformer) => {
+        return (0, query_result_1.__query_result)((on_success, on_error) => {
+            handler(parameters).__extract_data(on_success, (e) => {
+                on_error(error_transformer(e));
+            });
+        });
+    };
+};
+exports.__query = __query;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicXVlcnkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcXVlcnkvcXVlcnkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQ0EsaURBQStDO0FBT3hDLE1BQU0sT0FBTyxHQUFHLENBQ25CLE9BQTJDLEVBQ1AsRUFBRTtJQUN0QyxPQUFPLENBQUMsVUFBVSxFQUFFLGlCQUFpQixFQUFFLEVBQUU7UUFDckMsT0FBTyxJQUFBLDZCQUFjLEVBQUMsQ0FBQyxVQUFVLEVBQUUsUUFBUSxFQUFFLEVBQUU7WUFDM0MsT0FBTyxDQUFDLFVBQVUsQ0FBQyxDQUFDLGNBQWMsQ0FDOUIsVUFBVSxFQUNWLENBQUMsQ0FBQyxFQUFFLEVBQUU7Z0JBQ0YsUUFBUSxDQUFDLGlCQUFpQixDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUE7WUFDbEMsQ0FBQyxDQUNKLENBQUE7UUFDTCxDQUFDLENBQUMsQ0FBQTtJQUNOLENBQUMsQ0FBQTtBQUNMLENBQUMsQ0FBQTtBQWJZLFFBQUEsT0FBTyxXQWFuQiJ9

package/dist/query/query_function.d.ts

@@ -0,0 +1,2 @@
+import * as _pi from "../interface";
+export declare const query_function: <Result, Error, Parameters, Query_Resources>(handler: ($p: Parameters, $q: Query_Resources) => _pi.Query_Result<Result, Error>) => _pi.Query_Function<_pi.Query<Result, Error, Parameters>, Query_Resources>;

package/dist/query/query_function.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.query_function = void 0;
+const query_result_1 = require("./query_result");
+const query_function = (handler) => {
+    return ($q) => ($p, error_transformer) => {
+        return (0, query_result_1.__query_result)((on_success, on_error) => {
+            handler($p, $q).__extract_data(on_success, (e) => {
+                on_error(error_transformer(e));
+            });
+        });
+    };
+};
+exports.query_function = query_function;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicXVlcnlfZnVuY3Rpb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcXVlcnkvcXVlcnlfZnVuY3Rpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBR0EsaURBQStDO0FBRXhDLE1BQU0sY0FBYyxHQUFHLENBQzFCLE9BR29DLEVBQ3FDLEVBQUU7SUFDM0UsT0FBTyxDQUFDLEVBQUUsRUFBRSxFQUFFLENBQUMsQ0FBQyxFQUFFLEVBQUUsaUJBQWlCLEVBQUUsRUFBRTtRQUNyQyxPQUFPLElBQUEsNkJBQWMsRUFBQyxDQUFDLFVBQVUsRUFBRSxRQUFRLEVBQUUsRUFBRTtZQUMzQyxPQUFPLENBQUMsRUFBRSxFQUFFLEVBQUUsQ0FBQyxDQUFDLGNBQWMsQ0FDMUIsVUFBVSxFQUNWLENBQUMsQ0FBQyxFQUFFLEVBQUU7Z0JBQ0YsUUFBUSxDQUFDLGlCQUFpQixDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUE7WUFDbEMsQ0FBQyxDQUNKLENBQUE7UUFDTCxDQUFDLENBQUMsQ0FBQTtJQUNOLENBQUMsQ0FBQTtBQUNMLENBQUMsQ0FBQTtBQWhCWSxRQUFBLGNBQWMsa0JBZ0IxQiJ9

package/dist/query/query_result.d.ts

@@ -0,0 +1,10 @@
+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_result or on_error callback will be called
+ * @param on_result the callback to call when a value is produced
+ * @param on_error the callback to call when an error is produced
+ */
+type Executer<Output, Error> = (on_result: ($: Output) => void, on_error: ($: Error) => void) => void;
+export declare function __query_result<T, E>(executer: Executer<T, E>): _pi.Query_Result<T, E>;
+export {};

package/dist/query/query_result.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.__query_result = __query_result;
+const create_refinement_context_1 = require("../__internals/async/create_refinement_context");
+class Query_Result_Class {
+    constructor(executer) {
+        this.executer = executer;
+        this.query_result = null;
+    }
+    transform_result(transformer) {
+        return new Query_Result_Class((on_result, on_error) => {
+            this.executer(($) => {
+                on_result(transformer($));
+            }, on_error);
+        });
+    }
+    // deprecated_transform_error<New_Error>(
+    //     error_transformer: _pi.Transformer<Error, New_Error>,
+    // ): _pi.Query_Result<Output, New_Error> {
+    //     return new Query_Result_Class<Output, New_Error>((on_result, on_error) => {
+    //         this.executer(
+    //             on_result,
+    //             ($) => {
+    //                 on_error(error_transformer($))
+    //             },
+    //         )
+    //     })
+    // }
+    query_without_error_transformation(queryer) {
+        return new Query_Result_Class((on_result, on_error) => {
+            this.executer(($) => {
+                queryer($).__extract_data(on_result, on_error);
+            }, on_error);
+        });
+    }
+    // query<New_Output, Query_Error>(
+    //     queryer: Queryer<New_Output, Query_Error, Output>,
+    //     error_transformer: _pi.Transformer<Query_Error, Error>,
+    // ): _pi.Query_Result<New_Output, Error> {
+    //     return new Query_Result_Class<New_Output, Error>((on_result, on_error) => {
+    //         this.executer(
+    //             ($) => {
+    //                 queryer($).__extract_data(
+    //                     on_result,
+    //                     (queryer_error) => {
+    //                         on_error(error_transformer(queryer_error))
+    //                     },
+    //                 )
+    //             },
+    //             on_error,
+    //         )
+    //     })
+    // }
+    refine_without_error_transformation(callback) {
+        return new Query_Result_Class((on_result, on_error) => {
+            this.executer(($) => {
+                (0, create_refinement_context_1.create_refinement_context)((abort) => callback($, abort)).__extract_data(on_result, on_error);
+            }, on_error);
+        });
+    }
+    // refine<New_Output, Refiner_Error>(
+    //     callback: ($: Output, abort: _pi.Abort<Refiner_Error>) => New_Output,
+    //     error_transformer: _pi.Transformer<Refiner_Error, Error>,
+    // ): _pi.Query_Result<New_Output, Error> {
+    //     return new Query_Result_Class<New_Output, Error>((on_result, on_error) => {
+    //         this.executer(
+    //             ($) => {
+    //                 _pinternals.deprecated_create_refinement_context<New_Output, Refiner_Error>((abort) => callback($, abort)).__extract_data(
+    //                     on_result,
+    //                     (stager_error) => {
+    //                         on_error(error_transformer(stager_error))
+    //                     },
+    //                 )
+    //             },
+    //             on_error,
+    //         )
+    //     })
+    // }
+    rework_error_temp(error_reworker, rework_error_transformer) {
+        return new Query_Result_Class((on_result, on_error) => {
+            this.executer(on_result, ($) => {
+                error_reworker($).__extract_data((new_target_error) => {
+                    on_error(new_target_error);
+                }, (rework_error) => {
+                    on_error(rework_error_transformer(rework_error));
+                });
+            });
+        });
+    }
+    __extract_data(on_result, on_error) {
+        this.executer(on_result, on_error);
+    }
+}
+function __query_result(executer) {
+    return new Query_Result_Class(executer);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/refiner/index.d.ts

@@ -0,0 +1,8 @@
+import * as _pi from "../interface";
+export * from "../__internals/sync/expression/decide";
+export { deprecated_cc, deprecated_block, panic as fixme_abort, iterate, unreachable_code_path } from "../__internals/sync/expression/special";
+export * from "../__internals/sync/expression/initialize";
+type Dictionary_Builder<T> = {
+    'add entry': (key: string, value: T) => void;
+};
+export declare const deprecated_build_dictionary: <T>($: ($c: Dictionary_Builder<T>) => void, abort?: _pi.Abort<["duplicate key in dictionary literal", null]>) => _pi.Dictionary<T>;

package/dist/refiner/index.js

@@ -0,0 +1,45 @@
+"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_build_dictionary = exports.unreachable_code_path = exports.iterate = exports.fixme_abort = exports.deprecated_block = exports.deprecated_cc = void 0;
+__exportStar(require("../__internals/sync/expression/decide"), exports);
+var special_1 = require("../__internals/sync/expression/special");
+Object.defineProperty(exports, "deprecated_cc", { enumerable: true, get: function () { return special_1.deprecated_cc; } });
+Object.defineProperty(exports, "deprecated_block", { enumerable: true, get: function () { return special_1.deprecated_block; } });
+Object.defineProperty(exports, "fixme_abort", { enumerable: true, get: function () { return special_1.panic; } });
+Object.defineProperty(exports, "iterate", { enumerable: true, get: function () { return special_1.iterate; } });
+Object.defineProperty(exports, "unreachable_code_path", { enumerable: true, get: function () { return special_1.unreachable_code_path; } });
+__exportStar(require("../__internals/sync/expression/initialize"), exports);
+const dictionary_1 = require("../__internals/sync/expression/literals/dictionary");
+const deprecated_build_dictionary = ($, abort) => {
+    const temp = {};
+    $({
+        'add entry': (key, $) => {
+            if (key in temp) {
+                if (abort !== undefined) {
+                    return abort(['duplicate key in dictionary literal', null]);
+                }
+                else {
+                    throw new Error(`duplicate key in dictionary literal: ${key}`);
+                }
+            }
+            temp[key] = $;
+        }
+    });
+    return (0, dictionary_1.$$)(temp);
+};
+exports.deprecated_build_dictionary = deprecated_build_dictionary;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcmVmaW5lci9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7OztBQUVBLHdFQUFxRDtBQUVyRCxrRUFNK0M7QUFMM0Msd0dBQUEsYUFBYSxPQUFBO0FBQ2IsMkdBQUEsZ0JBQWdCLE9BQUE7QUFDaEIsc0dBQUEsS0FBSyxPQUFlO0FBQ3BCLGtHQUFBLE9BQU8sT0FBQTtBQUNQLGdIQUFBLHFCQUFxQixPQUFBO0FBR3pCLDRFQUF5RDtBQVV6RCxtRkFBZ0c7QUFDekYsTUFBTSwyQkFBMkIsR0FBRyxDQUN2QyxDQUFzQyxFQUN0QyxLQUFnRSxFQUMvQyxFQUFFO0lBQ25CLE1BQU0sSUFBSSxHQUF5QixFQUFFLENBQUE7SUFDckMsQ0FBQyxDQUFDO1FBQ0UsV0FBVyxFQUFFLENBQUMsR0FBRyxFQUFFLENBQUMsRUFBRSxFQUFFO1lBQ3BCLElBQUksR0FBRyxJQUFJLElBQUksRUFBRSxDQUFDO2dCQUNkLElBQUksS0FBSyxLQUFLLFNBQVMsRUFBRSxDQUFDO29CQUN0QixPQUFPLEtBQUssQ0FBQyxDQUFDLHFDQUFxQyxFQUFFLElBQUksQ0FBQyxDQUFDLENBQUE7Z0JBQy9ELENBQUM7cUJBQU0sQ0FBQztvQkFDSixNQUFNLElBQUksS0FBSyxDQUFDLHdDQUF3QyxHQUFHLEVBQUUsQ0FBQyxDQUFBO2dCQUNsRSxDQUFDO1lBQ0wsQ0FBQztZQUNELElBQUksQ0FBQyxHQUFHLENBQUMsR0FBRyxDQUFDLENBQUE7UUFDakIsQ0FBQztLQUNKLENBQUMsQ0FBQTtJQUNGLE9BQU8sSUFBQSxlQUFxQixFQUFDLElBQUksQ0FBQyxDQUFBO0FBQ3RDLENBQUMsQ0FBQTtBQWxCWSxRQUFBLDJCQUEyQiwrQkFrQnZDIn0=

package/dist/refiner/resolve.d.ts

@@ -0,0 +1,176 @@
+import * as _pi from "../interface";
+import * as initialize from "../__internals/sync/expression/initialize";
+type Location_to_String<Source> = ($: Source) => string;
+export type _T_Location_2_String<Source> = Location_to_String<Source>;
+type Non_Circular_Result<T> = ['error', ['circular', _pi.List<string>]] | ['resolved', T];
+type Lookup<T> = {
+    __get_possible_entry: (key: string) => _pi.Optional_Value<T>;
+};
+type Acyclic_Lookup<T> = _pi.Optional_Value<Lookup<Non_Circular_Result<T>>>;
+export type _T_Acyclic_Lookup<T> = Acyclic_Lookup<T>;
+type Possibly_Circular_Result<T> = _pi.Circular_Dependency<T>;
+type Cyclic_Lookup<T> = _pi.Optional_Value<Lookup<Possibly_Circular_Result<T>>>;
+export type _T_Cyclic_Lookup<T> = Cyclic_Lookup<T>;
+type Lookup_Stack<T> = _pi.List<Acyclic_Lookup<T>>;
+export type _T_Lookup_Stack<T> = Lookup_Stack<T>;
+declare namespace unresolved$ {
+    type Derived_Reference<M_Source, T_Type> = null;
+    type Dictionary<M_Source, T_D> = {
+        readonly 'dictionary': _pi.Dictionary<{
+            readonly 'entry': T_D;
+            readonly 'location': M_Source;
+        }>;
+        readonly 'location': M_Source;
+    };
+    type List<M_Source, T_L> = {
+        readonly 'list': _pi.List<{
+            readonly 'element': T_L;
+            readonly 'location': M_Source;
+        }>;
+        readonly 'location': M_Source;
+    };
+    type Ordered_Dictionary<M_Source, T_D> = {
+        readonly 'dictionary': _pi.Dictionary<{
+            readonly 'entry': T_D;
+            readonly 'location': M_Source;
+        }>;
+        readonly 'location': M_Source;
+    };
+    type Reference_To_Circular_Dependent_Sibling<M_Source, T_Dictionary_Entry> = {
+        readonly 'key': string;
+        readonly 'location': M_Source;
+    };
+    type Reference_To_Normal_Dictionary_Entry<M_Source, T_Dictionary_Entry> = {
+        readonly 'key': string;
+        readonly 'location': M_Source;
+    };
+    type Reference_To_Stacked_Dictionary_Entry<M_Source, T_Dictionary_Entry> = {
+        readonly 'key': string;
+        readonly 'location': M_Source;
+    };
+    type State_Group<M_Source, T_SG> = {
+        readonly 'location': M_Source;
+        readonly 'state group': T_SG;
+    };
+}
+declare namespace resolved$ {
+    type Derived_Reference<M_Source, T_Type> = T_Type;
+    type Dictionary<M_Source, T_D> = _pi.Dictionary<T_D>;
+    type List<M_Source, T_L> = _pi.List<T_L>;
+    type Ordered_Dictionary<M_Source, T_D> = {
+        readonly 'dictionary': _pi.Dictionary<T_D>;
+        readonly 'ordered list': _pi.List<{
+            readonly 'key': string;
+            readonly 'value': T_D;
+        }>;
+    };
+    type Reference_To_Circular_Dependent_Sibling<M_Source, T_Dictionary_Entry> = {
+        readonly 'entry': _pi.Circular_Dependency<T_Dictionary_Entry>;
+        readonly 'key': string;
+    };
+    type Reference_To_Normal_Dictionary_Entry<M_Source, T_Dictionary_Entry> = {
+        readonly 'entry': T_Dictionary_Entry;
+        readonly 'key': string;
+    };
+    type Reference_To_Stacked_Dictionary_Entry<M_Source, T_Dictionary_Entry> = {
+        readonly 'entry': T_Dictionary_Entry;
+        readonly 'key': string;
+        readonly 'up steps': number;
+    };
+    type State_Group<M_Source, T_SG> = T_SG;
+}
+export type Acyclic_Entry_Reference<T_Dictionary_Entry> = {
+    readonly 'entry': T_Dictionary_Entry;
+    readonly 'key': string;
+};
+type Key_Value_Location_Triplet<Source, T> = {
+    'key': string;
+    'value': T;
+    'location': Source;
+};
+export type Path<Source, Resolved_Element, Seed> = {
+    'list': _pi.List<Resolved_Element>;
+    'result': {
+        'data': Seed;
+    };
+};
+export type Resolved_Step<Resolved_Element, Seed> = {
+    'element': Resolved_Element;
+    'result': Seed;
+};
+type Resolve_Error_Type = [
+    'circular dependency',
+    {
+        'keys': _pi.List<string>;
+    }
+] | [
+    'no such entry',
+    {
+        'key': string;
+    }
+] | ['no context lookup', null] | [
+    'missing denseness entry',
+    {
+        'key': string;
+    }
+] | [
+    'index out of bounds',
+    {
+        'up steps taken': number;
+    }
+] | [
+    'no element found at index',
+    {
+        'index': number;
+    }
+];
+export declare const abort: <Source>(location: Source, type: Resolve_Error_Type, location_to_string: Location_to_String<Source>) => never;
+export declare const dictionary_to_lookup: <T>($: _pi.Dictionary<T>, $p: null) => Acyclic_Lookup<T>;
+export declare const get_possibly_circular_dependent_sibling_entry: <Source, T>($: Cyclic_Lookup<T>, $p: {
+    "reference": unresolved$.Reference_To_Circular_Dependent_Sibling<Source, T>;
+    "location 2 string": Location_to_String<Source>;
+}) => resolved$.Reference_To_Circular_Dependent_Sibling<Source, T>;
+export declare const push_stack: <T extends initialize.list.NonUndefined>($: _pi.List<T>, $p: {
+    "element": T;
+}) => _pi.List<T>;
+export declare const get_entry_from_stack: <Source, T>($: Lookup_Stack<T>, $p: {
+    "reference": unresolved$.Reference_To_Stacked_Dictionary_Entry<Source, T>;
+    "location 2 string": Location_to_String<Source>;
+}) => resolved$.Reference_To_Stacked_Dictionary_Entry<Source, T>;
+export declare const get_entry: <Source, T>($: Acyclic_Lookup<T>, $p: {
+    "reference": unresolved$.Reference_To_Normal_Dictionary_Entry<Source, T>;
+    "location 2 string": Location_to_String<Source>;
+}) => resolved$.Reference_To_Normal_Dictionary_Entry<Source, T>;
+export declare const resolve_path: <Source, Unresolved_Element, Resolved_Element extends initialize.list.NonUndefined, Seed>($: unresolved$.List<Source, Unresolved_Element>, $p: {
+    "seed": Seed;
+    "map": ($: Unresolved_Element, current: Seed) => Resolved_Step<Resolved_Element, Seed>;
+}) => Path<Source, Resolved_Element, Seed>;
+export declare const resolve_dictionary: <Source, TUnresolved, TResolved>($: unresolved$.Dictionary<Source, TUnresolved>, $p: {
+    "map": ($: Key_Value_Location_Triplet<Source, TUnresolved>, $l: {
+        "possibly circular dependent siblings": Cyclic_Lookup<TResolved>;
+    }) => TResolved;
+    "location 2 string": ($: Source) => string;
+}) => resolved$.Dictionary<Source, TResolved>;
+export declare const resolve_dense_dictionary: <Source, TUnresolved, TResolved, TBenchmark>($: unresolved$.Dictionary<Source, TUnresolved>, $p: {
+    "denseness benchmark": _pi.Dictionary<TBenchmark>;
+    "map": ($: Key_Value_Location_Triplet<Source, TUnresolved>, $l: {
+        "possibly circular dependent siblings": Cyclic_Lookup<TResolved>;
+    }) => TResolved;
+    "location 2 string": ($: Source) => string;
+}) => resolved$.Dictionary<Source, TResolved>;
+export declare const resolve_dense_ordered_dictionary: <Source, TUnresolved, TResolved, TBenchmark>($: unresolved$.Dictionary<Source, TUnresolved>, $p: {
+    "denseness benchmark": _pi.Dictionary<TBenchmark>;
+    "map": ($: Key_Value_Location_Triplet<Source, TUnresolved>, $l: {
+        "possibly circular dependent siblings": Cyclic_Lookup<TResolved>;
+        "not circular dependent siblings": Acyclic_Lookup<TResolved>;
+    }) => TResolved;
+    "location 2 string": ($: Source) => string;
+}) => resolved$.Ordered_Dictionary<Source, TResolved>;
+export declare const resolve_ordered_dictionary: <Source, TUnresolved, TResolved>($: unresolved$.Dictionary<Source, TUnresolved>, $p: {
+    "map": ($: Key_Value_Location_Triplet<Source, TUnresolved>, $l: {
+        "possibly circular dependent siblings": Cyclic_Lookup<TResolved>;
+        "not circular dependent siblings": Acyclic_Lookup<TResolved>;
+    }) => TResolved;
+    "location 2 string": ($: Source) => string;
+}) => resolved$.Ordered_Dictionary<Source, TResolved>;
+export {};