pareto 0.57.0 → 0.59.0

package/auto.pareto/auto.dependencies/pareto-standard-impure-library/modules/collation/api.data.ts

@@ -1,15 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import { algorithm, algref, api } from "pareto/auto.dist/public/shorthands/cosmos"
-
-import * as g_project from "pareto/auto.dist/public/glossaries/cosmos__type__system"
-
-import { $ as glos } from "./glossary.data"
-import { glossary, group, member, number, type } from 'pareto/auto.dist/public/shorthands/cosmos'
-
-export const $: g_project.D.API = api(
-    glos,
-    {
-        "localeIsBefore": algorithm("IsBefore", null, {}),
-    }
-)

package/auto.pareto/auto.dependencies/pareto-standard-impure-library/modules/collation/glossary.data.ts

@@ -1,34 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import {
-    string, member, group,
-    typeReference,
-    data,
-    sfunction,
-    type,
-    externalTypeReference,
-    boolean,
-} from "pareto/auto.dist/public/shorthands/cosmos"
-
-import * as g_glossary from "pareto/auto.dist/public/glossaries/cosmos__type__system"
-const d = pd.d
-
-export const $: g_glossary.D.Glossary = {
-    'glossary parameters':d({}),
-    'imports': d({
-    }),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
-            "Boolean": type(boolean()),
-            "CompareData": type(group({
-                "benchmark": member(string()),
-                "focus": member(string()),
-            })),
-        }),
-    },
-    'interface types': d({}),
-    'algorithm types': d({
-        "IsBefore": sfunction(typeReference("Boolean"), data(typeReference("CompareData"))),
-    }),
-}

package/auto.pareto/auto.dependencies/pareto-standard-impure-library/modules/dictionary/api.data.ts

@@ -1,60 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import { algorithm, algref, api } from "pareto/auto.dist/public/shorthands/cosmos"
-
-import * as g_project from "pareto/auto.dist/public/glossaries/cosmos__type__system"
-
-import { $ as glos } from "./glossary.data"
-import { aInterface, aInterfaceMethod, glossary, group, member, number, sInterface, sInterfaceMethod, streamconsumer, string, type, typeReference } from 'pareto/auto.dist/public/shorthands/cosmos'
-
-export const $: g_project.D.API = api(
-    glos,
-    {
-        /**
-         * does the dictionary contain the specified key
-         */
-        "contains": algorithm("Contains", null, {}),
-        /**
-         * is the dictionary empty (no entries)
-         */
-        "isEmpty": algorithm("IsEmpty", null, {}),
-        /**
-         * a dictionary where every entry contains optional data is transformed
-         * into a dictionary with only the entries that contained data
-         */
-        "filter": algorithm("Filter", null, {}),
-        /**
-         * a dictionary with containing entries with values and a key candidate is transformed
-         * into a dictionary where the new key of the entry is the candidate. If candidates are not unique
-         * the function panics
-         */
-        "unsafeRekey": algorithm("UnsafeRekey", null, {}),
-        /**
-         * 2 dictionaries are combined into 1 dictionary. If keys are not unique this function panics.
-         */
-        "unsafeMerge": algorithm("UnsafeMerge", null, {}),
-        /**
-         * a key/value pair is added to a dictionary resulting in a new dictionary.
-         * if the key is not unique the function panics
-         */
-        "unsafeAddEntry": algorithm("UnsafeAddEntry", null, {}),
-        /**
-         * a focus dictionary is matched to a benchmark dictionary resulting in a result dictionary
-         * this last dictionary contains all entries found in the benchmark dictionary.
-         * each entry value is optionally supplemented with the value of the focus entry, if found.
-         */
-        "matchDictionaries": algorithm("MatchDictionaries", null, {}),
-        /**
-         * 2 dictionaries are combined into 1 dictionary. is a key exists in both directories, only the entry of the last dictionary will be used.
-         */
-        "mergeAndOverwrite": algorithm("MergeAndOverwrite", null, {}),
-        /**
-         * the keys of the outermost dictionary is combined with the key of the innermost dictionary
-         */
-        "flattenDictionaryOfDictionaries": algorithm("FlattenDictionaryOfDictionaries", null, {}),
-        /**
-         * 2 dictionaries are combined into 1 dictionary. is a key exists in both directories, only the entry of the first dictionary will be used.
-         */
-        "mergeAndIgnore": algorithm("MergeAndIgnore", null, {}),
-    }
-)

package/auto.pareto/auto.dependencies/pareto-standard-impure-library/modules/dictionary/glossary.data.ts

@@ -1,130 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import {
-    dictionary,
-    typeReference,
-    data,
-    sfunction,
-    ref,
-    typeParameter,
-    externalTypeReference,
-    parametrizedType,
-    optional,
-    group,
-    member,
-    aInterface,
-    streamconsumer,
-    aInterfaceMethod,
-    type,
-    string,
-    boolean,
-    sInterface,
-    sInterfaceMethod,
-} from "pareto/auto.dist/public/shorthands/cosmos"
-
-import * as g_glossary from "pareto/auto.dist/public/glossaries/cosmos__type__system"
-const d = pd.d
-
-export const $: g_glossary.D.Glossary = {
-    'glossary parameters': d({}),
-    'imports': d({
-    }),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
-            "Boolean": type(boolean()),
-            "String": type(string()),
-            "KeyValuePair": parametrizedType({ "Type": null }, group({
-                "key": member(string()),
-                "value": member(ref(typeParameter("Type"))),
-            })),
-            "Dictionary": parametrizedType({ "Type": null }, dictionary(ref(typeParameter("Type")))),
-            "DictionaryAndKey": parametrizedType({ "Type": null }, group({
-                "dictionary": member(dictionary(ref(typeParameter("Type")))),
-                "key": member(string()),
-            })),
-            "FilterableDictionary": parametrizedType({ "Type": null }, dictionary(optional(ref(typeParameter("Type"))))),
-            "MergeParameters": parametrizedType({ "Type": null }, group({
-                "primary": member(ref(typeReference("Dictionary", { "Type": typeParameter("Type") }))),
-                "secondary": member(ref(typeReference("Dictionary", { "Type": typeParameter("Type") }))),
-            })),
-            "MatchedDictionary": parametrizedType({ "Benchmark": null, "Focus": null }, dictionary(group({
-                "benchmark": member(ref(typeParameter("Benchmark"))),
-                "focus": member(optional(ref(typeParameter("Focus")))),
-            }))),
-
-            "DictionaryTuple": parametrizedType({ "Benchmark": null, "Focus": null }, group({
-                "benchmark": member(ref(typeReference("Dictionary", { "Type": typeParameter("Benchmark") }))),
-                "focus": member(ref(typeReference("Dictionary", { "Type": typeParameter("Focus") }))),
-            })),
-            "FlattenDictionaryOfDictionariesParameters": parametrizedType({ "Type": null }, group({
-                "dictionaries": member(dictionary(ref(typeReference("Dictionary", { "Type": typeParameter("Type") })))),
-                "separator": member(string()),
-                "escape": member(string()),// to escape if the separator appears in the key of the top level dictionary
-            })),
-            "UnsafeAddEntryParameters": parametrizedType({ "Type": null }, group({
-                "dictionary": member(ref(typeReference("Dictionary", { "Type": typeParameter("Type") }))),
-                "keyValuePair": member(ref(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))
-            })),
-
-
-            "RekeyDictionary": parametrizedType({ "Type": null }, dictionary(ref(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))),
-
-        }),
-    },
-    'interface types': d({
-    }),
-    'algorithm types': d({
-        "Contains": sfunction(
-            typeReference("Boolean"),
-            data(typeReference("DictionaryAndKey", { "Type": typeParameter("Type") })),
-            { "Type": null }
-        ),
-        "IsEmpty": sfunction(
-            typeReference("Boolean"),
-            data(typeReference("Dictionary", { "Type": typeParameter("Type") })),
-            { "Type": null }
-        ),
-        "Filter": sfunction(
-            typeReference("Dictionary", { "Type": typeParameter("Type") }),
-            data(typeReference("FilterableDictionary", { "Type": typeParameter("Type") })),
-            { "Type": null }
-        ),
-        "UnsafeRekey": sfunction(
-            typeReference("Dictionary", { "Type": typeParameter("Type") }),
-            data(typeReference("RekeyDictionary", { "Type": typeParameter("Type") })),
-            { "Type": null }
-        ),
-        "UnsafeMerge": sfunction(
-            typeReference("Dictionary", { "Type": typeParameter("Type") }),
-            data(typeReference("MergeParameters", { "Type": typeParameter("Type") })),
-            { "Type": null }
-        ),
-        "UnsafeAddEntry": sfunction(
-            typeReference("Dictionary", { "Type": typeParameter("Type") }),
-            data(typeReference("UnsafeAddEntryParameters", { "Type": typeParameter("Type") })),
-            { "Type": null }
-        ),
-        "MergeAndIgnore": sfunction(
-            typeReference("Dictionary", { "Type": typeParameter("Type") }),
-            data(typeReference("MergeParameters", { "Type": typeParameter("Type") })),
-            { "Type": null }
-        ),
-        "MatchDictionaries": sfunction(
-            typeReference("MatchedDictionary", { "Benchmark": typeParameter("Benchmark"), "Focus": typeParameter("Focus") }),
-            data(typeReference("DictionaryTuple", { "Benchmark": typeParameter("Benchmark"), "Focus": typeParameter("Focus") })),
-            { "Benchmark": null, "Focus": null }
-        ),
-        "FlattenDictionaryOfDictionaries": sfunction(
-            typeReference("Dictionary", { "Type": typeParameter("Type") }),
-            data(typeReference("FlattenDictionaryOfDictionariesParameters", { "Type": typeParameter("Type") })),
-            { "Type": null }
-        ),
-        "MergeAndOverwrite": sfunction(
-            typeReference("Dictionary", { "Type": typeParameter("Type") }),
-            data(typeReference("MergeParameters", { "Type": typeParameter("Type") })),
-            { "Type": null }
-        ),
-    }),
-
-}

package/auto.pareto/auto.dependencies/pareto-standard-impure-library/modules/filesystem/api.data.ts

@@ -1,19 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import { algorithm, algref, api } from "pareto/auto.dist/public/shorthands/cosmos"
-
-import * as g_project from "pareto/auto.dist/public/glossaries/cosmos__type__system"
-
-import { $ as glos } from "./glossary.data"
-import { glossary, group, member, number, type } from 'pareto/auto.dist/public/shorthands/cosmos'
-
-export const $: g_project.D.API = api(
-    glos,
-    {
-        "createFileWriter": algorithm("CreateFileWriter", null, {}),
-        //"openFileStream": algorithm(functionReference("this", {}, "GetFile"), null, {}),
-        "makeDirectory": algorithm("MakeDirectory", null, {}),
-        "readDirectory": algorithm("ReadDirectory", null, {}),
-        "unlink": algorithm("Unlink", null, {}),
-    }
-)

package/auto.pareto/auto.dependencies/pareto-standard-impure-library/modules/filesystem/glossary.data.ts

@@ -1,189 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import {
-    infInit,
-    afunction, aInterfaceMethod, aInterfaceReference, boolean, data, dictionary, externalTypeReference, group,
-    member, null_, parametrizedType, ref, streamconsumer, string, taggedUnion, type, typeParameter, typeReference, aInterface,
-    array
-} from "pareto/auto.dist/public/shorthands/cosmos"
-
-import * as g_glossary from "pareto/auto.dist/public/glossaries/cosmos__type__system"
-
-const d = pd.d
-
-export const $: g_glossary.D.Glossary = {
-    'glossary parameters': d({}),
-    'imports': d({
-    }),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
-            "Null": type(null_()),
-            "String": type(string()),
-            "Path": type(array(string())),
-            "AnnotatedError": parametrizedType({ "Error": null }, group({
-                "path": member(ref(typeReference("String"))),
-                "error": member(ref(typeParameter("Error"))),
-            })),
-            "Result": parametrizedType({
-                "Error": null,
-                "Success": null,
-            }, taggedUnion({
-                "error": ref(typeParameter("Error")),
-                "success": ref(typeParameter("Success")),
-            })),
-            "AnnotatedReadDirError": type(ref(typeReference("AnnotatedError", {
-                "Error": typeReference("ReadDirError"),
-            }))),
-            "AnnotatedReadFileError": type(ref(typeReference("AnnotatedError", {
-                "Error": typeReference("ReadFileError"),
-            }))),
-            "AnnotatedRmdirError": type(ref(typeReference("AnnotatedError", {
-                "Error": typeReference("RmdirError"),
-            }))),
-            "AnnotatedMkdirError": type(ref(typeReference("AnnotatedError", {
-                "Error": typeReference("MkdirError"),
-            }))),
-            "AnnotatedUnlinkError": type(ref(typeReference("AnnotatedError", {
-                "Error": typeReference("UnlinkError"),
-            }))),
-            "AnnotatedWriteFileError": type(ref(typeReference("AnnotatedError", {
-                "Error": typeReference("WriteFileError"),
-            }))),
-            "WriteFileParameters": type(group({
-                "path": member(ref(typeReference("Path"))),
-                "overwrite if exists": member(boolean()),
-                "create containing directories": member(boolean()),
-            })),
-            // "AnnotatedReadFileError": group({
-            //     "path": member(str()),
-            //     "error": member(taggedUnion({
-            //         "no entity": null_(),
-            //         "is directory": null_(),
-            //         "unknown": type(group({
-            //             "message": member(str()),
-            //         })),
-            //     })),
-            // }),
-            "DirNodeData": type(group({
-                "path": member(string()),
-                "type": member(taggedUnion({
-                    "directory": null_(),
-                    "file": null_(),
-                    "unknown": null_(),
-                })),
-            })),
-            "MkdirError": type(taggedUnion({
-                "no entity": null_(),
-                "exists": null_(),
-                "unknown": group({
-                    "message": member(string()),
-                }),
-            })),
-            "Mkdir_Data": type(group({
-                "path": member(ref(typeReference("Path"))),
-                "createContainingDirectories": member(boolean()),
-            })),
-            "Mkdir_Result": type(ref(typeReference("Result", {
-                "Error": typeReference("AnnotatedMkdirError"),
-                "Success": typeReference("Null"),
-            }))),
-            "ReadDirectory_Data": type(group({
-                "path": member(ref(typeReference("Path"))),
-            })),
-            "ReadDirectory_Success": type(dictionary(ref(typeReference("DirNodeData")))),
-            "ReadDirectory_Result": type(ref(typeReference("Result", {
-                "Error": typeReference("AnnotatedReadDirError"),
-                "Success": typeReference("ReadDirectory_Success"),
-            }))),
-            "ReadDirError": type(taggedUnion({
-                "no entity": null_(),
-                "is not directory": null_(),
-                "unknown": group({
-                    "message": member(string()),
-                }),
-            })),
-            "ReadFile_Result": type(ref(typeReference("Result", {
-                "Error": typeReference("AnnotatedReadFileError"),
-                "Success": typeReference("String"),
-            }))),
-
-            "ReadFile_Data": type(group({
-                "path": member(ref(typeReference("Path"))),
-            })),
-            "ReadFileError": type(taggedUnion({
-                "no entity": null_(),
-                "is directory": null_(),
-                "unknown": group({
-                    "message": member(string()),
-                }),
-            })),
-            "RmdirError": type(taggedUnion({
-                "no entity": null_(),
-                "not empty": null_(),
-                "unknown": group({
-                    "message": member(string()),
-                }),
-            })),
-            "UnlinkError": type(taggedUnion({
-                "no entity": null_(),
-                "is directory": null_(),
-                "unknown": group({
-                    "message": member(string()),
-                }),
-            })),
-            "Unlink_Data": type(group({
-                "path": member(ref(typeReference("Path"))),
-            })),
-            "Unlink_Result": type(ref(typeReference("Result", {
-                "Error": typeReference("AnnotatedUnlinkError"),
-                "Success": typeReference("Null"),
-            }))),
-
-            // "WriteFile_Result": type(ref(typeReference("Result", {
-            //     "Error": typeReference("AnnotatedWriteFileError"),
-            //     "Success": typeReference("common", "Null"),
-            // })),
-
-            "WriteFileError": type(taggedUnion({
-                "no entity": null_(),
-                "is directory": null_(),
-                "unknown": group({
-                    "message": member(string()),
-                }),
-            })),
-        }),
-    },
-    'interface types': d({
-        //these should be defined somewhere but is this the place
-        // "HandleReadDirError": interfaceMethod(typeReference("AnnotatedReadDirFileError"), null, null, null),
-        // "HandleReadFileError": interfaceMethod(typeReference("AnnotatedReadFileError"), null, null, null),
-        // "HandleMkdirError": interfaceMethod(typeReference("AnnotatedMkdirError"), null, null, null),
-        // "HandleUnlinkError": interfaceMethod(typeReference("AnnotatedUnlinkError"), null, null, null),
-
-
-        "OnFileWriteError": aInterface(aInterfaceMethod(typeReference("AnnotatedWriteFileError"))),
-
-
-        // "Reader": ['group', {
-        //     'members': d({
-        //         "init": builderMethod(null, ['reference', builderReference("StreamConsumer")]),
-        //         "onError": builderMethod(typeReference("AnnotatedReadFileError")),
-        //     }),
-        // }]
-        "StringStreamConsumer": aInterface(streamconsumer(
-            aInterfaceMethod(typeReference("String")),
-            aInterfaceMethod(null),
-        )),
-        "WriteFile": aInterface(aInterfaceMethod(typeReference("WriteFileParameters"), ['reference', aInterfaceReference("StringStreamConsumer")])),
-    }),
-    'algorithm types': d({
-        "CreateFileWriter": infInit(aInterfaceReference("WriteFile"), {
-            "onWriteFileError": aInterfaceReference("OnFileWriteError"),
-        }),
-        "MakeDirectory": afunction(typeReference("Mkdir_Result"), typeReference("Mkdir_Data")),
-        "ReadDirectory": afunction(typeReference("ReadDirectory_Result"), typeReference("ReadDirectory_Data")),
-        "Unlink": afunction(typeReference("Unlink_Result"), typeReference("Unlink_Data")),
-        //"OpenFIleStream": afunc(typeReference("common", "Path"), null, null, inf(interfaceReference("Reader"))),
-    }),
-}

package/auto.pareto/auto.dependencies/pareto-standard-impure-library/modules/foreach/api.data.ts

@@ -1,25 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import { algorithm, algref, api } from "pareto/auto.dist/public/shorthands/cosmos"
-
-import * as g_project from "pareto/auto.dist/public/glossaries/cosmos__type__system"
-
-import { $ as glos } from "./glossary.data"
-import { glossary, sibling, group, member, number, type } from 'pareto/auto.dist/public/shorthands/cosmos'
-
-// import { $ as g_collation } from "../collation/glossary.data"
-
-export const $: g_project.D.API = api(
-    glos,
-    {
-        "arrayForEach": algorithm("ArrayForEach", null, {}),
-        "dictionaryForEach": algorithm("DictionaryForEach", null, {
-            //FIXME "compare": sibling("collation", "IsABeforeB"),
-        }),
-        "enrichedArrayForEach": algorithm("EnrichedArrayForEach", null, {}),
-        "enrichedDictionaryForEach": algorithm("EnrichedDictionaryForEach", null, {
-            //FIXME "compare": sibling("collation", "IsABeforeB"),
-        }),
-        "decorateDictionaryEntriesWithKey": algorithm("DecorateDictionaryEntriesWithKey", null, {}),
-    }
-)

package/auto.pareto/auto.dependencies/pareto-standard-impure-library/modules/foreach/glossary.data.ts

@@ -1,78 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import {
-    string,
-    dictionary, member, group,
-    array,
-    typeReference,
-    boolean,
-    ref,
-    sInterfaceMethod,
-    sfunction,
-    data,
-    procedure,
-    sInterfaceReference,
-    parametrizedType,
-    typeParameter,
-    sInterface,
-    optional,
-
-} from "pareto/auto.dist/public/shorthands/cosmos"
-
-import * as g_glossary from "pareto/auto.dist/public/glossaries/cosmos__type__system"
-const d = pd.d
-
-export const $: g_glossary.D.Glossary = {
-    'glossary parameters': d({}),
-    'imports': d({}),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
-            "Array": parametrizedType({ "Type": null }, array(ref(typeParameter("Type")))),
-            "Dictionary": parametrizedType({ "Type": null }, dictionary(ref(typeParameter("Type")))),
-            "KeyValueDictionary": parametrizedType({ "Type": null }, dictionary(ref(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))),
-            "KeyValuePair": parametrizedType({ "Type": null }, group({
-                "key": member(string()),
-                "value": member(ref(typeParameter("Type"))),
-            })),
-            "AnnotatedEntry": parametrizedType({ "Type": null }, group({
-                "isFirst": member(boolean()),
-                "isLast": member(boolean()),
-                "key": member(string()),
-                "value": member(ref(typeParameter("Type"))),
-            })),
-            "AnnotatedElement": parametrizedType({ "Type": null }, group({
-                "isFirst": member(boolean()),
-                "isLast": member(boolean()),
-                "value": member(ref(typeParameter("Type"))),
-            })),
-
-
-        }),
-    },
-    'interface types': d({
-        "OnElement": sInterface(sInterfaceMethod(typeParameter("Type")), { "Type": null }),
-        "OnEntry": sInterface(sInterfaceMethod(typeReference("KeyValuePair", { "Type": typeParameter("Type") })), { "Type": null }),
-        "OnEnrichedDictionary": sInterface(['group', {
-            'members': d({
-                "onEmpty": sInterfaceMethod(null),
-                "onNotEmpty": sInterfaceMethod(null, sInterfaceMethod(typeReference("AnnotatedEntry", { "Type": typeParameter("Type") }))),
-            }),
-        }], { "Type": null }),
-        "OnEnrichedArray": sInterface(['group', {
-            'members': d({
-                "onEmpty": sInterfaceMethod(null),
-                "onNotEmpty": sInterfaceMethod(null, sInterfaceMethod(typeReference("AnnotatedElement", { "Type": typeParameter("Type") }))),
-            }),
-        }], { "Type": null }),
-    }),
-    'algorithm types': d({
-        "ArrayForEach": procedure(data(typeReference("Array", { "Type": typeParameter("Type") })), sInterfaceReference("OnElement", { "Type": typeParameter("Type") }), { "Type": null }),
-        "DictionaryForEach": procedure(data(typeReference("Dictionary", { "Type": typeParameter("Type") })), sInterfaceReference("OnEntry", { "Type": typeParameter("Type") }), { "Type": null }),
-        "EnrichedDictionaryForEach": procedure(data(typeReference("Dictionary", { "Type": typeParameter("Type") })), sInterfaceReference("OnEnrichedDictionary", { "Type": typeParameter("Type") }), { "Type": null }),
-        "EnrichedArrayForEach": procedure(data(typeReference("Array", { "Type": typeParameter("Type") })), sInterfaceReference("OnEnrichedArray", { "Type": typeParameter("Type") }), { "Type": null }),
-        "DecorateDictionaryEntriesWithKey": sfunction(typeReference("KeyValueDictionary", { "Type": typeParameter("Type") }), data(typeReference("Dictionary", { "Type": typeParameter("Type") })), { "Type": null }),
-
-
-    }),
-}

package/auto.pareto/auto.dependencies/pareto-standard-impure-library/modules/http/api.data.ts

@@ -1,16 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import { algorithm, algref, api } from "pareto/auto.dist/public/shorthands/cosmos"
-
-import * as g_project from "pareto/auto.dist/public/glossaries/cosmos__type__system"
-
-import { $ as glos } from "./glossary.data"
-import { array, glossary, group, member, number, ref, string, taggedUnion, type, typeReference } from 'pareto/auto.dist/public/shorthands/cosmos'
-
-export const $: g_project.D.API = api(
-    glos,
-    {
-        "initializeHTTPServerProxy": algorithm("Initialize HTTP Server Proxy", "Configuration", {}),
-        "initializeHTTPSServerProxy": algorithm("Initialize HTTP Server Proxy", "Configuration", {}),
-    }
-)

package/auto.pareto/auto.dependencies/pareto-standard-impure-library/modules/http/glossary.data.ts

@@ -1,69 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import {
-    aInterface, aInterfaceMethod, aInterfaceReference, array, boolean,
-    group, member, ref, resource, streamconsumer, string, taggedUnion, type, typeReference
-} from "pareto/auto.dist/public/shorthands/cosmos"
-
-import * as g_glossary from "pareto/auto.dist/public/glossaries/cosmos__type__system"
-
-const d = pd.d
-
-export const $: g_glossary.D.Glossary = {
-    'glossary parameters': d({}),
-    'imports': d({
-    }),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
-            "Path": type(array(string())),
-            "EncounteredErrors": type(boolean()),
-            "Data": type(taggedUnion({
-                "error": ref(typeReference("HTTPError")),
-                "data": string()
-            })),
-            "HTTPError": type(taggedUnion({
-                "unknown": string(),
-            })),
-
-
-            "Configuration": type(group({
-                "hostName": member(string()),
-                "contextPath": member(ref(typeReference("Path"))),
-            })),
-        }),
-    },
-    'interface types': d({
-
-        //"HandleError": interfaceMethod(typeReference("HTTPError")),
-        // "ProcessHTTPResource": func(typeReference("common", "Path"), null, builderReference("Init"), null),
-        //"Init": aInterface(aInterfaceMethod(null, ['reference', aInterfaceReference("StreamConsumer")])),
-        // "Init": ['choice', {
-        //     'options': d({
-        //         "success": ['reference', aInterfaceReference("StreamConsumer")],
-        //         "error": ['reference', aInterfaceReference("ErrorStreamConsumer")],
-        //     })
-        // }],
-        // "Init": builderMethod(null, ['reference', {
-        //     'context': ['local', null],
-        //     'interface': "StreamConsumer"
-        // }], false),
-        // "StreamConsumer": aInterface(streamconsumer(
-        //     aInterfaceMethod(externalTypeReference("common", "String")),
-        //     aInterfaceMethod(typeReference("EncounteredErrors")),
-        // )),
-        "Consumer": aInterface(streamconsumer(
-            aInterfaceMethod(typeReference("Data")),
-            aInterfaceMethod(null),
-        )),
-    }),
-    'algorithm types': d({
-        "Initialize HTTP Server Proxy": resource(typeReference("Path"), aInterfaceReference("Consumer")),
-        // "HTTPRequest": a(, {
-        //     "init": aInterfaceReference("Init"),
-        //     "errorConsumer": aInterfaceReference("ErrorStreamConsumer")
-        // })
-
-    }),
-
-}

package/auto.pareto/auto.dependencies/pareto-standard-impure-library/modules/json/api.data.ts

@@ -1,16 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import { algorithm, algref, api } from "pareto/auto.dist/public/shorthands/cosmos"
-
-import * as g_project from "pareto/auto.dist/public/glossaries/cosmos__type__system"
-
-import { $ as glos } from "./glossary.data"
-import { glossary, group, member, number, sInterface, sInterfaceMethod, string, type, typeReference } from 'pareto/auto.dist/public/shorthands/cosmos'
-
-export const $: g_project.D.API = api(
-    glos,
-    {
-        "convertJSON": algorithm("ConvertJSON", null, {}),
-        "unsafeConvertJSON": algorithm("UnsafeConvertJSON", null, {}),
-    }
-)