pareto 0.61.0 → 0.63.0

package/auto.dist/public/modules/main/implementations/temp_$compile_$boekhouding.alg.js

@@ -42,7 +42,7 @@ const a_psub = __importStar(require("pareto-subatomic-library"));
 const $$ = ($c, $d) => {
     const t2c = a_pp.tendril__2__cosmos__type__system.map(null, null);
     const t2a = a_pp.tendril__2__alan__light.map__Model__2__Root(null, null);
-    const al2safp = a_pp.alan__light__fountain__pen__indented__file__with__escaped__strings.map__Root__2__Block(null, null);
+    const al2safp = a_pp.alan__light__2__fountain__pen__indented__file__with__escaped__strings.map__Root__2__Block(null, null);
     const fp2l = a_pp.fountain__pen__lines__2__lines.map__Lines__2__Lines(null, null);
     const fp2fp = a_pp.fountain__pen__indented__file__2__fountain__pen__indented__file.map__Block__2__Lines(null, null);
     const createStream = a_pp.fountain__pen__lines__2__lines.stream(null, null);
@@ -80,4 +80,4 @@ const $$ = ($c, $d) => {
     };
 };
 exports.$$ = $$;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/auto.pareto/auto.dependencies/index.ts

@@ -5,7 +5,7 @@ import { $ as dep_pareto_standard_library } from './pareto-standard-library/$.da
 import { $ as dep_pareto_subatomic_library } from './pareto-subatomic-library/$.data'
 
 export const $ = pd.d({
-    'pareto-pure': { library: dep_pareto_pure, version: '^0.22.0' },
-    'pareto-standard-library': { library: dep_pareto_standard_library, version: '^0.9.0' },
-    'pareto-subatomic-library': { library: dep_pareto_subatomic_library, version: '^0.7.0' },
+    'pareto-pure': { library: dep_pareto_pure, version: '^0.23.0' },
+    'pareto-standard-library': { library: dep_pareto_standard_library, version: '^0.10.0' },
+    'pareto-subatomic-library': { library: dep_pareto_subatomic_library, version: '^0.8.0' },
 })

package/auto.pareto/auto.dependencies/pareto-pure/$.data.ts

@@ -37,6 +37,11 @@ import { $ as d_testresult_2_testresult } from "./modules/testresult_2_testresul
 
 import { $ as d_dependencies } from "./auto.dependencies"
 
+const dataglossary = (desc: string[], $: g_project.D.Glossary): g_project.D.Module__Set.glossaries.DX => ({
+    'description': "FIXMEDESCRIPTION",
+    'glossary': $
+})
+
 export const $: g_project.D.Library = {
     'author': "Corno",
     'description': "",
@@ -49,24 +54,24 @@ export const $: g_project.D.Library = {
     'module sets': {
         'public': {
             'glossaries': d({
-                "alan light": d_alan_light,
-                "astn": d_astn,
-                "cosmos type system": d_cosmos_type_system,
-                "cosmos typescript": d_cosmos_typescript,
-                "fountain pen directory": d_fountain_pen_directory,
-                "fountain pen indented file": d_fountain_pen_indented_file,
-                "fountain pen indented file with escaped strings": d_fountain_pen_indented_file_with_escaped_strings,
-                "grammar": d_grammar,
-                "graphviz": d_graphviz,
-                "lines": d_lines,
-                "pareto": d_pareto,
-                "tendril": d_tendril,
-                "tendril resolved": d_tendril_resolved,
-                "testresult": d_testresult,
-                "typescript intermediate": d_typescript_intermediate,
+                "alan light": dataglossary([], d_alan_light),
+                "astn": dataglossary([], d_astn),
+                "cosmos type system": dataglossary([], d_cosmos_type_system),
+                "cosmos typescript": dataglossary([], d_cosmos_typescript),
+                "fountain pen directory": dataglossary([], d_fountain_pen_directory),
+                "fountain pen indented file": dataglossary([], d_fountain_pen_indented_file),
+                "fountain pen indented file with escaped strings": dataglossary([], d_fountain_pen_indented_file_with_escaped_strings),
+                "grammar": dataglossary([], d_grammar),
+                "graphviz": dataglossary([], d_graphviz),
+                "lines": dataglossary([], d_lines),
+                "pareto": dataglossary([], d_pareto),
+                "tendril": dataglossary([], d_tendril),
+                "tendril resolved": dataglossary([], d_tendril_resolved),
+                "testresult": dataglossary([], d_testresult),
+                "typescript intermediate": dataglossary([], d_typescript_intermediate),
             }),
             'modules': d({
-                "alan light fountain pen indented file with escaped strings": d_alan_light_2_fountain_pen_indented_file_with_escaped_strings,
+                "alan light 2 fountain pen indented file with escaped strings": d_alan_light_2_fountain_pen_indented_file_with_escaped_strings,
                 "astn 2 fountain pen with escaped strings": d_astn_2_fountain_pen_indented_file_with_escaped_strings,
                 "fountain pen indented file 2 fountain pen indented file": d_fountain_pen_indented_file_2_fountain_pen_indented_file,
                 "fountain pen lines 2 lines": d_fountain_pen_lines_2_lines,

package/auto.pareto/auto.dependencies/pareto-pure/auto.dependencies/index.ts

@@ -3,5 +3,5 @@ import * as pd from 'pareto-core-data'
 import { $ as dep_pareto_standard_library } from './pareto-standard-library/$.data'
 
 export const $ = pd.d({
-    'pareto-standard-library': { library: dep_pareto_standard_library, version: '^0.9.0' },
+    'pareto-standard-library': { library: dep_pareto_standard_library, version: '^0.10.0' },
 })

package/auto.pareto/auto.dependencies/pareto-pure/auto.dependencies/pareto-standard-library/modules/array/glossary.data.ts

@@ -12,76 +12,78 @@ import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.c
 const d = pd.d
 
 export const $: g_glossary.D.Glossary = {
-    'glossary parameters': d({}),
-    'imports': d({
-    }),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
-            //out
-            "Array": parametrizedType(
-                { "Type": null },
-                array(ref(typeParameter("Type")))
-            ),
+    'data glossary': {
+        'glossary parameters': d({}),
+        'imports': d({
+        }),
+        'root': {
+            'namespaces': d({}),
+            'data types': d({
+                //out
+                "Array": parametrizedType(
+                    { "Type": null },
+                    array(ref(typeParameter("Type")))
+                ),
 
-            "ZippedArray": parametrizedType(
-                { "Benchmark": null, "Focus": null },
-                array(group({
-                    "benchmark": member(ref(typeParameter("Benchmark"))),
-                    "focus": member(ref(typeParameter("Focus"))),
-                }))
-            ),
+                "ZippedArray": parametrizedType(
+                    { "Benchmark": null, "Focus": null },
+                    array(group({
+                        "benchmark": member(ref(typeParameter("Benchmark"))),
+                        "focus": member(ref(typeParameter("Focus"))),
+                    }))
+                ),
 
-            //in
-            "ArrayOfArrays": parametrizedType(
-                { "Type": null },
-                array(ref(typeReference("Array", { "Type": typeParameter("Type") })))),
+                //in
+                "ArrayOfArrays": parametrizedType(
+                    { "Type": null },
+                    array(ref(typeReference("Array", { "Type": typeParameter("Type") })))),
 
-            "AppendParameters": parametrizedType(
-                { "Type": null },
-                group({
-                    "array": member(ref(typeReference("Array", { "Type": typeParameter("Type") }))),
-                    "element": member(ref(typeParameter("Type"))),
-                })
-            ),
-            "PrependParameters": parametrizedType(
-                { "Type": null },
-                group({
-                    "array": member(ref(typeReference("Array", { "Type": typeParameter("Type") }))),
-                    "element": member(ref(typeParameter("Type"))),
-                })
-            ),
-            "ArrayTuple": parametrizedType(
-                { "Benchmark": null, "Focus": null },
-                group({
-                    "benchmark": member(ref(typeReference("Array", { "Type": typeParameter("Benchmark") }))),
-                    "focus": member(ref(typeReference("Array", { "Type": typeParameter("Focus") }))),
-                })
-            ),
-            "Nested": parametrizedType({ "Type": null }, taggedUnion({
-                "single": ref(typeParameter("Type")),
-                "multiple": array(ref(typeReference("Nested", { "Type": typeParameter("Type") }))),
-                "none": null_(),
-            })),
-            // "Array": parametrizedType({ "Type": null }, array(ref(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))),
-            // "KeyValuePair": parametrizedType({ "Type": null }, group({
-            //     "key": member(string()),
-            //     "value": member(ref(typeParameter("Type"))),
-            // })),
+                "AppendParameters": parametrizedType(
+                    { "Type": null },
+                    group({
+                        "array": member(ref(typeReference("Array", { "Type": typeParameter("Type") }))),
+                        "element": member(ref(typeParameter("Type"))),
+                    })
+                ),
+                "PrependParameters": parametrizedType(
+                    { "Type": null },
+                    group({
+                        "array": member(ref(typeReference("Array", { "Type": typeParameter("Type") }))),
+                        "element": member(ref(typeParameter("Type"))),
+                    })
+                ),
+                "ArrayTuple": parametrizedType(
+                    { "Benchmark": null, "Focus": null },
+                    group({
+                        "benchmark": member(ref(typeReference("Array", { "Type": typeParameter("Benchmark") }))),
+                        "focus": member(ref(typeReference("Array", { "Type": typeParameter("Focus") }))),
+                    })
+                ),
+                "Nested": parametrizedType({ "Type": null }, taggedUnion({
+                    "single": ref(typeParameter("Type")),
+                    "multiple": array(ref(typeReference("Nested", { "Type": typeParameter("Type") }))),
+                    "none": null_(),
+                })),
+                // "Array": parametrizedType({ "Type": null }, array(ref(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))),
+                // "KeyValuePair": parametrizedType({ "Type": null }, group({
+                //     "key": member(string()),
+                //     "value": member(ref(typeParameter("Type"))),
+                // })),
 
-            "DependencyDictionary": parametrizedType({ "Type": null }, dictionary(group({
-                "value": member(ref(typeParameter("Type"))),
-                "dependencies": member(dictionary(null_())),
-            }))),
+                "DependencyDictionary": parametrizedType({ "Type": null }, dictionary(group({
+                    "value": member(ref(typeParameter("Type"))),
+                    "dependencies": member(dictionary(null_())),
+                }))),
 
 
-            "KeyValuePairArray": parametrizedType({ "Type": null }, array(ref(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))),
-            "KeyValuePair": parametrizedType({ "Type": null }, group({
-                "key": member(string()),
-                "value": member(ref(typeParameter("Type"))),
-            })),
+                "KeyValuePairArray": parametrizedType({ "Type": null }, array(ref(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))),
+                "KeyValuePair": parametrizedType({ "Type": null }, group({
+                    "key": member(string()),
+                    "value": member(ref(typeParameter("Type"))),
+                })),
 
-        }),
+            }),
+        },
     },
     'interface types': d({}),
     'algorithm types': d({

package/auto.pareto/auto.dependencies/pareto-pure/auto.dependencies/pareto-standard-library/modules/boolean/glossary.data.ts

@@ -17,19 +17,21 @@ import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.c
 const d = pd.d
 
 export const $: g_glossary.D.Glossary = {
-    'glossary parameters': d({}),
-    'imports': d({
-    }),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
-            "Boolean": type(boolean()),
-            "Pair Of Booleans": type(group({
-                "yin": member(boolean()),
-                "yang": member(boolean()),
-            })),
-            "Array Of Booleans": type(array(boolean())),
+    'data glossary': {
+        'glossary parameters': d({}),
+        'imports': d({
         }),
+        'root': {
+            'namespaces': d({}),
+            'data types': d({
+                "Boolean": type(boolean()),
+                "Pair Of Booleans": type(group({
+                    "yin": member(boolean()),
+                    "yang": member(boolean()),
+                })),
+                "Array Of Booleans": type(array(boolean())),
+            }),
+        },
     },
     'interface types': d({}),
     'algorithm types': d({

package/auto.pareto/auto.dependencies/pareto-pure/auto.dependencies/pareto-standard-library/modules/buildInterfaceInitializers/glossary.data.ts

@@ -13,40 +13,43 @@ import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.c
 const d = pd.d
 
 export const $: g_glossary.D.Glossary = {
-    'glossary parameters': d({}),
-    'imports': d({
-    }),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
-            "Simple Array": parametrizedType({ "Type": null }, array(ref(typeParameter("Type")))),
+    'data glossary': {
+        'glossary parameters': d({}),
+        'imports': d({
+        }),
+        'root': {
+            'namespaces': d({}),
+            'data types': d({
+                "Simple Array": parametrizedType({ "Type": null }, array(ref(typeParameter("Type")))),
 
-            "Simple Dictionary": parametrizedType({ "Type": null }, dictionary(ref(typeParameter("Type")))),
-            "Simple String": type(string()),
+                "Simple Dictionary": parametrizedType({ "Type": null }, dictionary(ref(typeParameter("Type")))),
+                "Simple String": type(string()),
 
-            "Array": parametrizedType({ "Type": null, "EndType": null }, group({
-                "array": member(array(ref(typeParameter("Type")))),
-                "end": member(ref(typeParameter("EndType"))),
-            })),
-            "Dictionary": parametrizedType({ "Type": null, "EndType": null }, group({
-                "dictionary": member(dictionary(ref(typeParameter("Type")))),
-                "end": member(ref(typeParameter("EndType"))),
-            })),
-            "String": parametrizedType({ "EndType": null }, group({
-                "string": member(string()),
-                "end": member(ref(typeParameter("EndType"))),
-            })),
-            "KeyValuePair": parametrizedType({ "Type": null }, group({
-                "key": member(string()),
-                "value": member(ref(typeParameter("Type"))),
-            })),
+                "Array": parametrizedType({ "Type": null, "EndType": null }, group({
+                    "array": member(array(ref(typeParameter("Type")))),
+                    "end": member(ref(typeParameter("EndType"))),
+                })),
+                "Dictionary": parametrizedType({ "Type": null, "EndType": null }, group({
+                    "dictionary": member(dictionary(ref(typeParameter("Type")))),
+                    "end": member(ref(typeParameter("EndType"))),
+                })),
+                "String": parametrizedType({ "EndType": null }, group({
+                    "string": member(string()),
+                    "end": member(ref(typeParameter("EndType"))),
+                })),
+                "KeyValuePair": parametrizedType({ "Type": null }, group({
+                    "key": member(string()),
+                    "value": member(ref(typeParameter("Type"))),
+                })),
+
+                "DictionaryBuildStrategy": type(taggedUnion({
+                    "ignore": group({}),
+                    "overwrite": group({}),
+                })),
+                "Startstring": type(string()),
+            }),
+        },
 
-            "DictionaryBuildStrategy": type(taggedUnion({
-                "ignore": group({}),
-                "overwrite": group({}),
-            })),
-            "Startstring": type(string()),
-        }),
     },
     'interface types': d({
         "Array": aInterface(

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

@@ -26,51 +26,53 @@ import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.c
 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")))),
-            "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") }))),
-            })),
-            "ZippedDictionary": parametrizedType({ "Benchmark": null, "Focus": null }, dictionary(group({
-                "benchmark": member(ref(typeParameter("Benchmark"))),
-                "focus": member(optional(ref(typeParameter("Focus")))),
-            }))),
+    'data 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")))),
+                "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") }))),
+                })),
+                "ZippedDictionary": 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") })))
-            })),
-            "KeyValueDictionary": parametrizedType({ "Type": null }, dictionary(ref(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))),
+                "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") })))
+                })),
+                "KeyValueDictionary": parametrizedType({ "Type": null }, dictionary(ref(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))),
 
-            "RekeyDictionary": parametrizedType({ "Type": null }, dictionary(ref(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))),
-            "WrapKeysData": parametrizedType({ "Type": null }, group({
-                "dictionary": member(ref(typeReference("Dictionary", { "Type": typeParameter("Type") }))),
+                "RekeyDictionary": parametrizedType({ "Type": null }, dictionary(ref(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))),
+                "WrapKeysData": parametrizedType({ "Type": null }, group({
+                    "dictionary": member(ref(typeReference("Dictionary", { "Type": typeParameter("Type") }))),
                     "prefix": member(string()),
                     "suffix": member(string()),
-            })),
-        }),
+                })),
+            }),
+        },
     },
     'interface types': d({
     }),

package/auto.pareto/auto.dependencies/pareto-pure/auto.dependencies/pareto-standard-library/modules/nested/glossary.data.ts

@@ -8,14 +8,16 @@ import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.c
 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"))))
+    'data glossary': {
+        'glossary parameters': d({}),
+        'imports': d({
         }),
+        'root': {
+            'namespaces': d({}),
+            'data types': d({
+                "Array": parametrizedType({ "Type": null }, array(ref(typeParameter("Type"))))
+            }),
+        },
     },
     'interface types': d({}),
     'algorithm types': d({

package/auto.pareto/auto.dependencies/pareto-pure/auto.dependencies/pareto-standard-library/modules/number/glossary.data.ts

@@ -10,30 +10,32 @@ import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.c
 const d = pd.d
 
 export const $: g_glossary.D.Glossary = {
-    'glossary parameters': d({}),
-    'imports': d({
-    }),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
-            "Number": type(number()),
-            "OptionalNumber": type(optional(number())),
-            "NumberRange": type(array(number())),
-            "NumberTuple": type(group({
-                "yin": member(number()),
-                "yang": member(number()),
-            })),
-            "SubtractData": type(group({
-                "minuend": member(number()),
-                "subtrahend": member(number()),
-            })),
-            "NumberDictionary": type(dictionary(number())),
-            "NumberArray": type(array(number())),
-
-            "IncrementConfig": type(group({
-                "stepsize": member(number())
-            }))
+    'data glossary': {
+        'glossary parameters': d({}),
+        'imports': d({
         }),
+        'root': {
+            'namespaces': d({}),
+            'data types': d({
+                "Number": type(number()),
+                "OptionalNumber": type(optional(number())),
+                "NumberRange": type(array(number())),
+                "NumberTuple": type(group({
+                    "yin": member(number()),
+                    "yang": member(number()),
+                })),
+                "SubtractData": type(group({
+                    "minuend": member(number()),
+                    "subtrahend": member(number()),
+                })),
+                "NumberDictionary": type(dictionary(number())),
+                "NumberArray": type(array(number())),
+
+                "IncrementConfig": type(group({
+                    "stepsize": member(number())
+                }))
+            }),
+        },
     },
     'interface types': d({}),
     'algorithm types': d({
@@ -46,7 +48,7 @@ export const $: g_glossary.D.Glossary = {
         * if the denominator is 0, the return value is not set
         * (division by 0),
         */
-     
+
         /**
          * calculates the max of an array of numbers. If there are no entries, the result value is 0
          */

package/auto.pareto/auto.dependencies/pareto-pure/auto.dependencies/pareto-standard-library/modules/optional/glossary.data.ts

@@ -10,18 +10,20 @@ import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.c
 const d = pd.d
 
 export const $: g_glossary.D.Glossary = {
-    'glossary parameters': d({}),
-    'imports': d({
-    }),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
-            "OptionalNumber": type(optional(number())),
-            "DivisionData": type(group({
-                "numerator": member(number()),
-                "denominator": member(number()),
-            })),
+    'data glossary': {
+        'glossary parameters': d({}),
+        'imports': d({
         }),
+        'root': {
+            'namespaces': d({}),
+            'data types': d({
+                "OptionalNumber": type(optional(number())),
+                "DivisionData": type(group({
+                    "numerator": member(number()),
+                    "denominator": member(number()),
+                })),
+            }),
+        },
     },
     'interface types': d({}),
     'algorithm types': d({
@@ -32,5 +34,5 @@ export const $: g_glossary.D.Glossary = {
         "Divide": sfunction(typeReference("OptionalNumber"), data(typeReference("DivisionData"))),
         "DivisionRemainder": sfunction(typeReference("OptionalNumber"), data(typeReference("DivisionData"))),
     }),
-     
+
 }

package/auto.pareto/auto.dependencies/pareto-pure/auto.dependencies/pareto-standard-library/modules/resolve/glossary.data.ts

@@ -23,14 +23,16 @@ import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.c
 const d = pd.d
 
 export const $: g_glossary.D.Glossary = {
-    'glossary parameters': d({}),
-    'imports': d({
-    }),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
-
+    'data glossary': {
+        'glossary parameters': d({}),
+        'imports': d({
         }),
+        'root': {
+            'namespaces': d({}),
+            'data types': d({
+
+            }),
+        },
     },
     'interface types': d({}),
     'algorithm types': d({