pareto 0.61.0 → 0.62.0

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.22.3",
+        "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.62.0",
+    "content-fingerprint": "edf7b0f767fe6fed1325f5e50422323de15518da"
 }