pareto 0.61.0 → 0.63.0

package/auto.pareto/auto.dependencies/pareto-subatomic-library/glossaries/lines.data.ts

@@ -11,14 +11,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({
-            "Lines": type(array(string())),
+    'data glossary': {
+        'glossary parameters': d({}),
+        'imports': d({
         }),
+        'root': {
+            'namespaces': d({}),
+            'data types': d({
+                "Lines": type(array(string())),
+            }),
+        },
     },
     'interface types': d({
     }),

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

@@ -11,30 +11,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({
-            "Array": parametrizedType({ "Type": null }, array(ref(typeParameter("Type")))),
-            "Boolean": type(boolean()),
-            "EnrichedArray": parametrizedType({ "Type": null }, array(group({
-                "value": member(ref(typeParameter("Type"))),
-                "isFirst": member(boolean()),
-                "isLast": member(boolean()),
-                "position": member(number()),
-            }))),
-            "GetElementAtData": parametrizedType({ "Type": null }, group({
-                "array": member(ref(typeReference("Array", { "Type": typeParameter("Type") }))),
-                "index": member(number()),
-            })),
-            "Length": type(number()),
-            "OptionalValue": parametrizedType({ "Type": null }, optional(ref(typeParameter("Type")))),
-            "Value": parametrizedType({ "Type": null }, ref(typeParameter("Type"))),
-            
-
+    'data glossary': {
+        'glossary parameters': d({}),
+        'imports': d({
         }),
+        'root': {
+            'namespaces': d({}),
+            'data types': d({
+                "Array": parametrizedType({ "Type": null }, array(ref(typeParameter("Type")))),
+                "Boolean": type(boolean()),
+                "EnrichedArray": parametrizedType({ "Type": null }, array(group({
+                    "value": member(ref(typeParameter("Type"))),
+                    "isFirst": member(boolean()),
+                    "isLast": member(boolean()),
+                    "position": member(number()),
+                }))),
+                "GetElementAtData": parametrizedType({ "Type": null }, group({
+                    "array": member(ref(typeReference("Array", { "Type": typeParameter("Type") }))),
+                    "index": member(number()),
+                })),
+                "Length": type(number()),
+                "OptionalValue": parametrizedType({ "Type": null }, optional(ref(typeParameter("Type")))),
+                "Value": parametrizedType({ "Type": null }, ref(typeParameter("Type"))),
+
+
+            }),
+        },
     },
     'interface types': d({}),
     'algorithm types': d({

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

@@ -27,24 +27,26 @@ 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()),
-            "Dictionary": parametrizedType({ "Type": null }, dictionary(ref(typeParameter("Type")))),
-            "DictionaryAndKey": parametrizedType({ "Type": null }, group({
-                "dictionary": member(dictionary(ref(typeParameter("Type")))),
-                "key": member(string()),
-            })),
-            
-            "Number": type(number()),
-            "PossibleValue": parametrizedType({ "Type": null }, optional(ref(typeParameter("Type")))),
-            "Value": parametrizedType({ "Type": null }, ref(typeParameter("Type"))),
-
+    'data glossary': {
+        'glossary parameters': d({}),
+        'imports': d({
         }),
+        'root': {
+            'namespaces': d({}),
+            'data types': d({
+                "Boolean": type(boolean()),
+                "Dictionary": parametrizedType({ "Type": null }, dictionary(ref(typeParameter("Type")))),
+                "DictionaryAndKey": parametrizedType({ "Type": null }, group({
+                    "dictionary": member(dictionary(ref(typeParameter("Type")))),
+                    "key": member(string()),
+                })),
+
+                "Number": type(number()),
+                "PossibleValue": parametrizedType({ "Type": null }, optional(ref(typeParameter("Type")))),
+                "Value": parametrizedType({ "Type": null }, ref(typeParameter("Type"))),
+
+            }),
+        },
     },
     'interface types': d({
     }),
@@ -66,7 +68,7 @@ export const $: g_glossary.D.Glossary = {
             { "Type": null }
         ),
 
-        "Size": sfunction(    
+        "Size": sfunction(
             typeReference("Number"),
             data(typeReference("Dictionary", { "Type": typeParameter("Type") })),
             { "Type": null }

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

@@ -27,23 +27,25 @@ 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({
-        "lines": imp(d_lines, {}),
-    }),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
-            "File Path": type(array(string())),
-            "File Write Data": type(group({
-                "directory path": member(ref(typeReference("File Path"))),
-                "file name": member(string()),
-                "data": member(ref(externalTypeReference("lines", "Lines"))),
-            })),
-            "Root Data": type(group({
-                "context directory": member(string()),
-            })),
+    'data glossary': {
+        'glossary parameters': d({}),
+        'imports': d({
+            "lines": imp(d_lines, {}),
         }),
+        'root': {
+            'namespaces': d({}),
+            'data types': d({
+                "File Path": type(array(string())),
+                "File Write Data": type(group({
+                    "directory path": member(ref(typeReference("File Path"))),
+                    "file name": member(string()),
+                    "data": member(ref(externalTypeReference("lines", "Lines"))),
+                })),
+                "Root Data": type(group({
+                    "context directory": member(string()),
+                })),
+            }),
+        },
     },
     'interface types': d({
         "RootFileWriter": aInterface(aInterfaceMethod(typeReference("Root Data"), infref(aInterfaceReference("FileWriter")))),

package/auto.pareto/auto.dependencies/pareto-subatomic-library/modules/json/glossary.data.ts

@@ -14,28 +14,31 @@ 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({
-            "String": type(string()),
-            "Result": type(taggedUnion({
-                "success": ref(typeReference("Value")),
-                "error": string(),
-            })),
-            //"Result": type(ref(glossaryParameter("Type"))),
-            "Value": type(taggedUnion({
-                "object": dictionary(ref(typeReference("Value"))),
-                "array": array(ref(typeReference("Value"))),
-                "string": string(),
-                "number": number(),
-                "boolean": boolean(),
-                "null": null_(),
-            })),
 
+    'data glossary': {
+        'glossary parameters': d({
         }),
+        'imports': d({}),
+        'root': {
+            'namespaces': d({}),
+            'data types': d({
+                "String": type(string()),
+                "Result": type(taggedUnion({
+                    "success": ref(typeReference("Value")),
+                    "error": string(),
+                })),
+                //"Result": type(ref(glossaryParameter("Type"))),
+                "Value": type(taggedUnion({
+                    "object": dictionary(ref(typeReference("Value"))),
+                    "array": array(ref(typeReference("Value"))),
+                    "string": string(),
+                    "number": number(),
+                    "boolean": boolean(),
+                    "null": null_(),
+                })),
+
+            }),
+        },
     },
     'interface types': d({
 

package/auto.pareto/auto.dependencies/pareto-subatomic-library/modules/numerical_predicates/glossary.data.ts

@@ -10,24 +10,26 @@ 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()),
-            "Number": type(number()),
-            "NumberPair": type(group({
-                "yin": member(number()),
-                "yang": member(number()),
-            })),
-            "CompareData": type(group({
-                "benchmark": member(number()),
-                "focus": member(number()),
-            })),
-
+    'data glossary': {
+        'glossary parameters': d({}),
+        'imports': d({
         }),
+        'root': {
+            'namespaces': d({}),
+            'data types': d({
+                "Boolean": type(boolean()),
+                "Number": type(number()),
+                "NumberPair": type(group({
+                    "yin": member(number()),
+                    "yang": member(number()),
+                })),
+                "CompareData": type(group({
+                    "benchmark": member(number()),
+                    "focus": member(number()),
+                })),
+
+            }),
+        },
     },
     'interface types': d({}),
     'algorithm types': d({

package/auto.pareto/auto.dependencies/pareto-subatomic-library/modules/string/glossary.data.ts

@@ -12,75 +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({
-            "String": type(string()),
-            "Length": type(number()),
-            "Boolean": type(boolean()),
-            "Character Code": type(number()),
-            "Possible Character Code": type(optional(number())),
-            "Possible Position": type(optional(number())),
 
-            "CharacterCode At Data": type(group({
-                "contextString": member(string()),
-                "index": member(number()),
-            })),
-            "CharacterArray": type(array(number())),
-            "SplitData": type(group({
-                "contextString": member(string()),
-                "splitter": member(string()),
-            })),
-            "IncludesData": type(group({
-                "contextString": member(string()),
-                "searchString": member(string()),
-            })),
-            "SplitIn2Result": type(group({
-                "head": member(string()),
-                "tail": member(optional(string())),
-            })),
-            "SplitResult": type(array(string())),
-            "StartsWithData": type(group({
-                "contextString": member(string()),
-                "searchString": member(string()),
-            })),
-            "EndsWithData": type(group({
-                "contextString": member(string()),
-                "searchString": member(string()),
-            })),
-            "SubstringData": type(group({
-                "contextString": member(string()),
-                "begin": member(number()),
-                /**
-                 * I'm deliberately choosing length over end here, because length will become a 'natural' in the future
-                 * and then this function is guaranteed to not have a negative length.
-                 * going with 'end' would require a check for negative values.
-                 */
-                "length": member(number()),
-            })),
-            "ReplaceData": type(group({
-                "contextString": member(string()),
-                "pattern": member(string()),
-                "replacement": member(string()),
-            })),
-            "EscapeParameters": type(group({
-                "contextString": member(string()),
-                "escape": member(string()),
-                "patterns to escape": member(array(string())),
-            })),
-            "PadData": type(group({
-                "contextString": member(string()),
-                "targetLength": member(number()),
-                "padString": member(string()),
-            })),
-            "IndexOfData": type(group({
-                "contextString": member(string()),
-                "searchString": member(string()),
-            })),
+    'data glossary': {
+        'glossary parameters': d({}),
+        'imports': d({
         }),
+        'root': {
+            'namespaces': d({}),
+            'data types': d({
+                "String": type(string()),
+                "Length": type(number()),
+                "Boolean": type(boolean()),
+                "Character Code": type(number()),
+                "Possible Character Code": type(optional(number())),
+                "Possible Position": type(optional(number())),
+
+                "CharacterCode At Data": type(group({
+                    "contextString": member(string()),
+                    "index": member(number()),
+                })),
+                "CharacterArray": type(array(number())),
+                "SplitData": type(group({
+                    "contextString": member(string()),
+                    "splitter": member(string()),
+                })),
+                "IncludesData": type(group({
+                    "contextString": member(string()),
+                    "searchString": member(string()),
+                })),
+                "SplitIn2Result": type(group({
+                    "head": member(string()),
+                    "tail": member(optional(string())),
+                })),
+                "SplitResult": type(array(string())),
+                "StartsWithData": type(group({
+                    "contextString": member(string()),
+                    "searchString": member(string()),
+                })),
+                "EndsWithData": type(group({
+                    "contextString": member(string()),
+                    "searchString": member(string()),
+                })),
+                "SubstringData": type(group({
+                    "contextString": member(string()),
+                    "begin": member(number()),
+                    /**
+                     * I'm deliberately choosing length over end here, because length will become a 'natural' in the future
+                     * and then this function is guaranteed to not have a negative length.
+                     * going with 'end' would require a check for negative values.
+                     */
+                    "length": member(number()),
+                })),
+                "ReplaceData": type(group({
+                    "contextString": member(string()),
+                    "pattern": member(string()),
+                    "replacement": member(string()),
+                })),
+                "EscapeParameters": type(group({
+                    "contextString": member(string()),
+                    "escape": member(string()),
+                    "patterns to escape": member(array(string())),
+                })),
+                "PadData": type(group({
+                    "contextString": member(string()),
+                    "targetLength": member(number()),
+                    "padString": member(string()),
+                })),
+                "IndexOfData": type(group({
+                    "contextString": member(string()),
+                    "searchString": member(string()),
+                })),
+            }),
+        },
     },
     'interface types': d({}),
     'algorithm types': d({
@@ -112,8 +115,8 @@ export const $: g_glossary.D.Glossary = {
 
         //composite
         "SplitIn2": sfunction(typeReference("SplitIn2Result"), data(typeReference("SplitData"))),
-        
-        
+
+
         //"UnsafeCharCodeAt": sfunction(typeReference("Character Code"), data(typeReference("CharacterCode At Data"))),
         //"TrimEnd": sfunction(typeReference("String"), data(typeReference("String"))),
 

package/auto.pareto/modules/main/glossary.data.ts

@@ -15,18 +15,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({
-            "Message": type(string()),
-            "Exit code": type(number()),
-            "Command Line Arguments": type(group({
-                "arguments": member(array(string()))
-            })),
+    'data glossary': {
+        'glossary parameters': d({}),
+        'imports': d({
         }),
+        'root': {
+            'namespaces': d({}),
+            'data types': d({
+                "Message": type(string()),
+                "Exit code": type(number()),
+                "Command Line Arguments": type(group({
+                    "arguments": member(array(string()))
+                })),
+            }),
+        },
     },
     'interface types': d({
         "Main": aInterface(aInterfaceMethod(typeReference("Command Line Arguments"))),
@@ -38,6 +40,6 @@ export const $: g_glossary.D.Glossary = {
             "stdout": aInterfaceReference("Message Stream", {}),
             "stderr": aInterfaceReference("Message Stream", {}),
             "exit": aInterfaceReference("Exit")
-        }, {  }),
+        }, {}),
     }),
 }

package/auto.pareto/modules/pareto_2_fountain_pen/glossary.data.ts

@@ -33,20 +33,22 @@ import { $ as d_l } from "../../auto.dependencies/pareto-pure/glossaries/lines.d
 const d = pd.d
 
 export const $: g_glossary.D.Glossary = {
-    'imports': d({
-        "fp": imp(d_fpif, {}),
-        "l": imp(d_l, {}),
-        "pareto": imp(d_pareto, {}),
-    }),
-
-    'glossary parameters': d({}),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
-            "Data": type(group({
-                "compilation unit": member(ref(externalTypeReference("pareto", "Compilation Unit", {}))),
-            })),
+    'data glossary': {
+        'imports': d({
+            "fp": imp(d_fpif, {}),
+            "l": imp(d_l, {}),
+            "pareto": imp(d_pareto, {}),
         }),
+
+        'glossary parameters': d({}),
+        'root': {
+            'namespaces': d({}),
+            'data types': d({
+                "Data": type(group({
+                    "compilation unit": member(ref(externalTypeReference("pareto", "Compilation Unit", {}))),
+                })),
+            }),
+        },
     },
     'interface types': d({}),
     'algorithm types': d({

package/auto.pareto/modules/string_aware_fountain_pen_2 fountain_pen/glossary.data.ts

@@ -9,15 +9,17 @@ 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({
-        "in": sh.imp(d_in, {}),
-        "out": sh.imp(d_out, {}),
-    }),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
+    'data glossary': {
+        'glossary parameters': d({}),
+        'imports': d({
+            "in": sh.imp(d_in, {}),
+            "out": sh.imp(d_out, {}),
         }),
+        'root': {
+            'namespaces': d({}),
+            'data types': d({
+            }),
+        },
     },
     'interface types': d({}),
     'algorithm types': d({

package/auto.pareto/modules/typescript_intermediate_2_fountain_pen/glossary.data.ts

@@ -22,16 +22,18 @@ import { $ as d_fpif } from "../../auto.dependencies/pareto-pure/glossaries/foun
 import { $ as d_ts } from "../../auto.dependencies/pareto-pure/glossaries/typescript_intermediate.data"
 
 export const $: g_glossary.D.Glossary = {
-    'glossary parameters': d({}),
-    'imports': d({
-        "out": imp(d_fpif, {}),
-        "in": imp(d_ts, {}),
-    }),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
-            "String": type(string()),
+    'data glossary': {
+        'glossary parameters': d({}),
+        'imports': d({
+            "out": imp(d_fpif, {}),
+            "in": imp(d_ts, {}),
         }),
+        'root': {
+            'namespaces': d({}),
+            'data types': d({
+                "String": type(string()),
+            }),
+        },
     },
     'interface types': d({}),
     'algorithm types': d({

package/auto.pareto/modules/typescript_naming/glossary.data.ts

@@ -17,15 +17,17 @@ 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({
-            "Raw Identifier": type(string()),
-            "Sanitized Identifier": type(string()),
+    'data glossary': {
+        'glossary parameters': d({}),
+        'imports': d({
         }),
+        'root': {
+            'namespaces': d({}),
+            'data types': d({
+                "Raw Identifier": type(string()),
+                "Sanitized Identifier": type(string()),
+            }),
+        },
     },
     'interface types': d({}),
     'algorithm types': d({

package/package.json

@@ -7,9 +7,9 @@
         "pareto-core-bin": "^0.1.4",
         "pareto-core-data": "^0.7.3",
         "pareto-core-dev": "^0.9.1",
-        "pareto-pure": "^0.22.0",
-        "pareto-standard-library": "^0.9.0",
-        "pareto-subatomic-library": "^0.7.0"
+        "pareto-pure": "^0.23.0",
+        "pareto-standard-library": "^0.10.0",
+        "pareto-subatomic-library": "^0.8.0"
     },
     "bin": {
         "boekhouding": "auto.dist/auto.bin/auto.boekhouding.js"
@@ -25,6 +25,6 @@
     "main": "auto.dist/index.js",
     "types": "auto.dist/index.d.ts",
     "name": "pareto",
-    "version": "0.61.0",
-    "content-fingerprint": "3b2830301bd51dbec9b8e0839d968f7c9e2f3aa0"
+    "version": "0.63.0",
+    "content-fingerprint": "6feee6fb125ce84737607c60165b0a4506e1284e"
 }