pareto 0.58.0 → 0.59.0

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

@@ -46,8 +46,10 @@ export const $: g_glossary.D.Glossary = {
     },
     'interface types': d({}),
     'algorithm types': d({
+        "Add": sfunction(typeReference("Number"), data(typeReference("NumberTuple"))),
+        "Multiply": sfunction(typeReference("Number"), data(typeReference("NumberTuple"))),
         "Increment": sfunction(typeReference("Number"), data(typeReference("Number"))),
-        "Array Multiply": sfunction(typeReference("Number"), data(typeReference("NumberRange"))),
+        // "Array Multiply": sfunction(typeReference("Number"), data(typeReference("NumberRange"))),
         "Negate": sfunction(typeReference("Number"), data(typeReference("Number"))),
         /**
         * if the denominator is 0, the return value is null
@@ -57,19 +59,20 @@ export const $: g_glossary.D.Glossary = {
         /**
          * calculates the max of an array of numbers. If there are no entries, the result value is 0
          */
-        "ArrayMax": sfunction(typeReference("OptionalNumber"), data(typeReference("NumberArray"))),
-        "ArrayMin": sfunction(typeReference("OptionalNumber"), data(typeReference("NumberArray"))),
-        "ArraySum": sfunction(typeReference("Number"), data(typeReference("NumberArray"))),
+        // "ArrayMax": sfunction(typeReference("OptionalNumber"), data(typeReference("NumberArray"))),
+        // "ArrayMin": sfunction(typeReference("OptionalNumber"), data(typeReference("NumberArray"))),
+        // "ArraySum": sfunction(typeReference("Number"), data(typeReference("NumberArray"))),
         /**
          * calculates the max of a dictionary of number. If there are no entries, the result value is 0
          */
-        "DictionaryMax": sfunction(typeReference("OptionalNumber"), data(typeReference("NumberDictionary"))),
-        "DictionaryMin": sfunction(typeReference("OptionalNumber"), data(typeReference("NumberDictionary"))),
+        // "DictionaryMax": sfunction(typeReference("OptionalNumber"), data(typeReference("NumberDictionary"))),
+        // "DictionaryMin": sfunction(typeReference("OptionalNumber"), data(typeReference("NumberDictionary"))),
         /**
         * calculates the max of a tuple of numbers
         */
         "DictionarySum": sfunction(typeReference("Number"), data(typeReference("NumberDictionary"))),
 
+        "Min": sfunction(typeReference("Number"), data(typeReference("NumberTuple"))),
         "Max": sfunction(typeReference("Number"), data(typeReference("NumberTuple"))),
         "Subtract": sfunction(typeReference("Number"), data(typeReference("SubtractData"))),
     }),

package/auto.pareto/auto.dependencies/pareto-pure/auto.dependencies/pareto-standard-library/modules/build/api.data.ts

@@ -18,7 +18,6 @@ export const $: g_project.D.API = api(
         "createSafeDictionaryBuilder": algorithm("CreateSafeDictionaryBuilder", "DictionaryBuildStrategy", {}),
         "createArrayBuilder": algorithm("CreateArrayBuilder", null, {}),
 
-
         "createStringBuilder": algorithm("CreateStringBuilder", "Startstring", {
         }),
     }

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

@@ -41,10 +41,6 @@ export const $: g_glossary.D.Glossary = {
                 "value": member(ref(typeParameter("Type"))),
             })),
 
-
-
-
-
             "DictionaryBuildStrategy": type(taggedUnion({
                 "ignore": group({}),
                 "overwrite": group({}),
@@ -80,10 +76,6 @@ export const $: g_glossary.D.Glossary = {
         ), { "EndType": null }),
         "Add": sInterface(sInterfaceMethod(typeReference("KeyValuePair", { "Type": typeParameter("Type") })), { "Type": null }),
         "Push": sInterface(sInterfaceMethod(typeParameter("Type")), { "Type": null }),
-
-
-
-
     }),
     'algorithm types': d({
         "CreateArrayBuilder": infInit(aInterfaceReference("Elements", {

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

@@ -64,7 +64,6 @@ export const $: g_glossary.D.Glossary = {
             })),
             "KeyValueDictionary": parametrizedType({ "Type": null }, dictionary(ref(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))),
 
-
             "RekeyDictionary": parametrizedType({ "Type": null }, dictionary(ref(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))),
 
         }),

package/auto.pareto/auto.dependencies/pareto-pure/auto.dependencies/pareto-standard-library/modules/tostring/api.data.ts

@@ -11,7 +11,9 @@ export const $: g_project.D.API = api(
     {
         "getArrayAsString": algorithm("GetArrayAsString", "Configuration", {}),
         "getLengthAsString": algorithm("GetLengthAsString", null, {}),
-        "getKeysAsString": algorithm("GetKeysAsString", "Configuration", {}),
+        
+        //this one implicitely sorts the keys
+        //"getKeysAsString": algorithm("GetKeysAsString", "Configuration", {}),
 
         "getNumberOfKeysAsString": algorithm("GetNumberOfKeysAsString", null, {}),
 

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

@@ -22,7 +22,6 @@ export const $: g_glossary.D.Glossary = {
             "StringArray": type(array(string())),
             "Dictionary": parametrizedType({ "T": null }, dictionary(ref(typeParameter("T")))),
 
-
             "Configuration": type(group({
                 "separator": member(string()),
                 "maximum": member(optional(group({
@@ -36,7 +35,7 @@ export const $: g_glossary.D.Glossary = {
     'algorithm types': d({
         "GetLengthAsString": sfunction(typeReference("String"), data(typeReference("Array", { "T": typeParameter("T") })), { "T": null}),
         "GetArrayAsString": sfunction(typeReference("String"), data(typeReference("StringArray"))),
-        "GetKeysAsString": sfunction(typeReference("String"), data(typeReference("Dictionary", { "T": typeParameter("T") })), { "T": null}),
+        //"GetKeysAsString": sfunction(typeReference("String"), data(typeReference("Dictionary", { "T": typeParameter("T") })), { "T": null}),
         "GetNumberOfKeysAsString": sfunction(typeReference("String"), data(typeReference("Dictionary", { "T": typeParameter("T") })), { "T": null}),
     }),
 }

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

@@ -0,0 +1,38 @@
+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(),
+                "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-standard-library/modules/json/glossary.data.ts → pareto-pure/glossaries/astn.data.ts}

@@ -20,28 +20,25 @@ export const $: g_glossary.D.Glossary = {
     '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"))),
+                "verbose type": dictionary(ref(typeReference("Value"))),
+                "shorthand type": array(ref(typeReference("Value"))),
+                "dictionary": dictionary(ref(typeReference("Value"))),
                 "array": array(ref(typeReference("Value"))),
-                "string": string(),
-                "number": number(),
-                "boolean": boolean(),
-                "null": null_(),
+                "quoted string": string(),
+                "apostrophed string": string(),
+                "backticked string": string(),
+                "raw string": string(),
+                "tagged union": group({
+                    "option": member(string()),
+                    "value": member(ref(typeReference("Value"))),
+                })
             })),
-
-
         }),
     },
     'interface types': d({
 
     }),
     'algorithm types': d({
-        "Serialize": sfunction(typeReference("String"), data(typeReference("Value"))),
     }),
 }

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/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_alan_light_intermediate/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/auto.dependencies/pareto-pure/modules/alan_light_2_alan_light_intermediate/glossary.data.ts

@@ -0,0 +1,40 @@
+import * as pd from 'pareto-core-data'
+
+import {
+    data,
+    sfunction,
+    type,
+    group,
+    typeReference,
+    member,
+    string,
+    dictionary,
+    null_,
+    array,
+    imp,
+    externalTypeReference,
+} from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+
+import { $ as d_alan_light } from "../../glossaries/auto.alan_light.data"
+import { $ as d_alan_light_intermediate } from "../../glossaries/alan_light_intermediate.data"
+
+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({
+        "alan light": imp(d_alan_light, {}),
+        "alan light intermediate": imp(d_alan_light_intermediate, {}),
+    }),
+    'root': {
+        'namespaces': d({}),
+        'data types': d({
+        }),
+    },
+    'interface types': d({}),
+    'algorithm types': d({
+        "Map": sfunction(externalTypeReference("alan light intermediate", "Block"), data(externalTypeReference("alan light", "Root"))),
+    }),
+
+}

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_astn } from "../../glossaries/astn.data"
+import { $ as d_fp } from "../../glossaries/fountain_pen.data"
+
+const d = pd.d
+
+export const $: g_glossary.D.Glossary = {
+    'glossary parameters': d({
+    }),
+    'imports': d({
+        "astn": imp(d_astn, {}),
+        "fountain pen": imp(d_fp, {}),
+    }),
+    'root': {
+        'namespaces': d({}),
+        'data types': d({
+        }),
+    },
+    'interface types': d({
+
+    }),
+    'algorithm types': d({
+        "Serialize": sfunction(externalTypeReference("fountain pen", "Block"), data(externalTypeReference("astn", "Value"))),
+    }),
+}

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

@@ -1,3 +1,5 @@
+
+
 import * as pd from 'pareto-core-data'
 
 import { algorithm, algref, api } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
@@ -5,7 +7,7 @@ import { algorithm, algref, api } from "pareto-pure/auto.dist/public/shorthands/
 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, sInterface, sInterfaceMethod, string, type, typeReference } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+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,

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

@@ -0,0 +1,34 @@
+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_fountain_pen } from "../../glossaries/fountain_pen.data"
+
+export const $: g_glossary.D.Glossary = {
+    'glossary parameters': d({}),
+    'imports': d({
+        "fp": imp(d_fountain_pen, {}),
+    }),
+    'root': {
+        'namespaces': d({}),
+        'data types': d({
+            "SerializeData": type(group({
+                "block": member(ref(externalTypeReference("fp", "Block"))),
+            })),
+            "String": type(string()),
+        }),
+    },
+    'interface types': d({    }),
+    'algorithm types': d({
+        "Serialize": sfunction(externalTypeReference("fp", "Lines"), data(externalTypeReference("fp", "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, {}),
     }
 )