pareto 0.75.2 → 0.76.1

package/auto.pareto/auto.dependencies/pareto-pure/glossaries/auto.pareto_4gl_typescript.temp_in_between.data.ts

@@ -1,132 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import * as g_cosmos from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
-
-const d = pd.d
-const a = pd.a
-
-export const $: g_cosmos.D.Data__Glossary = {
-    'glossary parameters': d({
-    }),
-    'imports': d({
-    }),
-    'root': {
-        'data types': d({
-            "Typescript Package": {
-                'parameters': d({
-                }),
-                'type': ['group', d<g_cosmos.D.Data__Type>({
-                    "executables": ['dictionary', ['group', d<g_cosmos.D.Data__Type>({
-                        "initializer": ['text', null],
-                        "module": ['text', null],
-                    })]],
-                    "type": ['state group', d({
-                        "impure": ['group', d<g_cosmos.D.Data__Type>({
-                            "dependencies": ['dictionary', ['nothing', null]],
-                            "devDependencies": ['dictionary', ['nothing', null]],
-                        })],
-                        "pure": ['nothing', null],
-                    })],
-                })],
-            },
-        }),
-        'namespaces': d({
-            "Typescript Package": {
-                'data types': d({
-                }),
-                'namespaces': d({
-                    "G": {
-                        'data types': d({
-                        }),
-                        'namespaces': d({
-                            "executables": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                    "DX": {
-                                        'data types': d({
-                                        }),
-                                        'namespaces': d({
-                                            "G": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                    "initializer": {
-                                                        'data types': d({
-                                                        }),
-                                                        'namespaces': d({
-                                                        }),
-                                                    },
-                                                    "module": {
-                                                        'data types': d({
-                                                        }),
-                                                        'namespaces': d({
-                                                        }),
-                                                    },
-                                                }),
-                                            },
-                                        }),
-                                    },
-                                }),
-                            },
-                            "type": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                    "TU": {
-                                        'data types': d({
-                                        }),
-                                        'namespaces': d({
-                                            "impure": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                    "G": {
-                                                        'data types': d({
-                                                        }),
-                                                        'namespaces': d({
-                                                            "dependencies": {
-                                                                'data types': d({
-                                                                }),
-                                                                'namespaces': d({
-                                                                    "DX": {
-                                                                        'data types': d({
-                                                                        }),
-                                                                        'namespaces': d({
-                                                                        }),
-                                                                    },
-                                                                }),
-                                                            },
-                                                            "devDependencies": {
-                                                                'data types': d({
-                                                                }),
-                                                                'namespaces': d({
-                                                                    "DX": {
-                                                                        'data types': d({
-                                                                        }),
-                                                                        'namespaces': d({
-                                                                        }),
-                                                                    },
-                                                                }),
-                                                            },
-                                                        }),
-                                                    },
-                                                }),
-                                            },
-                                            "pure": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                }),
-                                            },
-                                        }),
-                                    },
-                                }),
-                            },
-                        }),
-                    },
-                }),
-            },
-        }),
-    },
-}

package/auto.pareto/auto.dependencies/pareto-pure/glossaries/auto.railroad_diagram.temp_in_between.data.ts

@@ -1,241 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import * as g_cosmos from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
-
-const d = pd.d
-const a = pd.a
-
-export const $: g_cosmos.D.Data__Glossary = {
-    'glossary parameters': d({
-    }),
-    'imports': d({
-    }),
-    'root': {
-        'data types': d({
-            "Diagram": {
-                'parameters': d({
-                }),
-                'type': ['group', d<g_cosmos.D.Data__Type>({
-                    "main rule": ['text', null],
-                    "rules": ['dictionary', ['component', ['type', {
-                        'context': ['local', null],
-                        'tailXX': a([
-                        ]),
-                        'type arguments': d({
-                        }),
-                        'typeXX': "Snippet",
-                    }]]],
-                })],
-            },
-            "Snippet": {
-                'parameters': d({
-                }),
-                'type': ['group', d<g_cosmos.D.Data__Type>({
-                    "occurence": ['state group', d({
-                        "once": ['nothing', null],
-                        "zero or more": ['nothing', null],
-                    })],
-                    "type": ['state group', d({
-                        "choice": ['group', d<g_cosmos.D.Data__Type>({
-                            "alternatives": ['dictionary', ['component', ['type', {
-                                'context': ['local', null],
-                                'tailXX': a([
-                                ]),
-                                'type arguments': d({
-                                }),
-                                'typeXX': "Snippet",
-                            }]]],
-                            "main alternative": ['text', null],
-                        })],
-                        "non-terminal": ['group', d<g_cosmos.D.Data__Type>({
-                            "class": ['text', null],
-                            "rule": ['text', null],
-                        })],
-                        "sequence": ['list', ['component', ['type', {
-                            'context': ['local', null],
-                            'tailXX': a([
-                            ]),
-                            'type arguments': d({
-                            }),
-                            'typeXX': "Snippet",
-                        }]]],
-                        "terminal": ['group', d<g_cosmos.D.Data__Type>({
-                            "class": ['text', null],
-                            "value": ['text', null],
-                        })],
-                    })],
-                })],
-            },
-        }),
-        'namespaces': d({
-            "Diagram": {
-                'data types': d({
-                }),
-                'namespaces': d({
-                    "G": {
-                        'data types': d({
-                        }),
-                        'namespaces': d({
-                            "main rule": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                }),
-                            },
-                            "rules": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                    "DX": {
-                                        'data types': d({
-                                        }),
-                                        'namespaces': d({
-                                        }),
-                                    },
-                                }),
-                            },
-                        }),
-                    },
-                }),
-            },
-            "Snippet": {
-                'data types': d({
-                }),
-                'namespaces': d({
-                    "G": {
-                        'data types': d({
-                        }),
-                        'namespaces': d({
-                            "occurence": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                    "TU": {
-                                        'data types': d({
-                                        }),
-                                        'namespaces': d({
-                                            "once": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                }),
-                                            },
-                                            "zero or more": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                }),
-                                            },
-                                        }),
-                                    },
-                                }),
-                            },
-                            "type": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                    "TU": {
-                                        'data types': d({
-                                        }),
-                                        'namespaces': d({
-                                            "choice": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                    "G": {
-                                                        'data types': d({
-                                                        }),
-                                                        'namespaces': d({
-                                                            "alternatives": {
-                                                                'data types': d({
-                                                                }),
-                                                                'namespaces': d({
-                                                                    "DX": {
-                                                                        'data types': d({
-                                                                        }),
-                                                                        'namespaces': d({
-                                                                        }),
-                                                                    },
-                                                                }),
-                                                            },
-                                                            "main alternative": {
-                                                                'data types': d({
-                                                                }),
-                                                                'namespaces': d({
-                                                                }),
-                                                            },
-                                                        }),
-                                                    },
-                                                }),
-                                            },
-                                            "non-terminal": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                    "G": {
-                                                        'data types': d({
-                                                        }),
-                                                        'namespaces': d({
-                                                            "class": {
-                                                                'data types': d({
-                                                                }),
-                                                                'namespaces': d({
-                                                                }),
-                                                            },
-                                                            "rule": {
-                                                                'data types': d({
-                                                                }),
-                                                                'namespaces': d({
-                                                                }),
-                                                            },
-                                                        }),
-                                                    },
-                                                }),
-                                            },
-                                            "sequence": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                    "A": {
-                                                        'data types': d({
-                                                        }),
-                                                        'namespaces': d({
-                                                        }),
-                                                    },
-                                                }),
-                                            },
-                                            "terminal": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                    "G": {
-                                                        'data types': d({
-                                                        }),
-                                                        'namespaces': d({
-                                                            "class": {
-                                                                'data types': d({
-                                                                }),
-                                                                'namespaces': d({
-                                                                }),
-                                                            },
-                                                            "value": {
-                                                                'data types': d({
-                                                                }),
-                                                                'namespaces': d({
-                                                                }),
-                                                            },
-                                                        }),
-                                                    },
-                                                }),
-                                            },
-                                        }),
-                                    },
-                                }),
-                            },
-                        }),
-                    },
-                }),
-            },
-        }),
-    },
-}

package/auto.pareto/auto.dependencies/pareto-pure/glossaries/auto.semantic_versioning.temp_in_between.data.ts

@@ -1,123 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import * as g_cosmos from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
-
-const d = pd.d
-const a = pd.a
-
-export const $: g_cosmos.D.Data__Glossary = {
-    'glossary parameters': d({
-    }),
-    'imports': d({
-    }),
-    'root': {
-        'data types': d({
-            "Number or Text": {
-                'parameters': d({
-                }),
-                'type': ['state group', d({
-                    "alphanumeric": ['text', null],
-                    "numeric": ['integer', null],
-                })],
-            },
-            "Semantic Version": {
-                'parameters': d({
-                }),
-                'type': ['group', d<g_cosmos.D.Data__Type>({
-                    "build identifiers": ['list', ['text', null]],
-                    "major": ['integer', null],
-                    "minor": ['integer', null],
-                    "patch": ['integer', null],
-                    "pre-release identifiers": ['list', ['component', ['type', {
-                        'context': ['local', null],
-                        'tailXX': a([
-                        ]),
-                        'type arguments': d({
-                        }),
-                        'typeXX': "Number or Text",
-                    }]]],
-                })],
-            },
-        }),
-        'namespaces': d({
-            "Number or Text": {
-                'data types': d({
-                }),
-                'namespaces': d({
-                    "TU": {
-                        'data types': d({
-                        }),
-                        'namespaces': d({
-                            "alphanumeric": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                }),
-                            },
-                            "numeric": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                }),
-                            },
-                        }),
-                    },
-                }),
-            },
-            "Semantic Version": {
-                'data types': d({
-                }),
-                'namespaces': d({
-                    "G": {
-                        'data types': d({
-                        }),
-                        'namespaces': d({
-                            "build identifiers": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                    "A": {
-                                        'data types': d({
-                                        }),
-                                        'namespaces': d({
-                                        }),
-                                    },
-                                }),
-                            },
-                            "major": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                }),
-                            },
-                            "minor": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                }),
-                            },
-                            "patch": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                }),
-                            },
-                            "pre-release identifiers": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                    "A": {
-                                        'data types': d({
-                                        }),
-                                        'namespaces': d({
-                                        }),
-                                    },
-                                }),
-                            },
-                        }),
-                    },
-                }),
-            },
-        }),
-    },
-}

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

@@ -1,51 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import {
-    boolean,
-    component,
-    data,
-    dictionary,
-    externalTypeReference,
-    group,
-    imp,
-    integer,
-    list,
-    prop,
-    nothing,
-    optional,
-    parametrizedType,
-    sfunction,
-    stateGroup,
-    text,
-    type,
-    typeParameter,
-    typeReference,
-} from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
-
-import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
-
-import { $ as d_fountain_pen } from "./fountain_pen_indented_file.data"
-
-const d = pd.d
-
-export const $: g_glossary.D.Data__Glossary = {
-    'glossary parameters': d({
-    }),
-    'imports': d({
-        "fp": imp(d_fountain_pen, {}),
-    }),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
-            "Directory": type(group({
-                "nodes": prop(dictionary(stateGroup({
-                    "allowed manual": nothing(),
-                    "allowed automatic": nothing(),
-                    "file": component(externalTypeReference("fp", "Block")),
-                    "template": component(externalTypeReference("fp", "Block")),
-                    "directory": component(typeReference("Directory")),
-                })))
-            }))
-        }),
-    },
-}

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

@@ -1,58 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import {
-    boolean,
-    component,
-    data,
-    dictionary,
-    externalTypeReference,
-    group,
-    imp,
-    integer,
-    list,
-    prop,
-    nothing,
-    optional,
-    parametrizedType,
-    sfunction,
-    stateGroup,
-    text,
-    type,
-    typeParameter,
-    typeReference,
-} from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
-import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
-const d = pd.d
-
-export const $: g_glossary.D.Data__Glossary = {
-    'glossary parameters': d({}),
-    'imports': d({
-    }),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
-            "Block": type(list(stateGroup({
-                "nested line": component(typeReference("Line")),
-                "line": text(),
-                /**
-                 * this one can be used to make code generation easier.
-                 * it will be inlined
-                 */
-                "sub block": component(typeReference("Block")),
-            }))),
-            "Line": type(list(stateGroup({
-                "snippet": text(),
-                "indent": component(typeReference("Block")),
-                /**
-                 * this one can be used to make code generation easier.
-                 * it will be inlined
-                 */
-                "sub line": component(typeReference("Line")),
-            }))),
-            "Lines": type(list(group({
-                "indentation": prop(integer()),
-                "text": prop(text()),
-            }))),
-        }),
-    },
-}

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

@@ -1,52 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import {
-    boolean,
-    component,
-    data,
-    dictionary,
-    externalTypeReference,
-    group,
-    imp,
-    integer,
-    list,
-    prop,
-    nothing,
-    optional,
-    parametrizedType,
-    sfunction,
-    stateGroup,
-    text,
-    type,
-    typeParameter,
-    typeReference,
-} from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
-
-import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
-const d = pd.d
-
-export const $: g_glossary.D.Data__Glossary = {
-    'glossary parameters': d({}),
-    'imports': d({
-    }),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
-            "Block": type(list(stateGroup({
-                "nested line": component(typeReference("Line")),
-                "line": text(),
-            }))),
-            "Line": type(list(stateGroup({
-                "snippet": text(),
-                "apostrophed string": text(),
-                "quoted string": text(),
-                "backticked string": text(),
-                "indent": component(typeReference("Block"))
-            }))),
-            "Lines": type(list(group({
-                "indentation": prop(integer()),
-                "text": prop(text()),
-            }))),
-        }),
-    },
-}