exupery-core-internals 0.1.0

package/dist/imp/private/create_async_registry.d.ts

@@ -0,0 +1,14 @@
+export type I_Async_Registry = {
+    readonly 'register': () => void;
+    readonly 'report_finished': () => void;
+};
+/**
+ * this function provides a callback with a counter as parameter
+ * when the counter reaches 0, the onEnd callback is called
+ *
+ * this function is specifically useful for async map functions
+ *
+ * @param callback this callback creates a scope within which the counter is provided
+ * @param onEnd this callback will be called when the counter reaches 0
+ */
+export declare function create_async_registry(registration_phase: ($: I_Async_Registry) => void, on_all_finished: () => void): void;

package/dist/imp/private/create_async_registry.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create_async_registry = create_async_registry;
+/**
+ * this function provides a callback with a counter as parameter
+ * when the counter reaches 0, the onEnd callback is called
+ *
+ * this function is specifically useful for async map functions
+ *
+ * @param callback this callback creates a scope within which the counter is provided
+ * @param onEnd this callback will be called when the counter reaches 0
+ */
+function create_async_registry(registration_phase, on_all_finished) {
+    let counter = 0;
+    /*
+     * we need to keep track of if the registration phase is ended or not.
+     * it can happen that the counter reaches 0 during the registration phase, specifically if there is no real async calls being made
+     * in that case the reportFinished counter is als called during the registration phase.
+     * If that happens there should not yet be a call to onEnd().
+     */
+    let registration_phase_ended = false;
+    let on_all_finished_has_been_called = false;
+    function checkStatus() {
+        if (registration_phase_ended) {
+            if (counter === 0) {
+                if (on_all_finished_has_been_called === true) {
+                    throw new Error("CORE: already ended");
+                }
+                on_all_finished_has_been_called = true;
+                on_all_finished();
+            }
+        }
+    }
+    registration_phase({
+        register: () => {
+            if (on_all_finished_has_been_called) {
+                throw new Error("CORE: async call done after context is ready");
+            }
+            counter += 1;
+        },
+        report_finished: () => {
+            if (counter === 0) {
+                throw new Error("CORE: decrement while counter is 0");
+            }
+            counter -= 1;
+            checkStatus();
+        },
+    });
+    registration_phase_ended = true;
+    checkStatus();
+}

package/dist/imp/public/array_literal.d.ts

@@ -0,0 +1,9 @@
+import * as pt from "exupery-core-types";
+/**
+ * returns a Exupery array
+ * why is this not the constructor? to call a constructor, you have to use the keyword 'new'. Exupery doesn't use the concept of a class so that keyword should be avoided
+
+ * @param source An array literal
+ * @returns
+ */
+export declare function array_literal<T>(source: readonly T[]): pt.Array<T>;

package/dist/imp/public/array_literal.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.array_literal = array_literal;
+const create_async_registry_1 = require("../private/create_async_registry");
+const cast_to_async_value_imp_1 = require("./cast_to_async_value_imp");
+const not_set_1 = require("./not_set");
+const set_1 = require("./set");
+/**
+ * this is an implementation, not public by design
+ * If you feel the need to rename this class, don't rename it to 'Array',
+ * it will break the 'instanceOf Array' test
+ */
+class Array_Class {
+    constructor(data) {
+        this.data = data;
+    }
+    map($v) {
+        return array_literal(this.data.map((entry) => {
+            return $v(entry);
+        }));
+    }
+    async_map($v) {
+        // const elements = source.map($v)
+        // let _isGuaranteedToReturnAResult = true
+        // source.forEach(($) => {
+        //     if ($)
+        // })
+        function array(array, $v) {
+            const mapped = array.map($v);
+            return (0, cast_to_async_value_imp_1.cast_to_async_value_imp)(($c) => {
+                const temp = [];
+                (0, create_async_registry_1.create_async_registry)((registry) => {
+                    mapped.forEach((v) => {
+                        registry.register();
+                        v.__execute((v) => {
+                            temp.push(v);
+                            registry.report_finished();
+                        });
+                    });
+                }, () => {
+                    $c(array_literal(temp));
+                });
+            });
+        }
+        return array(this.data, $v);
+    }
+    /////////
+    __for_each($i) {
+        this.data.forEach(($) => {
+            $i($);
+        });
+    }
+    __get_length() {
+        return this.data.length;
+    }
+    __get_element_at(index) {
+        if (index < 0 || index >= this.data.length) {
+            return (0, not_set_1.not_set)();
+        }
+        return (0, set_1.set)(this.data[index]);
+    }
+    __get_raw_copy() {
+        return this.data.slice();
+    }
+}
+/**
+ * returns a Exupery array
+ * why is this not the constructor? to call a constructor, you have to use the keyword 'new'. Exupery doesn't use the concept of a class so that keyword should be avoided
+
+ * @param source An array literal
+ * @returns
+ */
+function array_literal(source) {
+    const data = source.slice(); //create a copy
+    if (!(data instanceof Array)) {
+        throw new Error("invalid input in 'array_literal'");
+    }
+    return new Array_Class(source);
+}

package/dist/imp/public/assert_unreachable.d.ts

@@ -0,0 +1,15 @@
+/**
+ * au means 'assert unreachable'. Used in the 'default' clause of switch statements to ensure
+ * during compile time that all possible cases have been implemented
+ *
+ * example:
+ *
+ * switch (x) {
+ *     case "5":
+ *         break
+ *     default: au(x)
+ * }
+ *
+ * @param _x
+ */
+export declare function au<RT>(_x: never): RT;

package/dist/imp/public/assert_unreachable.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.au = au;
+/**
+ * au means 'assert unreachable'. Used in the 'default' clause of switch statements to ensure
+ * during compile time that all possible cases have been implemented
+ *
+ * example:
+ *
+ * switch (x) {
+ *     case "5":
+ *         break
+ *     default: au(x)
+ * }
+ *
+ * @param _x
+ */
+function au(_x) {
+    throw new Error("unreachable");
+}

package/dist/imp/public/block.d.ts

@@ -0,0 +1,12 @@
+/**
+ *
+ * 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
+ * })
+ */
+export declare function block<RT>(callback: () => RT): RT;

package/dist/imp/public/block.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.block = block;
+/**
+ *
+ * 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 block(callback) {
+    return callback();
+}

package/dist/imp/public/cast_to_async_value_imp.d.ts

@@ -0,0 +1,8 @@
+import * as pt from "exupery-core-types";
+import { Execute } from "../types/Execute";
+/**
+ * returns an {@link Async_Value }
+ * @param execute the function that produces the eventual value
+ * @returns
+ */
+export declare function cast_to_async_value_imp<T>(execute: Execute<T>): pt.Async_Value<T>;

package/dist/imp/public/cast_to_async_value_imp.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cast_to_async_value_imp = cast_to_async_value_imp;
+class Async_Value_Class {
+    constructor(execute) {
+        this.execute = execute;
+    }
+    map($v) {
+        function rewrite(source, rewrite) {
+            return cast_to_async_value_imp(((cb) => {
+                source((v) => {
+                    rewrite(v).__execute(cb);
+                });
+            }));
+        }
+        return rewrite(this.execute, $v);
+    }
+    __execute($i) {
+        this.execute($i);
+    }
+}
+/**
+ * returns an {@link Async_Value }
+ * @param execute the function that produces the eventual value
+ * @returns
+ */
+function cast_to_async_value_imp(execute) {
+    return new Async_Value_Class(execute);
+}

package/dist/imp/public/change_context.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 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
+ */
+export declare function cc<T, RT>(input: T, callback: (output: T) => RT): RT;

package/dist/imp/public/change_context.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cc = cc;
+/**
+ * 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 cc(input, callback) {
+    return callback(input);
+}

package/dist/imp/public/dictionary_literal.d.ts

@@ -0,0 +1,11 @@
+import * as pt from "exupery-core-types";
+/**
+ * returns a Exupery dictionary
+ *
+ * why is this not the constructor? to call a constructor, you have to use the keyword 'new'. Exupery doesn't use the concept of a class so that keyword should be avoided
+ * @param source An object literal
+ * @returns
+ */
+export declare function dictionary_literal<T>(source: {
+    readonly [key: string]: T;
+}): pt.Dictionary<T>;

package/dist/imp/public/dictionary_literal.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dictionary_literal = dictionary_literal;
+const create_async_registry_1 = require("../private/create_async_registry");
+const cast_to_async_value_imp_1 = require("./cast_to_async_value_imp");
+const set_1 = require("./set");
+const not_set_1 = require("./not_set");
+const array_literal_1 = require("./array_literal");
+/**
+ * this is an implementation, not public by design
+ */
+class Dictionary {
+    constructor(source) {
+        this.source = source;
+    }
+    map($v) {
+        return new Dictionary(this.source.map(($) => {
+            return {
+                key: $.key,
+                value: $v($.value, $.key)
+            };
+        }));
+    }
+    async_map($v) {
+        function imp(dictionary_as_array, $v) {
+            const mapped = dictionary_as_array.map(($) => {
+                return {
+                    key: $.key,
+                    value: $v($.value),
+                };
+            });
+            return (0, cast_to_async_value_imp_1.cast_to_async_value_imp)((cb) => {
+                const temp = {};
+                (0, create_async_registry_1.create_async_registry)((counter) => {
+                    mapped.map(($) => {
+                        counter.register();
+                        $.value.__execute((nv) => {
+                            temp[$.key] = nv;
+                            counter.report_finished();
+                        });
+                    });
+                }, () => {
+                    cb(dictionary_literal(temp));
+                });
+            });
+        }
+        return imp(this.source, $v);
+    }
+    __map_with_key($v) {
+        return new Dictionary(this.source.map(($) => {
+            return {
+                key: $.key,
+                value: $v($.value, $.key),
+            };
+        }));
+    }
+    to_array(compare) {
+        const sorted_keys = this.source.slice().sort(compare);
+        return (0, array_literal_1.array_literal)(sorted_keys);
+    }
+    __get_entry(key) {
+        for (let i = 0; i !== this.source.length; i += 1) {
+            const element = this.source[i];
+            if (element.key === key) {
+                return (0, set_1.set)(element.value);
+            }
+        }
+        return (0, not_set_1.not_set)();
+    }
+    __add_entry_if_not_exists(key, value) {
+        for (let i = 0; i !== this.source.length; i += 1) {
+            const element = this.source[i];
+            if (element.key === key) {
+                return this;
+            }
+        }
+        return new Dictionary([...this.source, { key: key, value: value }]);
+    }
+    __add_entry_overwrite_if_exists(key, value) {
+        return new Dictionary(this.source.map((entry) => {
+            if (entry.key === key) {
+                return { key: key, value: value };
+            }
+            else {
+                return entry;
+            }
+        }));
+    }
+    __remove_entry_if_exists(key) {
+        return new Dictionary(this.source.filter((entry) => {
+            return entry.key !== key;
+        }));
+    }
+}
+/**
+ * returns a Exupery dictionary
+ *
+ * why is this not the constructor? to call a constructor, you have to use the keyword 'new'. Exupery doesn't use the concept of a class so that keyword should be avoided
+ * @param source An object literal
+ * @returns
+ */
+function dictionary_literal(source) {
+    //first we clone the source data so that changes to that source will have no impact on this implementation.
+    //only works if the set does not become extremely large
+    function create_dictionary_as_array(source) {
+        const imp = [];
+        Object.keys(source).forEach((key) => {
+            imp.push({ key: key, value: source[key] });
+        });
+        return imp;
+    }
+    const daa = create_dictionary_as_array(source);
+    return new Dictionary(daa);
+}

package/dist/imp/public/get_location_info.d.ts

@@ -0,0 +1,13 @@
+export type Source_Location = {
+    'file': string;
+    'line': number;
+    'column': number;
+};
+/**
+ * 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 get_location_info(depth: number): Source_Location;
+export declare function location_to_string(location: Source_Location): string;

package/dist/imp/public/get_location_info.js

@@ -0,0 +1,80 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.get_location_info = get_location_info;
+exports.location_to_string = location_to_string;
+const process = __importStar(require("process"));
+const path = __importStar(require("path"));
+/**
+ *
+ * @returns the string on the specified line
+ */
+function get_line(e, depth) {
+    const regex = /\((.*)\)$/;
+    //const regex = /\((.*):(\d+):(\d+)\)$/ //further splitted; file,line,column,
+    if (e.stack === undefined) {
+        throw new Error("NO STACK INFO");
+    }
+    const line = e.stack.split("\n")[depth + 2];
+    const match = regex.exec(line);
+    //determine the path relative to the current working directory
+    return path.relative(process.cwd(), (() => {
+        if (match === null) {
+            const begin = "    at /";
+            if (line.startsWith(begin)) {
+                return path.relative(process.cwd(), line.substring(begin.length - 1));
+            }
+            else {
+                throw new Error(`COULD NOT PARSE STACK LINE: ${line}`);
+            }
+        }
+        else {
+            return match[1];
+        }
+    })());
+}
+/**
+ * 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 get_location_info(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
+    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]),
+    };
+}
+function location_to_string(location) {
+    return `${location.file}:${location.line}:${location.column}`;
+}

package/dist/imp/public/make_async.d.ts

@@ -0,0 +1,7 @@
+import * as pt from "exupery-core-types";
+/**
+ * converts a regular value to a {@link Async_Value}
+ * @param $ the value
+ * @returns
+ */
+export declare function make_async<T>($: T): pt.Async_Value<T>;

package/dist/imp/public/make_async.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.make_async = make_async;
+const cast_to_async_value_imp_1 = require("./cast_to_async_value_imp");
+/**
+ * converts a regular value to a {@link Async_Value}
+ * @param $ the value
+ * @returns
+ */
+function make_async($) {
+    return (0, cast_to_async_value_imp_1.cast_to_async_value_imp)(($c) => {
+        $c($);
+    });
+}

package/dist/imp/public/not_set.d.ts

@@ -0,0 +1,8 @@
+import * as pt from "exupery-core-types";
+/**
+ * why is this not the constructor? to call a constructor, you have to use the keyword 'new'. Exupery doesn't use the concept of a class so that keyword should be avoided
+
+ * creates a not set Optional_Value
+ * @returns Optional_Value of type T
+ */
+export declare function not_set<T>(): pt.Optional_Value<T>;

package/dist/imp/public/not_set.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.not_set = not_set;
+/**
+ * this is an implementation, not public by design
+ */
+class Not_Set_Value {
+    constructor() {
+        this.__raw = [false];
+    }
+    transform(set, not_set) {
+        return not_set();
+    }
+    map(set) {
+        return not_set();
+    }
+}
+/**
+ * why is this not the constructor? to call a constructor, you have to use the keyword 'new'. Exupery doesn't use the concept of a class so that keyword should be avoided
+
+ * creates a not set Optional_Value
+ * @returns Optional_Value of type T
+ */
+function not_set() {
+    return new Not_Set_Value();
+}

package/dist/imp/public/panic.d.ts

@@ -0,0 +1,10 @@
+export declare function panic_for_internal_functions(depth: number, message: string): never;
+/**
+ * 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
+ */
+export declare function panic(message: string): never;

package/dist/imp/public/panic.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.panic_for_internal_functions = panic_for_internal_functions;
+exports.panic = panic;
+const get_location_info_1 = require("./get_location_info");
+function panic_for_internal_functions(depth, message) {
+    const location = (0, get_location_info_1.get_location_info)(depth + 1);
+    console.error(`PANIC: ${message} @ ${(0, get_location_info_1.location_to_string)(location)}`);
+    const e = new Error();
+    console.error(e.stack);
+    process.exit(1);
+}
+/**
+ * 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) {
+    panic_for_internal_functions(1, message);
+}

package/dist/imp/public/resolve_async_tuple_2.d.ts

@@ -0,0 +1,6 @@
+import * as pt from 'exupery-core-types';
+export type Sync_Tuple_2<T1, T2> = {
+    readonly 'first': T1;
+    readonly 'second': T2;
+};
+export declare function resolve_async_tuple_2<T1, T2>(first: pt.Async_Value<T1>, second: pt.Async_Value<T2>): pt.Async_Value<Sync_Tuple_2<T1, T2>>;

package/dist/imp/public/resolve_async_tuple_2.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolve_async_tuple_2 = resolve_async_tuple_2;
+const cast_to_async_value_imp_1 = require("./cast_to_async_value_imp");
+function resolve_async_tuple_2(first, second) {
+    return (0, cast_to_async_value_imp_1.cast_to_async_value_imp)((cb) => {
+        let element_1_is_set = false;
+        let element_2_is_set = false;
+        let elem1;
+        let elem2;
+        function wrap_up() {
+            if (element_1_is_set && element_2_is_set) {
+                cb({ first: elem1, second: elem2 });
+            }
+        }
+        first.__execute((val) => {
+            elem1 = val;
+            element_1_is_set = true;
+            wrap_up();
+        });
+        second.__execute((val) => {
+            elem2 = val;
+            element_2_is_set = true;
+            wrap_up();
+        });
+    });
+}

package/dist/imp/public/set.d.ts

@@ -0,0 +1,7 @@
+import * as pt from "exupery-core-types";
+/**
+ * returns a set {@link Optional_Value}.
+
+ * @param $ the set value
+ */
+export declare function set<T>($: T): pt.Optional_Value<T>;

package/dist/imp/public/set.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.set = set;
+/**
+ * this is an implementation, not public by design
+ */
+class Set_Value {
+    constructor(source) {
+        this.source = source;
+        this.__raw = [true, source];
+        this.value = source;
+    }
+    transform(set, not_set) {
+        if (this.__raw[0] === true) {
+            return set(this.__raw[1]);
+        }
+        else {
+            return not_set();
+        }
+    }
+    map(if_set) {
+        return set(if_set(this.value));
+    }
+}
+/**
+ * returns a set {@link Optional_Value}.
+
+ * @param $ the set value
+ */
+function set($) {
+    return new Set_Value($);
+}

package/dist/imp/public/switch_state.d.ts

@@ -0,0 +1,19 @@
+export type State<T> = readonly [string | boolean, T];
+/**
+ * ss means 'switch state'.
+ * used to make the value T the context variable ('$')
+ * given a tuple of a string (or boolean) and a value T,
+ * the function takes the value T and calls back the callback ($c)
+ * notice that the string part is never used
+ *
+ * example:
+ *
+ * switch ($.state[0]) {
+ *     case "on":
+ *          return ss($.state, ($) => $.value
+ *     case "off":
+ *          return ss($.state, ($) => null
+ *     default: au($.state[0])
+ * }
+ */
+export declare function ss<T, RT>($: State<T>, $c: ($: T) => RT): RT;

package/dist/imp/public/switch_state.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ss = ss;
+/**
+ * ss means 'switch state'.
+ * used to make the value T the context variable ('$')
+ * given a tuple of a string (or boolean) and a value T,
+ * the function takes the value T and calls back the callback ($c)
+ * notice that the string part is never used
+ *
+ * example:
+ *
+ * switch ($.state[0]) {
+ *     case "on":
+ *          return ss($.state, ($) => $.value
+ *     case "off":
+ *          return ss($.state, ($) => null
+ *     default: au($.state[0])
+ * }
+ */
+function ss($, $c) {
+    return $c($[1]);
+}

package/dist/imp/types/Execute.d.ts

@@ -0,0 +1,5 @@
+/**
+ * function that (eventually) produces a value.
+ * the value is provided in a callback ($c)
+ */
+export type Execute<T> = ($c: ($: T) => void) => void;

package/dist/imp/types/Execute.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+export * from "./imp/public/dictionary_literal";
+export * from "./imp/public/array_literal";
+export * from "./imp/public/panic";
+export * from "./imp/public/assert_unreachable";
+export * from "./imp/public/change_context";
+export * from "./imp/public/block";
+export * from "./imp/public/switch_state";
+export * from "./imp/public/get_location_info";
+export * from "./imp/public/resolve_async_tuple_2";
+export * from "./imp/public/make_async";
+export * from "./imp/public/cast_to_async_value_imp";
+export * from "./imp/public/set";
+export * from "./imp/public/not_set";

package/dist/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 });
+__exportStar(require("./imp/public/dictionary_literal"), exports);
+__exportStar(require("./imp/public/array_literal"), exports);
+__exportStar(require("./imp/public/panic"), exports);
+__exportStar(require("./imp/public/assert_unreachable"), exports);
+__exportStar(require("./imp/public/change_context"), exports);
+__exportStar(require("./imp/public/block"), exports);
+__exportStar(require("./imp/public/switch_state"), exports);
+__exportStar(require("./imp/public/get_location_info"), exports);
+__exportStar(require("./imp/public/resolve_async_tuple_2"), exports);
+__exportStar(require("./imp/public/make_async"), exports);
+__exportStar(require("./imp/public/cast_to_async_value_imp"), exports);
+__exportStar(require("./imp/public/set"), exports);
+__exportStar(require("./imp/public/not_set"), exports);

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "exupery-core-internals",
+  "version": "0.1.0",
+  "license": "ISC",
+  "description": "",
+  "author": "Corno",
+  "keywords": [
+    "exupery",
+    "internals",
+    "wrapRawDictionary",
+    "wrapRawArray"
+  ],
+  "homepage": "https://github.com/corno/exupery-core#readme",
+  "bugs": {
+    "url": "https://github.com/corno/exupery-core/issues"
+  },
+  "dependencies": {
+    "exupery-core-types": "^0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^18.15.3"
+  },
+  "main": "./dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/corno/exupery-core-internals.git"
+  }
+}