pareto 0.58.0 → 0.60.0

package/auto.pareto/auto.dependencies/pareto-pure/{modules/fountain_pen/glossary.data.ts → glossaries/fountain_pen.data.ts}

@@ -20,36 +20,29 @@ export const $: g_glossary.D.Glossary = {
             "Block": type(array(taggedUnion({
                 "nested line": ref(typeReference("Line")),
                 "line": string(),
+                /**
+                 * this one can be used to make code generation easier.
+                 * it will be inlined
+                 */
+                "sub block": ref(typeReference("Block")),
             }))),
             "Line": type(array(taggedUnion({
                 "snippet": string(),
-                "indent": ref(typeReference("Block"))
+                "indent": ref(typeReference("Block")),
+                /**
+                 * this one can be used to make code generation easier.
+                 * it will be inlined
+                 */
+                "sub line": ref(typeReference("Line")),
             }))),
             "Lines": type(array(group({
                 "indentation": member(number()),
                 "text": member(string()),
             }))),
-            "Indented Lines": type(array(string())),
-            "SerializeData": type(group({
-                "block": member(ref(typeReference("Block"))),
-                "indentation": member(string()),
-            })),
-            "IndentData": type(group({
-                "lines": member(ref(typeReference("Lines"))),
-                "indentation": member(string()),
-            })),
-            "String": type(string()),
         }),
     },
     'interface types': d({
-        "Lines": aInterface(aInterfaceMethod(typeReference("Lines"))),
-        "Indented Lines": aInterface(streamconsumer(aInterfaceMethod(typeReference("String")), null)),
     }),
     'algorithm types': d({
-        "Indent": sfunction(typeReference("Indented Lines"), data(typeReference("IndentData"))),
-        "Serialize": sfunction(typeReference("Lines"), data(typeReference("Block"))),
-        "Stream": infInit(aInterfaceReference("Lines"), {
-            "handler": aInterfaceReference("Indented Lines")
-        }),
     }),
 }

package/auto.pareto/auto.dependencies/pareto-pure/glossaries/lines.data.ts

@@ -0,0 +1,27 @@
+import * as pd from 'pareto-core-data'
+
+import {
+    aInterface,
+    aInterfaceMethod,
+    aInterfaceReference,
+    array, data, dictionary, externalTypeReference, glossaryParameter, group, infInit, member, null_, number, parametrizedType, ref, sfunction, streamconsumer, string, taggedUnion, type, typeParameter, typeReference
+} from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+
+import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
+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())),
+        }),
+    },
+    'interface types': d({
+    }),
+    'algorithm types': d({
+    }),
+}

package/auto.pareto/auto.dependencies/pareto-pure/glossaries/string_aware_fountain_pen.data.ts

@@ -0,0 +1,40 @@
+import * as pd from 'pareto-core-data'
+
+import {
+    aInterface,
+    aInterfaceMethod,
+    aInterfaceReference,
+    array, data, dictionary, externalTypeReference, glossaryParameter, group, imp, infInit, member, null_, number, parametrizedType, ref, sfunction, streamconsumer, string, taggedUnion, type, typeParameter, typeReference
+} from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+
+import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
+const d = pd.d
+
+export const $: g_glossary.D.Glossary = {
+    'glossary parameters': d({}),
+    'imports': d({
+    }),
+    'root': {
+        'namespaces': d({}),
+        'data types': d({
+            "Block": type(array(taggedUnion({
+                "nested line": ref(typeReference("Line")),
+                "line": string(),
+            }))),
+            "Line": type(array(taggedUnion({
+                "snippet": string(),
+                "apostrophed string": string(),
+                "quoted string": string(),
+                "backticked string": string(),
+                "indent": ref(typeReference("Block"))
+            }))),
+            "Lines": type(array(group({
+                "indentation": member(number()),
+                "text": member(string()),
+            }))),
+        }),
+    },
+    'interface types': d({}),
+    'algorithm types': d({
+    }),
+}

package/auto.pareto/auto.dependencies/pareto-pure/glossaries/testresult.data.ts

@@ -0,0 +1,137 @@
+import * as pd from 'pareto-core-data'
+
+import {
+    array, boolean, data, dictionary, externalTypeReference, glossaryParameter, group, member, null_, number, optional, parametrizedType, procedure, ref, sfunction, sInterface, sInterfaceMethod, sInterfaceReference, string, taggedUnion, type, typeParameter, typeReference
+} from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+
+import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
+
+const d = pd.d
+
+export const $: g_glossary.D.Glossary = {
+    'glossary parameters': d({}),
+    'imports': d({
+    }),
+    'root': {
+        'namespaces': d({
+            // "intermediate": {
+            //     'namespaces': d({
+
+            //     }),
+            //     'data types': d({}),
+            // },
+            // "summary": {
+            //     'namespaces': d({
+
+            //     }),
+            //     'data types': d({}),
+            // },
+        }),
+        'data types': d({
+            "Library": type(group({
+                "public": member(ref(typeReference("Module Set"))),
+                "private": member(ref(typeReference("Module Set"))),
+            })),
+            "Module Set": type(dictionary(ref(typeReference("Module")))),
+            "Module": type(dictionary(ref(typeReference("Algorithm")))),
+            "Algorithm": type(group({
+                "location": member(ref(typeReference("Source Location"))),
+                "tests": member(optional(dictionary(ref(typeReference("Test"))))),
+            })),
+            "Source Location": type(group({
+                "file": member(string()),
+                "line": member(number()),
+                "column": member(number()),
+            })),
+            "Test": type(array(ref(typeReference("Error")))),
+            "Error": type(taggedUnion({
+                "content": ref(typeReference("Compare Error"))
+            })),
+            "Compare Error": type(group({
+                "location": member(ref(typeReference("Source Location"))),
+                "path": member(string()),
+                "type": member(taggedUnion({
+                    "wrong number": group({
+                        "found": member(number()),
+                    }),
+                    "wrong text": group({
+                        "found": member(string()),
+                    }),
+                    "wrong boolean": group({
+                        "found": member(boolean())
+                    }),
+                    "optional value expected not to be set": null_(),
+                    "optional value expected to be set": null_(),
+                    "not the right state": group({
+                        "found": member(string())
+                    }),
+                    "not enough elements": null_(),
+                    "too many elements": null_(),
+                    "superfluous entries": group({
+                        "keys": member(dictionary(null_()))
+                    }),
+                    "missing dictionary entry": group({
+                        "key": member(string()),
+                    }),
+                })),
+
+            })),
+            "Summary": type(group({
+                "number of tests": member(number()),
+                "number of missing tests": member(number()),
+                "number of errors": member(number()),
+            })),
+
+            "intLibrary": type(group({
+                "public": member(ref(typeReference("intModule Set"))),
+                "private": member(ref(typeReference("intModule Set"))),
+            })),
+            "intModule Set": type(dictionary(ref(typeReference("intModule")))),
+            "intModule": type(dictionary(ref(typeReference("intAlgorithm")))),
+            "intAlgorithm": type(group({
+                "location": member(ref(typeReference("Source Location"))),
+                "status": member(taggedUnion({
+                    "no tests": null_(),
+                    "skipped": null_(),
+                    "has tests": dictionary(ref(typeReference("intTest"))),
+                })),
+            })),
+            "intTest": type(taggedUnion({
+                "has errors": array(ref(typeReference("Error"))),
+                "has no errors": null_(),
+            })),
+            "annotatedStatus": type(taggedUnion({
+                "has errors": null_(),  // red
+                "missing tests": null_(), // yellow
+                "no tests": null_(), // grey
+                "success": null_(), // green
+            })),
+            "annotatedLibrary": type(group({
+                "public": member(ref(typeReference("annotatedModule Set"))),
+                "private": member(ref(typeReference("annotatedModule Set"))),
+            })),
+            "annotatedModule Set": type(group({
+                "status": member(ref(typeReference("annotatedStatus"))),
+                "modules": member(dictionary(ref(typeReference("annotatedModule")))),
+            })),
+            "annotatedModule": type(group({
+                "status": member(ref(typeReference("annotatedStatus"))),
+                "algorithms": member(dictionary(ref(typeReference("annotatedAlgorithm")))),
+            })),
+            "annotatedAlgorithm": type(group({
+                "location": member(ref(typeReference("Source Location"))),
+                "status": member(ref(typeReference("annotatedStatus"))),
+                "tests": member(dictionary(ref(typeReference("annotatedTest")))),
+            })),
+            "annotatedTest": type(group({
+                "status": member(ref(typeReference("annotatedStatus"))),
+                "errors": member(array(ref(typeReference("Error")))),
+            })),
+        }),
+    },
+    'interface types': d({
+
+    }),
+    'algorithm types': d({
+    }),
+}

package/auto.pareto/auto.dependencies/pareto-pure/glossaries/typescript_intermediate.data.ts

@@ -0,0 +1,68 @@
+import * as pd from 'pareto-core-data'
+
+import {
+    aInterface,
+    aInterfaceMethod,
+    aInterfaceReference,
+    array, boolean, data, dictionary, externalTypeReference, glossaryParameter, group, imp, infInit, member, null_, number, parametrizedType, ref, sfunction, streamconsumer, string, taggedUnion, type, typeParameter, typeReference
+} from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+
+import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
+const d = pd.d
+
+export const $: g_glossary.D.Glossary = {
+    'glossary parameters': d({}),
+    'imports': d({
+    }),
+    'root': {
+        'namespaces': d({}),
+        'data types': d({
+            "Block": type(array(taggedUnion({
+                "nested line": ref(typeReference("Line")),
+                "line": string(),
+
+                //specials
+
+                /**
+                 * this one can be used to transform a dictionary into an array of blocks. The order is not controllable.
+                 */
+                "block dictionary": dictionary(ref(typeReference("Block"))),
+            }))),
+            "Line": type(array(taggedUnion({
+                "snippet": string(),
+                "indent": ref(typeReference("Block")),
+
+                //specials
+                "apostrophed string": string(),
+                "quoted string": string(),
+                "backticked string": string(),
+                "identifier": string(),
+                // /**
+                //  * this one is necessary because TypeScript does not allow trailing commas in certain places.
+                //  * for example in type arguments.
+                //  */
+                // "array without trailing commas": array(ref(typeReference("Line"))),
+                /**
+                 * this one can be used to transform a dictionary into an array of line parts. The order is not controllable.
+                 * typescript sometimes handles empty dictoinaries in impure ways and sometimes doesn't accept a trailing comma.
+                 */
+                "line dictionary": group({
+                    "dictionary": member(dictionary(ref(typeReference("Line")))),
+                    "if empty": member(ref(typeReference("Line"))),
+                    "if not empty": member(group({
+                        "prefix": member(ref(typeReference("Line"))),
+                        "suffix": member(ref(typeReference("Line"))),
+                        "add commas in between": member(boolean()),
+                    })),
+                }),
+            }))),
+            "Lines": type(array(group({
+                "indentation": member(number()),
+                "text": member(string()),
+            }))),
+        }),
+    },
+    'interface types': d({}),
+    'algorithm types': d({
+    }),
+}

package/auto.pareto/auto.dependencies/pareto-pure/modules/alan_light_2_string_aware_fountain_pen/api.data.ts

@@ -0,0 +1,20 @@
+import * as pd from 'pareto-core-data'
+
+import { algorithm, api } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+
+import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
+
+import { $ as glos } from "./glossary.data"
+import { glossary, group, member, number, type } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+
+export const $: g_project.D.API = api(
+    glos,
+    {
+        /**
+         * use this function to serialize to an intermediate format.
+         * Serialization to this format can be done in a pure way.
+         * serialization from this format to an array of strings is not pure, specifically for 1 reason so far: apostrophed strings.
+         */
+        "map": algorithm("Map", null, {}),
+    }
+)

package/auto.pareto/{modules/alan_light_serialize → auto.dependencies/pareto-pure/modules/alan_light_2_string_aware_fountain_pen}/glossary.data.ts

@@ -15,8 +15,8 @@ import {
     externalTypeReference,
 } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
 
-import { $ as d_alan } from "../../auto.dependencies/pareto-pure/glossaries/auto.alan.data"
-import { $ as d_fp } from "../../auto.dependencies/pareto-pure/modules/fountain_pen/glossary.data"
+import { $ as d_in } from "../../glossaries/auto.alan_light.data"
+import { $ as d_out } from "../../glossaries/string_aware_fountain_pen.data"
 
 import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
 const d = pd.d
@@ -24,18 +24,17 @@ const d = pd.d
 export const $: g_glossary.D.Glossary = {
     'glossary parameters': d({}),
     'imports': d({
-        "alan": imp(d_alan, {}),
-        "fp": imp(d_fp, {}),
+        "in": imp(d_in, {}),
+        "out": imp(d_out, {}),
     }),
     'root': {
         'namespaces': d({}),
         'data types': d({
-            "String": type(string()),
         }),
     },
     'interface types': d({}),
     'algorithm types': d({
-        "Serialize": sfunction(externalTypeReference("fp", "Indented Lines"), data(externalTypeReference("alan", "Root"))),
+        "Map": sfunction(externalTypeReference("out", "Block"), data(externalTypeReference("in", "Root"))),
     }),
 
 }

package/auto.pareto/auto.dependencies/pareto-pure/{auto.dependencies/pareto-standard-library/modules/json → modules/astn_2_fountain_pen}/api.data.ts

@@ -10,6 +10,6 @@ import { glossary, group, member, number, sInterface, sInterfaceMethod, string,
 export const $: g_project.D.API = api(
     glos,
     {
-        "serialize": algorithm("Serialize", null, {}),
+        "map": algorithm("Map", null, {}),
     }
 )

package/auto.pareto/auto.dependencies/pareto-pure/modules/astn_2_fountain_pen/glossary.data.ts

@@ -0,0 +1,39 @@
+import * as pd from 'pareto-core-data'
+
+import {
+    array, afunction, boolean, computed, data, dictionary,
+    glossaryParameter, group, member, number, optional, ref, sfunction, string, type, typeReference,
+    taggedUnion,
+    null_,
+    sInterface,
+    sInterfaceMethod,
+    imp,
+    externalTypeReference
+} from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+
+import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
+
+import { $ as d_in } from "../../glossaries/astn.data"
+import { $ as d_out } from "../../glossaries/fountain_pen.data"
+
+const d = pd.d
+
+export const $: g_glossary.D.Glossary = {
+    'glossary parameters': d({
+    }),
+    'imports': d({
+        "in": imp(d_in, {}),
+        "out": imp(d_out, {}),
+    }),
+    'root': {
+        'namespaces': d({}),
+        'data types': d({
+        }),
+    },
+    'interface types': d({
+
+    }),
+    'algorithm types': d({
+        "Map": sfunction(externalTypeReference("out", "Block"), data(externalTypeReference("in", "Value"))),
+    }),
+}

package/auto.pareto/auto.dependencies/pareto-pure/modules/{tendril2pareto → cosmos_type_system_2_graphviz}/api.data.ts

@@ -11,6 +11,7 @@ import { $ as glos } from "./glossary.data"
 export const $: g_project.D.API = api(
     glos,
     {
-        "createResolver": algorithm("CreateResolver", null, {})
+        "map": algorithm("Map", null, {}),
+
     }
-)
+)

package/auto.pareto/auto.dependencies/pareto-pure/modules/cosmos_type_system_2_graphviz/glossary.data.ts

@@ -0,0 +1,30 @@
+import * as pd from 'pareto-core-data'
+
+import {
+    array, data, dictionary, externalTypeReference, glossaryParameter, group, imp, member, null_, parametrizedType, ref, sfunction, string, taggedUnion, type, typeParameter, typeReference
+} from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+
+import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
+
+import { $ as d_out } from "../../glossaries/auto.graphviz.data"
+import { $ as d_in } from "../../glossaries/auto.cosmos_type_system.data"
+
+const d = pd.d
+
+export const $: g_glossary.D.Glossary = {
+    'glossary parameters': d({}),
+    'imports': d({
+        "in": imp(d_in, {}),
+        "out": imp(d_out, {}),
+    }),
+    'root': {
+        'namespaces': d({}),
+        'data types': d({
+        }),
+    },
+    'interface types': d({}),
+    'algorithm types': d({
+        "Map": sfunction(externalTypeReference("out", "Graph"), data(externalTypeReference("in", "Glossary"))),
+
+    }),
+}

package/auto.pareto/auto.dependencies/pareto-pure/modules/{cosmos2pareto → cosmos_type_system_2_pareto}/glossary.data.ts

@@ -6,28 +6,28 @@ import {
 
 import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
 
-import { $ as d_pareto } from "../../glossaries/auto.pareto.data"
-import { $ as d_cosmos } from "../../glossaries/auto.cosmos_type_system.data"
+import { $ as d_out } from "../../glossaries/auto.pareto.data"
+import { $ as d_in } from "../../glossaries/auto.cosmos_type_system.data"
 
 const d = pd.d
 
 export const $: g_glossary.D.Glossary = {
     'glossary parameters': d({}),
     'imports': d({
-        "pareto": imp(d_pareto, {}),
-        "cosmos": imp(d_cosmos, {}),
+        "in": imp(d_in, {}),
+        "out": imp(d_out, {}),
     }),
     'root': {
         'namespaces': d({}),
         'data types': d({
             "Library2ParetoComparatorsData": type(group({
-                "library": member(ref(externalTypeReference("cosmos", "Library"))),
+                "library": member(ref(externalTypeReference("in", "Library"))),
             })),
         }),
     },
     'interface types': d({}),
     'algorithm types': d({
-        "Library2ParetoComparators": sfunction(externalTypeReference("pareto", "Compilation Unit"), data(typeReference("Library2ParetoComparatorsData"))),
+        "Library2ParetoComparators": sfunction(externalTypeReference("out", "Compilation Unit"), data(typeReference("Library2ParetoComparatorsData"))),
 
     }),
 }

package/auto.pareto/auto.dependencies/pareto-pure/modules/fountain_pen_2_fountain_pen/api.data.ts

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

package/auto.pareto/auto.dependencies/pareto-pure/modules/fountain_pen_2_fountain_pen/glossary.data.ts

@@ -0,0 +1,36 @@
+import * as pd from 'pareto-core-data'
+
+import {
+    aInterface,
+    aInterfaceMethod,
+    aInterfaceReference,
+    array, data, dictionary, externalTypeReference, glossaryParameter, group, imp, infInit, member, null_, number, parametrizedType, ref, sfunction, streamconsumer, string, taggedUnion, type, typeParameter, typeReference
+} from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+
+import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
+const d = pd.d
+
+import { $ as d_in } from "../../glossaries/fountain_pen.data"
+import { $ as d_out } from "../../glossaries/fountain_pen.data"
+
+export const $: g_glossary.D.Glossary = {
+    'glossary parameters': d({}),
+    'imports': d({
+
+        "in": imp(d_in, {}),
+        "out": imp(d_out, {}),
+    }),
+    'root': {
+        'namespaces': d({}),
+        'data types': d({
+            // "SerializeData": type(group({
+            //     "block": member(ref(externalTypeReference("in", "Block"))),
+            // })),
+            // "String": type(string()),
+        }),
+    },
+    'interface types': d({}),
+    'algorithm types': d({
+        "Map": sfunction(externalTypeReference("out", "Lines"), data(externalTypeReference("in", "Block"))),
+    }),
+}

package/auto.pareto/auto.dependencies/pareto-pure/modules/{fountain_pen → fountain_pen_2_lines}/api.data.ts

@@ -13,7 +13,6 @@ export const $: g_project.D.API = api(
     glos,
     {
         "indent": algorithm("Indent", null, {}),
-        "serialize": algorithm("Serialize", null, {}),
         "stream": algorithm("Stream", null, {}),
     }
 )

package/auto.pareto/auto.dependencies/pareto-pure/modules/fountain_pen_2_lines/glossary.data.ts

@@ -0,0 +1,42 @@
+import * as pd from 'pareto-core-data'
+
+import {
+    aInterface,
+    aInterfaceMethod,
+    aInterfaceReference,
+    array, data, dictionary, externalTypeReference, glossaryParameter, group, imp, infInit, member, null_, number, parametrizedType, ref, sfunction, streamconsumer, string, taggedUnion, type, typeParameter, typeReference
+} from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+
+import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
+const d = pd.d
+
+import { $ as d_in } from "../../glossaries/fountain_pen.data"
+import { $ as d_out } from "../../glossaries/lines.data"
+
+export const $: g_glossary.D.Glossary = {
+    'glossary parameters': d({}),
+    'imports': d({
+        "in": imp(d_in, {}),
+        "out": imp(d_out, {}),
+    }),
+    'root': {
+        'namespaces': d({}),
+        'data types': d({
+            "IndentData": type(group({
+                "lines": member(ref(externalTypeReference("in", "Lines"))),
+                "indentation": member(string()),
+            })),
+            "String": type(string()),
+        }),
+    },
+    'interface types': d({
+        "Lines": aInterface(aInterfaceMethod(externalTypeReference("in", "Lines"))),
+        "Indented Lines": aInterface(streamconsumer(aInterfaceMethod(typeReference("String")), null)),
+    }),
+    'algorithm types': d({
+        "Indent": sfunction(externalTypeReference("out", "Lines"), data(typeReference("IndentData"))),
+        "Stream": infInit(aInterfaceReference("Lines"), {
+            "handler": aInterfaceReference("Indented Lines")
+        }),
+    }),
+}

package/auto.pareto/auto.dependencies/pareto-pure/modules/graphviz_2_string_aware_fountain_pen/api.data.ts

@@ -0,0 +1,20 @@
+import * as pd from 'pareto-core-data'
+
+import { algorithm, api } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+
+import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
+
+import { $ as glos } from "./glossary.data"
+import { glossary, group, member, number, type } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+
+export const $: g_project.D.API = api(
+    glos,
+    {
+        /**
+         * use this function to serialize to an intermediate format.
+         * Serialization to this format can be done in a pure way.
+         * serialization from this format to an array of strings is not pure, specifically for 1 reason so far: apostrophed strings.
+         */
+        "map": algorithm("Map", null, {}),
+    }
+)