npm - pareto - Versions diffs - 0.75.2 → 0.76.1 - Mend

pareto 0.75.2 → 0.76.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (216) hide show

package/auto.dist/public/modules/pareto_3gl_high_2_lines/auto.provided_interface_glossary.d.ts DELETED Viewed

@@ -1,1574 +0,0 @@
-import * as pt from 'pareto-core-types';
-export declare namespace G {
-    namespace _r_in {
-        namespace G { }
-        namespace N {
-            namespace Compilation_$__$_Unit {
-                namespace N {
-                    namespace G {
-                        namespace N {
-                            namespace imports {
-                                namespace N {
-                                    namespace DX {
-                                        namespace N {
-                                            namespace G {
-                                                namespace N {
-                                                    namespace path {
-                                                        namespace N { }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                        }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                            namespace root_$__$_namespace {
-                                namespace N { }
-                                namespace D { }
-                            }
-                        }
-                        namespace D { }
-                    }
-                }
-                namespace D { }
-            }
-            namespace Directory {
-                namespace N {
-                    namespace G {
-                        namespace N {
-                            namespace nodes {
-                                namespace N {
-                                    namespace DX {
-                                        namespace N {
-                                            namespace TU {
-                                                namespace N {
-                                                    namespace directory {
-                                                        namespace N { }
-                                                        namespace D { }
-                                                    }
-                                                    namespace file {
-                                                        namespace N { }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                        }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                        }
-                        namespace D { }
-                    }
-                }
-                namespace D { }
-            }
-            namespace Expression {
-                namespace N {
-                    namespace TU {
-                        namespace N {
-                            namespace flow {
-                                namespace N {
-                                    namespace TU {
-                                        namespace N {
-                                            namespace block {
-                                                namespace N { }
-                                                namespace D { }
-                                            }
-                                            namespace change_$__$_context {
-                                                namespace N {
-                                                    namespace G {
-                                                        namespace N {
-                                                            namespace new_$__$_context_$__$_selection {
-                                                                namespace N { }
-                                                                namespace D { }
-                                                            }
-                                                            namespace sub_$__$_expression {
-                                                                namespace N { }
-                                                                namespace D { }
-                                                            }
-                                                        }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                            namespace implement_$__$_me {
-                                                namespace N { }
-                                                namespace D { }
-                                            }
-                                            namespace panic {
-                                                namespace N { }
-                                                namespace D { }
-                                            }
-                                        }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                            namespace literal {
-                                namespace N {
-                                    namespace TU {
-                                        namespace N {
-                                            namespace array {
-                                                namespace N {
-                                                    namespace A {
-                                                        namespace N { }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                            namespace _$_r_$_boolean {
-                                                namespace N {
-                                                    namespace TU {
-                                                        namespace N {
-                                                            namespace _$_r_$_false {
-                                                                namespace N { }
-                                                                namespace D { }
-                                                            }
-                                                            namespace _$_r_$_true {
-                                                                namespace N { }
-                                                                namespace D { }
-                                                            }
-                                                        }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                            namespace dictionary {
-                                                namespace N {
-                                                    namespace DX {
-                                                        namespace N { }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                            namespace _$_r_$_function {
-                                                namespace N {
-                                                    namespace G {
-                                                        namespace N {
-                                                            namespace block {
-                                                                namespace N { }
-                                                                namespace D { }
-                                                            }
-                                                            namespace temp_$__$_signature_$__$_help {
-                                                                namespace N {
-                                                                    namespace TU {
-                                                                        namespace N {
-                                                                            namespace has_$__$_additional_$__$_parameters {
-                                                                                namespace N { }
-                                                                                namespace D { }
-                                                                            }
-                                                                            namespace has_$__$_no_$__$_additional_$__$_parameters {
-                                                                                namespace N { }
-                                                                                namespace D { }
-                                                                            }
-                                                                            namespace typed {
-                                                                                namespace N { }
-                                                                                namespace D { }
-                                                                            }
-                                                                        }
-                                                                        namespace D { }
-                                                                    }
-                                                                }
-                                                                namespace D { }
-                                                            }
-                                                        }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                            namespace group {
-                                                namespace N {
-                                                    namespace DX {
-                                                        namespace N { }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                            namespace _$_r_$_null {
-                                                namespace N { }
-                                                namespace D { }
-                                            }
-                                            namespace _$_r_$_number {
-                                                namespace N { }
-                                                namespace D { }
-                                            }
-                                            namespace optional {
-                                                namespace N {
-                                                    namespace TU {
-                                                        namespace N {
-                                                            namespace not_$__$_set {
-                                                                namespace N { }
-                                                                namespace D { }
-                                                            }
-                                                            namespace _$_r_$_set {
-                                                                namespace N { }
-                                                                namespace D { }
-                                                            }
-                                                        }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                            namespace _$_r_$_string {
-                                                namespace N { }
-                                                namespace D { }
-                                            }
-                                            namespace tagged_$__$_union {
-                                                namespace N {
-                                                    namespace G {
-                                                        namespace N {
-                                                            namespace data {
-                                                                namespace N { }
-                                                                namespace D { }
-                                                            }
-                                                            namespace state {
-                                                                namespace N { }
-                                                                namespace D { }
-                                                            }
-                                                        }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                        }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                            namespace map {
-                                namespace N {
-                                    namespace G {
-                                        namespace N {
-                                            namespace selection {
-                                                namespace N { }
-                                                namespace D { }
-                                            }
-                                            namespace _$_r_$_type {
-                                                namespace N {
-                                                    namespace TU {
-                                                        namespace N {
-                                                            namespace array {
-                                                                namespace N { }
-                                                                namespace D { }
-                                                            }
-                                                            namespace _$_r_$_boolean {
-                                                                namespace N {
-                                                                    namespace G {
-                                                                        namespace N {
-                                                                            namespace false_$__$_expression {
-                                                                                namespace N { }
-                                                                                namespace D { }
-                                                                            }
-                                                                            namespace true_$__$_expression {
-                                                                                namespace N { }
-                                                                                namespace D { }
-                                                                            }
-                                                                        }
-                                                                        namespace D { }
-                                                                    }
-                                                                }
-                                                                namespace D { }
-                                                            }
-                                                            namespace dictionary {
-                                                                namespace N { }
-                                                                namespace D { }
-                                                            }
-                                                            namespace optional {
-                                                                namespace N {
-                                                                    namespace G {
-                                                                        namespace N {
-                                                                            namespace not_$__$_set {
-                                                                                namespace N { }
-                                                                                namespace D { }
-                                                                            }
-                                                                            namespace _$_r_$_set {
-                                                                                namespace N { }
-                                                                                namespace D { }
-                                                                            }
-                                                                        }
-                                                                        namespace D { }
-                                                                    }
-                                                                }
-                                                                namespace D { }
-                                                            }
-                                                            namespace tagged_$__$_union {
-                                                                namespace N {
-                                                                    namespace G {
-                                                                        namespace N {
-                                                                            namespace cases {
-                                                                                namespace N {
-                                                                                    namespace DX {
-                                                                                        namespace N { }
-                                                                                        namespace D { }
-                                                                                    }
-                                                                                }
-                                                                                namespace D { }
-                                                                            }
-                                                                            namespace _$_r_$_default {
-                                                                                namespace N {
-                                                                                    namespace O {
-                                                                                        namespace N { }
-                                                                                        namespace D { }
-                                                                                    }
-                                                                                }
-                                                                                namespace D { }
-                                                                            }
-                                                                        }
-                                                                        namespace D { }
-                                                                    }
-                                                                }
-                                                                namespace D { }
-                                                            }
-                                                        }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                        }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                            namespace reduce {
-                                namespace N {
-                                    namespace G {
-                                        namespace N {
-                                            namespace callback {
-                                                namespace N { }
-                                                namespace D { }
-                                            }
-                                            namespace initial {
-                                                namespace N { }
-                                                namespace D { }
-                                            }
-                                            namespace selection {
-                                                namespace N { }
-                                                namespace D { }
-                                            }
-                                        }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                            namespace selection {
-                                namespace N {
-                                    namespace G {
-                                        namespace N {
-                                            namespace start {
-                                                namespace N {
-                                                    namespace TU {
-                                                        namespace N {
-                                                            namespace context {
-                                                                namespace N { }
-                                                                namespace D { }
-                                                            }
-                                                            namespace parameter {
-                                                                namespace N { }
-                                                                namespace D { }
-                                                            }
-                                                            namespace seed {
-                                                                namespace N { }
-                                                                namespace D { }
-                                                            }
-                                                            namespace variable {
-                                                                namespace N {
-                                                                    namespace G {
-                                                                        namespace N {
-                                                                            namespace _$_r_$_import {
-                                                                                namespace N {
-                                                                                    namespace O {
-                                                                                        namespace N { }
-                                                                                        namespace D { }
-                                                                                    }
-                                                                                }
-                                                                                namespace D { }
-                                                                            }
-                                                                            namespace namespace_$__$_path {
-                                                                                namespace N {
-                                                                                    namespace A {
-                                                                                        namespace N { }
-                                                                                        namespace D { }
-                                                                                    }
-                                                                                }
-                                                                                namespace D { }
-                                                                            }
-                                                                            namespace variable {
-                                                                                namespace N { }
-                                                                                namespace D { }
-                                                                            }
-                                                                        }
-                                                                        namespace D { }
-                                                                    }
-                                                                }
-                                                                namespace D { }
-                                                            }
-                                                        }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                            namespace tail {
-                                                namespace N {
-                                                    namespace A {
-                                                        namespace N {
-                                                            namespace TU {
-                                                                namespace N {
-                                                                    namespace call {
-                                                                        namespace N {
-                                                                            namespace G {
-                                                                                namespace N {
-                                                                                    namespace _$_r_$_arguments {
-                                                                                        namespace N {
-                                                                                            namespace DX {
-                                                                                                namespace N { }
-                                                                                                namespace D { }
-                                                                                            }
-                                                                                        }
-                                                                                        namespace D { }
-                                                                                    }
-                                                                                    namespace context {
-                                                                                        namespace N { }
-                                                                                        namespace D { }
-                                                                                    }
-                                                                                    namespace type_$__$_arguments {
-                                                                                        namespace N { }
-                                                                                        namespace D { }
-                                                                                    }
-                                                                                }
-                                                                                namespace D { }
-                                                                            }
-                                                                        }
-                                                                        namespace D { }
-                                                                    }
-                                                                    namespace member_$__$_selection {
-                                                                        namespace N { }
-                                                                        namespace D { }
-                                                                    }
-                                                                }
-                                                                namespace D { }
-                                                            }
-                                                        }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                        }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                        }
-                        namespace D { }
-                    }
-                }
-                namespace D { }
-            }
-            namespace Function_$__$_Signature {
-                namespace N {
-                    namespace G {
-                        namespace N {
-                            namespace context_$__$_parameter {
-                                namespace N { }
-                                namespace D { }
-                            }
-                            namespace parameters {
-                                namespace N {
-                                    namespace DX {
-                                        namespace N { }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                            namespace return_$__$_type {
-                                namespace N {
-                                    namespace O {
-                                        namespace N { }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                            namespace type_$__$_parameters {
-                                namespace N { }
-                                namespace D { }
-                            }
-                        }
-                        namespace D { }
-                    }
-                }
-                namespace D { }
-            }
-            namespace Namespace {
-                namespace N {
-                    namespace G {
-                        namespace N {
-                            namespace namespaces {
-                                namespace N {
-                                    namespace DX {
-                                        namespace N { }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                            namespace types {
-                                namespace N {
-                                    namespace DX {
-                                        namespace N {
-                                            namespace G {
-                                                namespace N {
-                                                    namespace _$_r_$_type {
-                                                        namespace N { }
-                                                        namespace D { }
-                                                    }
-                                                    namespace type_$__$_parameters {
-                                                        namespace N { }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                        }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                            namespace variables {
-                                namespace N { }
-                                namespace D { }
-                            }
-                        }
-                        namespace D { }
-                    }
-                }
-                namespace D { }
-            }
-            namespace Statement_$__$_Block {
-                namespace N {
-                    namespace G {
-                        namespace N {
-                            namespace statements {
-                                namespace N {
-                                    namespace A {
-                                        namespace N {
-                                            namespace TU {
-                                                namespace N {
-                                                    namespace assignment {
-                                                        namespace N {
-                                                            namespace G {
-                                                                namespace N {
-                                                                    namespace expression {
-                                                                        namespace N { }
-                                                                        namespace D { }
-                                                                    }
-                                                                    namespace selection {
-                                                                        namespace N { }
-                                                                        namespace D { }
-                                                                    }
-                                                                }
-                                                                namespace D { }
-                                                            }
-                                                        }
-                                                        namespace D { }
-                                                    }
-                                                    namespace change_$__$_context {
-                                                        namespace N {
-                                                            namespace G {
-                                                                namespace N {
-                                                                    namespace new_$__$_context_$__$_selection {
-                                                                        namespace N { }
-                                                                        namespace D { }
-                                                                    }
-                                                                    namespace sub_$__$_statement_$__$_block {
-                                                                        namespace N { }
-                                                                        namespace D { }
-                                                                    }
-                                                                }
-                                                                namespace D { }
-                                                            }
-                                                        }
-                                                        namespace D { }
-                                                    }
-                                                    namespace debug {
-                                                        namespace N { }
-                                                        namespace D { }
-                                                    }
-                                                    namespace expression {
-                                                        namespace N { }
-                                                        namespace D { }
-                                                    }
-                                                    namespace _$_r_$_if {
-                                                        namespace N {
-                                                            namespace G {
-                                                                namespace N {
-                                                                    namespace condition {
-                                                                        namespace N { }
-                                                                        namespace D { }
-                                                                    }
-                                                                    namespace _$_r_$_else {
-                                                                        namespace N {
-                                                                            namespace O {
-                                                                                namespace N { }
-                                                                                namespace D { }
-                                                                            }
-                                                                        }
-                                                                        namespace D { }
-                                                                    }
-                                                                    namespace if_$__$_block {
-                                                                        namespace N { }
-                                                                        namespace D { }
-                                                                    }
-                                                                }
-                                                                namespace D { }
-                                                            }
-                                                        }
-                                                        namespace D { }
-                                                    }
-                                                    namespace _$_r_$_return {
-                                                        namespace N {
-                                                            namespace G {
-                                                                namespace N {
-                                                                    namespace expression {
-                                                                        namespace N { }
-                                                                        namespace D { }
-                                                                    }
-                                                                }
-                                                                namespace D { }
-                                                            }
-                                                        }
-                                                        namespace D { }
-                                                    }
-                                                    namespace sub_$__$_block {
-                                                        namespace N { }
-                                                        namespace D { }
-                                                    }
-                                                    namespace _$_r_$_switch {
-                                                        namespace N {
-                                                            namespace G {
-                                                                namespace N {
-                                                                    namespace cases {
-                                                                        namespace N {
-                                                                            namespace DX {
-                                                                                namespace N { }
-                                                                                namespace D { }
-                                                                            }
-                                                                        }
-                                                                        namespace D { }
-                                                                    }
-                                                                    namespace _$_r_$_default {
-                                                                        namespace N {
-                                                                            namespace O {
-                                                                                namespace N { }
-                                                                                namespace D { }
-                                                                            }
-                                                                        }
-                                                                        namespace D { }
-                                                                    }
-                                                                    namespace select {
-                                                                        namespace N { }
-                                                                        namespace D { }
-                                                                    }
-                                                                }
-                                                                namespace D { }
-                                                            }
-                                                        }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                        }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                            namespace variables {
-                                namespace N { }
-                                namespace D { }
-                            }
-                        }
-                        namespace D { }
-                    }
-                }
-                namespace D { }
-            }
-            namespace Type {
-                namespace N {
-                    namespace TU {
-                        namespace N {
-                            namespace array {
-                                namespace N { }
-                                namespace D { }
-                            }
-                            namespace _$_r_$_boolean {
-                                namespace N { }
-                                namespace D { }
-                            }
-                            namespace dictionary {
-                                namespace N { }
-                                namespace D { }
-                            }
-                            namespace _$_r_$_function {
-                                namespace N { }
-                                namespace D { }
-                            }
-                            namespace group {
-                                namespace N {
-                                    namespace G {
-                                        namespace N {
-                                            namespace members {
-                                                namespace N {
-                                                    namespace DX {
-                                                        namespace N { }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                        }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                            namespace integer {
-                                namespace N { }
-                                namespace D { }
-                            }
-                            namespace _$_r_$_null {
-                                namespace N { }
-                                namespace D { }
-                            }
-                            namespace optional {
-                                namespace N { }
-                                namespace D { }
-                            }
-                            namespace parameter_$__$_selection {
-                                namespace N { }
-                                namespace D { }
-                            }
-                            namespace _$_r_$_string {
-                                namespace N { }
-                                namespace D { }
-                            }
-                            namespace tagged_$__$_union {
-                                namespace N {
-                                    namespace DX {
-                                        namespace N { }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                            namespace type_$__$_selection {
-                                namespace N {
-                                    namespace G {
-                                        namespace N {
-                                            namespace _$_r_$_import {
-                                                namespace N {
-                                                    namespace O {
-                                                        namespace N { }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                            namespace namespace_$__$_path {
-                                                namespace N {
-                                                    namespace A {
-                                                        namespace N { }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                            namespace _$_r_$_type {
-                                                namespace N { }
-                                                namespace D { }
-                                            }
-                                            namespace type_$__$_arguments {
-                                                namespace N { }
-                                                namespace D { }
-                                            }
-                                        }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                        }
-                        namespace D { }
-                    }
-                }
-                namespace D { }
-            }
-            namespace Type_$__$_Arguments {
-                namespace N {
-                    namespace DX {
-                        namespace N { }
-                        namespace D { }
-                    }
-                }
-                namespace D { }
-            }
-            namespace Type_$__$_Parameters {
-                namespace N {
-                    namespace DX {
-                        namespace N { }
-                        namespace D { }
-                    }
-                }
-                namespace D { }
-            }
-            namespace Variables {
-                namespace N {
-                    namespace DX {
-                        namespace N {
-                            namespace G {
-                                namespace N {
-                                    namespace expression {
-                                        namespace N { }
-                                        namespace D { }
-                                    }
-                                    namespace mutable {
-                                        namespace N { }
-                                        namespace D { }
-                                    }
-                                    namespace _$_r_$_type {
-                                        namespace N {
-                                            namespace O {
-                                                namespace N { }
-                                                namespace D { }
-                                            }
-                                        }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                        }
-                        namespace D { }
-                    }
-                }
-                namespace D { }
-            }
-        }
-        namespace D {
-            namespace Compilation__Unit {
-                namespace imports {
-                    namespace DX {
-                        type path = string;
-                    }
-                    type DX = {
-                        readonly 'path': string;
-                    };
-                }
-                type imports = pt.Dictionary<{
-                    readonly 'path': string;
-                }>;
-                type root__namespace = D.Namespace;
-            }
-            type Compilation__Unit = {
-                readonly 'imports': pt.Dictionary<{
-                    readonly 'path': string;
-                }>;
-                readonly 'root namespace': D.Namespace;
-            };
-            namespace Directory {
-                namespace nodes {
-                    namespace DX {
-                        type directory = D.Directory;
-                        type file = D.Compilation__Unit;
-                    }
-                    type DX = ['directory', D.Directory] | ['file', D.Compilation__Unit];
-                }
-                type nodes = pt.Dictionary<['directory', D.Directory] | ['file', D.Compilation__Unit]>;
-            }
-            type Directory = {
-                readonly 'nodes': pt.Dictionary<['directory', D.Directory] | ['file', D.Compilation__Unit]>;
-            };
-            namespace Expression {
-                namespace flow {
-                    type block = D.Statement__Block;
-                    namespace change__context {
-                        type new__context__selection = D.Expression;
-                        type sub__expression = D.Expression;
-                    }
-                    type change__context = {
-                        readonly 'new context selection': D.Expression;
-                        readonly 'sub expression': D.Expression;
-                    };
-                    type implement__me = string;
-                    type panic = string;
-                }
-                type flow = ['block', D.Statement__Block] | [
-                    'change context',
-                    {
-                        readonly 'new context selection': D.Expression;
-                        readonly 'sub expression': D.Expression;
-                    }
-                ] | ['implement me', string] | ['panic', string];
-                namespace literal {
-                    namespace array {
-                        type A = D.Expression;
-                    }
-                    type array = pt.Array<D.Expression>;
-                    namespace _r_boolean {
-                        type _r_false = null;
-                        type _r_true = null;
-                    }
-                    type _r_boolean = ['false', null] | ['true', null];
-                    namespace dictionary {
-                        type DX = D.Expression;
-                    }
-                    type dictionary = pt.Dictionary<D.Expression>;
-                    namespace _r_function {
-                        type block = D.Statement__Block;
-                        namespace temp__signature__help {
-                            type has__additional__parameters = null;
-                            type has__no__additional__parameters = null;
-                            type typed = D.Function__Signature;
-                        }
-                        type temp__signature__help = ['has additional parameters', null] | ['has no additional parameters', null] | ['typed', D.Function__Signature];
-                    }
-                    type _r_function = {
-                        readonly 'block': D.Statement__Block;
-                        readonly 'temp signature help': ['has additional parameters', null] | ['has no additional parameters', null] | ['typed', D.Function__Signature];
-                    };
-                    namespace group {
-                        type DX = D.Expression;
-                    }
-                    type group = pt.Dictionary<D.Expression>;
-                    type _r_null = null;
-                    type _r_number = number;
-                    namespace optional {
-                        type not__set = null;
-                        type _r_set = D.Expression;
-                    }
-                    type optional = ['not set', null] | ['set', D.Expression];
-                    type _r_string = string;
-                    namespace tagged__union {
-                        type data = D.Expression;
-                        type state = string;
-                    }
-                    type tagged__union = {
-                        readonly 'data': D.Expression;
-                        readonly 'state': string;
-                    };
-                }
-                type literal = ['array', pt.Array<D.Expression>] | [
-                    'boolean',
-                    ['false', null] | ['true', null]
-                ] | ['dictionary', pt.Dictionary<D.Expression>] | [
-                    'function',
-                    {
-                        readonly 'block': D.Statement__Block;
-                        readonly 'temp signature help': ['has additional parameters', null] | ['has no additional parameters', null] | ['typed', D.Function__Signature];
-                    }
-                ] | ['group', pt.Dictionary<D.Expression>] | ['null', null] | ['number', number] | [
-                    'optional',
-                    ['not set', null] | ['set', D.Expression]
-                ] | ['string', string] | [
-                    'tagged union',
-                    {
-                        readonly 'data': D.Expression;
-                        readonly 'state': string;
-                    }
-                ];
-                namespace map {
-                    type selection = D.Expression;
-                    namespace _r_type {
-                        type array = D.Expression;
-                        namespace _r_boolean {
-                            type false__expression = D.Expression;
-                            type true__expression = D.Expression;
-                        }
-                        type _r_boolean = {
-                            readonly 'false expression': D.Expression;
-                            readonly 'true expression': D.Expression;
-                        };
-                        type dictionary = D.Expression;
-                        namespace optional {
-                            type not__set = D.Expression;
-                            type _r_set = D.Expression;
-                        }
-                        type optional = {
-                            readonly 'not set': D.Expression;
-                            readonly 'set': D.Expression;
-                        };
-                        namespace tagged__union {
-                            namespace cases {
-                                type DX = D.Expression;
-                            }
-                            type cases = pt.Dictionary<D.Expression>;
-                            namespace _r_default {
-                                type O = D.Expression;
-                            }
-                            type _r_default = pt.OptionalValue<D.Expression>;
-                        }
-                        type tagged__union = {
-                            readonly 'cases': pt.Dictionary<D.Expression>;
-                            readonly 'default': pt.OptionalValue<D.Expression>;
-                        };
-                    }
-                    type _r_type = ['array', D.Expression] | [
-                        'boolean',
-                        {
-                            readonly 'false expression': D.Expression;
-                            readonly 'true expression': D.Expression;
-                        }
-                    ] | ['dictionary', D.Expression] | [
-                        'optional',
-                        {
-                            readonly 'not set': D.Expression;
-                            readonly 'set': D.Expression;
-                        }
-                    ] | [
-                        'tagged union',
-                        {
-                            readonly 'cases': pt.Dictionary<D.Expression>;
-                            readonly 'default': pt.OptionalValue<D.Expression>;
-                        }
-                    ];
-                }
-                type map = {
-                    readonly 'selection': D.Expression;
-                    readonly 'type': ['array', D.Expression] | [
-                        'boolean',
-                        {
-                            readonly 'false expression': D.Expression;
-                            readonly 'true expression': D.Expression;
-                        }
-                    ] | ['dictionary', D.Expression] | [
-                        'optional',
-                        {
-                            readonly 'not set': D.Expression;
-                            readonly 'set': D.Expression;
-                        }
-                    ] | [
-                        'tagged union',
-                        {
-                            readonly 'cases': pt.Dictionary<D.Expression>;
-                            readonly 'default': pt.OptionalValue<D.Expression>;
-                        }
-                    ];
-                };
-                namespace reduce {
-                    type callback = D.Expression;
-                    type initial = D.Expression;
-                    type selection = D.Expression;
-                }
-                type reduce = {
-                    readonly 'callback': D.Expression;
-                    readonly 'initial': D.Expression;
-                    readonly 'selection': D.Expression;
-                };
-                namespace selection {
-                    namespace start {
-                        type context = null;
-                        type parameter = string;
-                        type seed = null;
-                        namespace variable {
-                            namespace _r_import {
-                                type O = string;
-                            }
-                            type _r_import = pt.OptionalValue<string>;
-                            namespace namespace__path {
-                                type A = string;
-                            }
-                            type namespace__path = pt.Array<string>;
-                            type variable = string;
-                        }
-                        type variable = {
-                            readonly 'import': pt.OptionalValue<string>;
-                            readonly 'namespace path': pt.Array<string>;
-                            readonly 'variable': string;
-                        };
-                    }
-                    type start = ['context', null] | ['parameter', string] | ['seed', null] | [
-                        'variable',
-                        {
-                            readonly 'import': pt.OptionalValue<string>;
-                            readonly 'namespace path': pt.Array<string>;
-                            readonly 'variable': string;
-                        }
-                    ];
-                    namespace tail {
-                        namespace A {
-                            namespace call {
-                                namespace _r_arguments {
-                                    type DX = D.Expression;
-                                }
-                                type _r_arguments = pt.Dictionary<D.Expression>;
-                                type context = D.Expression;
-                                type type__arguments = D.Type__Arguments;
-                            }
-                            type call = {
-                                readonly 'arguments': pt.Dictionary<D.Expression>;
-                                readonly 'context': D.Expression;
-                                readonly 'type arguments': D.Type__Arguments;
-                            };
-                            type member__selection = string;
-                        }
-                        type A = [
-                            'call',
-                            {
-                                readonly 'arguments': pt.Dictionary<D.Expression>;
-                                readonly 'context': D.Expression;
-                                readonly 'type arguments': D.Type__Arguments;
-                            }
-                        ] | ['member selection', string];
-                    }
-                    type tail = pt.Array<[
-                        'call',
-                        {
-                            readonly 'arguments': pt.Dictionary<D.Expression>;
-                            readonly 'context': D.Expression;
-                            readonly 'type arguments': D.Type__Arguments;
-                        }
-                    ] | ['member selection', string]>;
-                }
-                type selection = {
-                    readonly 'start': ['context', null] | ['parameter', string] | ['seed', null] | [
-                        'variable',
-                        {
-                            readonly 'import': pt.OptionalValue<string>;
-                            readonly 'namespace path': pt.Array<string>;
-                            readonly 'variable': string;
-                        }
-                    ];
-                    readonly 'tail': pt.Array<[
-                        'call',
-                        {
-                            readonly 'arguments': pt.Dictionary<D.Expression>;
-                            readonly 'context': D.Expression;
-                            readonly 'type arguments': D.Type__Arguments;
-                        }
-                    ] | ['member selection', string]>;
-                };
-            }
-            type Expression = [
-                'flow',
-                ['block', D.Statement__Block] | [
-                    'change context',
-                    {
-                        readonly 'new context selection': D.Expression;
-                        readonly 'sub expression': D.Expression;
-                    }
-                ] | ['implement me', string] | ['panic', string]
-            ] | [
-                'literal',
-                ['array', pt.Array<D.Expression>] | [
-                    'boolean',
-                    ['false', null] | ['true', null]
-                ] | ['dictionary', pt.Dictionary<D.Expression>] | [
-                    'function',
-                    {
-                        readonly 'block': D.Statement__Block;
-                        readonly 'temp signature help': ['has additional parameters', null] | ['has no additional parameters', null] | ['typed', D.Function__Signature];
-                    }
-                ] | ['group', pt.Dictionary<D.Expression>] | ['null', null] | ['number', number] | [
-                    'optional',
-                    ['not set', null] | ['set', D.Expression]
-                ] | ['string', string] | [
-                    'tagged union',
-                    {
-                        readonly 'data': D.Expression;
-                        readonly 'state': string;
-                    }
-                ]
-            ] | [
-                'map',
-                {
-                    readonly 'selection': D.Expression;
-                    readonly 'type': ['array', D.Expression] | [
-                        'boolean',
-                        {
-                            readonly 'false expression': D.Expression;
-                            readonly 'true expression': D.Expression;
-                        }
-                    ] | ['dictionary', D.Expression] | [
-                        'optional',
-                        {
-                            readonly 'not set': D.Expression;
-                            readonly 'set': D.Expression;
-                        }
-                    ] | [
-                        'tagged union',
-                        {
-                            readonly 'cases': pt.Dictionary<D.Expression>;
-                            readonly 'default': pt.OptionalValue<D.Expression>;
-                        }
-                    ];
-                }
-            ] | [
-                'reduce',
-                {
-                    readonly 'callback': D.Expression;
-                    readonly 'initial': D.Expression;
-                    readonly 'selection': D.Expression;
-                }
-            ] | [
-                'selection',
-                {
-                    readonly 'start': ['context', null] | ['parameter', string] | ['seed', null] | [
-                        'variable',
-                        {
-                            readonly 'import': pt.OptionalValue<string>;
-                            readonly 'namespace path': pt.Array<string>;
-                            readonly 'variable': string;
-                        }
-                    ];
-                    readonly 'tail': pt.Array<[
-                        'call',
-                        {
-                            readonly 'arguments': pt.Dictionary<D.Expression>;
-                            readonly 'context': D.Expression;
-                            readonly 'type arguments': D.Type__Arguments;
-                        }
-                    ] | ['member selection', string]>;
-                }
-            ];
-            namespace Function__Signature {
-                type context__parameter = D.Type;
-                namespace parameters {
-                    type DX = D.Type;
-                }
-                type parameters = pt.Dictionary<D.Type>;
-                namespace return__type {
-                    type O = D.Type;
-                }
-                type return__type = pt.OptionalValue<D.Type>;
-                type type__parameters = D.Type__Parameters;
-            }
-            type Function__Signature = {
-                readonly 'context parameter': D.Type;
-                readonly 'parameters': pt.Dictionary<D.Type>;
-                readonly 'return type': pt.OptionalValue<D.Type>;
-                readonly 'type parameters': D.Type__Parameters;
-            };
-            namespace Namespace {
-                namespace namespaces {
-                    type DX = D.Namespace;
-                }
-                type namespaces = pt.Dictionary<D.Namespace>;
-                namespace types {
-                    namespace DX {
-                        type _r_type = D.Type;
-                        type type__parameters = D.Type__Parameters;
-                    }
-                    type DX = {
-                        readonly 'type': D.Type;
-                        readonly 'type parameters': D.Type__Parameters;
-                    };
-                }
-                type types = pt.Dictionary<{
-                    readonly 'type': D.Type;
-                    readonly 'type parameters': D.Type__Parameters;
-                }>;
-                type variables = D.Variables;
-            }
-            type Namespace = {
-                readonly 'namespaces': pt.Dictionary<D.Namespace>;
-                readonly 'types': pt.Dictionary<{
-                    readonly 'type': D.Type;
-                    readonly 'type parameters': D.Type__Parameters;
-                }>;
-                readonly 'variables': D.Variables;
-            };
-            namespace Statement__Block {
-                namespace statements {
-                    namespace A {
-                        namespace assignment {
-                            type expression = D.Expression;
-                            type selection = D.Expression;
-                        }
-                        type assignment = {
-                            readonly 'expression': D.Expression;
-                            readonly 'selection': D.Expression;
-                        };
-                        namespace change__context {
-                            type new__context__selection = D.Expression;
-                            type sub__statement__block = D.Statement__Block;
-                        }
-                        type change__context = {
-                            readonly 'new context selection': D.Expression;
-                            readonly 'sub statement block': D.Statement__Block;
-                        };
-                        type debug = string;
-                        type expression = D.Expression;
-                        namespace _r_if {
-                            type condition = D.Expression;
-                            namespace _r_else {
-                                type O = D.Statement__Block;
-                            }
-                            type _r_else = pt.OptionalValue<D.Statement__Block>;
-                            type if__block = D.Statement__Block;
-                        }
-                        type _r_if = {
-                            readonly 'condition': D.Expression;
-                            readonly 'else': pt.OptionalValue<D.Statement__Block>;
-                            readonly 'if block': D.Statement__Block;
-                        };
-                        namespace _r_return {
-                            type expression = D.Expression;
-                        }
-                        type _r_return = {
-                            readonly 'expression': D.Expression;
-                        };
-                        type sub__block = D.Statement__Block;
-                        namespace _r_switch {
-                            namespace cases {
-                                type DX = D.Statement__Block;
-                            }
-                            type cases = pt.Dictionary<D.Statement__Block>;
-                            namespace _r_default {
-                                type O = D.Statement__Block;
-                            }
-                            type _r_default = pt.OptionalValue<D.Statement__Block>;
-                            type select = D.Expression;
-                        }
-                        type _r_switch = {
-                            readonly 'cases': pt.Dictionary<D.Statement__Block>;
-                            readonly 'default': pt.OptionalValue<D.Statement__Block>;
-                            readonly 'select': D.Expression;
-                        };
-                    }
-                    type A = [
-                        'assignment',
-                        {
-                            readonly 'expression': D.Expression;
-                            readonly 'selection': D.Expression;
-                        }
-                    ] | [
-                        'change context',
-                        {
-                            readonly 'new context selection': D.Expression;
-                            readonly 'sub statement block': D.Statement__Block;
-                        }
-                    ] | ['debug', string] | ['expression', D.Expression] | [
-                        'if',
-                        {
-                            readonly 'condition': D.Expression;
-                            readonly 'else': pt.OptionalValue<D.Statement__Block>;
-                            readonly 'if block': D.Statement__Block;
-                        }
-                    ] | [
-                        'return',
-                        {
-                            readonly 'expression': D.Expression;
-                        }
-                    ] | ['sub block', D.Statement__Block] | [
-                        'switch',
-                        {
-                            readonly 'cases': pt.Dictionary<D.Statement__Block>;
-                            readonly 'default': pt.OptionalValue<D.Statement__Block>;
-                            readonly 'select': D.Expression;
-                        }
-                    ];
-                }
-                type statements = pt.Array<[
-                    'assignment',
-                    {
-                        readonly 'expression': D.Expression;
-                        readonly 'selection': D.Expression;
-                    }
-                ] | [
-                    'change context',
-                    {
-                        readonly 'new context selection': D.Expression;
-                        readonly 'sub statement block': D.Statement__Block;
-                    }
-                ] | ['debug', string] | ['expression', D.Expression] | [
-                    'if',
-                    {
-                        readonly 'condition': D.Expression;
-                        readonly 'else': pt.OptionalValue<D.Statement__Block>;
-                        readonly 'if block': D.Statement__Block;
-                    }
-                ] | [
-                    'return',
-                    {
-                        readonly 'expression': D.Expression;
-                    }
-                ] | ['sub block', D.Statement__Block] | [
-                    'switch',
-                    {
-                        readonly 'cases': pt.Dictionary<D.Statement__Block>;
-                        readonly 'default': pt.OptionalValue<D.Statement__Block>;
-                        readonly 'select': D.Expression;
-                    }
-                ]>;
-                type variables = D.Variables;
-            }
-            type Statement__Block = {
-                readonly 'statements': pt.Array<[
-                    'assignment',
-                    {
-                        readonly 'expression': D.Expression;
-                        readonly 'selection': D.Expression;
-                    }
-                ] | [
-                    'change context',
-                    {
-                        readonly 'new context selection': D.Expression;
-                        readonly 'sub statement block': D.Statement__Block;
-                    }
-                ] | ['debug', string] | ['expression', D.Expression] | [
-                    'if',
-                    {
-                        readonly 'condition': D.Expression;
-                        readonly 'else': pt.OptionalValue<D.Statement__Block>;
-                        readonly 'if block': D.Statement__Block;
-                    }
-                ] | [
-                    'return',
-                    {
-                        readonly 'expression': D.Expression;
-                    }
-                ] | ['sub block', D.Statement__Block] | [
-                    'switch',
-                    {
-                        readonly 'cases': pt.Dictionary<D.Statement__Block>;
-                        readonly 'default': pt.OptionalValue<D.Statement__Block>;
-                        readonly 'select': D.Expression;
-                    }
-                ]>;
-                readonly 'variables': D.Variables;
-            };
-            namespace Type {
-                type array = D.Type;
-                type _r_boolean = null;
-                type dictionary = D.Type;
-                type _r_function = D.Function__Signature;
-                namespace group {
-                    namespace members {
-                        type DX = D.Type;
-                    }
-                    type members = pt.Dictionary<D.Type>;
-                }
-                type group = {
-                    readonly 'members': pt.Dictionary<D.Type>;
-                };
-                type integer = null;
-                type _r_null = null;
-                type optional = D.Type;
-                type parameter__selection = string;
-                type _r_string = null;
-                namespace tagged__union {
-                    type DX = D.Type;
-                }
-                type tagged__union = pt.Dictionary<D.Type>;
-                namespace type__selection {
-                    namespace _r_import {
-                        type O = string;
-                    }
-                    type _r_import = pt.OptionalValue<string>;
-                    namespace namespace__path {
-                        type A = string;
-                    }
-                    type namespace__path = pt.Array<string>;
-                    type _r_type = string;
-                    type type__arguments = D.Type__Arguments;
-                }
-                type type__selection = {
-                    readonly 'import': pt.OptionalValue<string>;
-                    readonly 'namespace path': pt.Array<string>;
-                    readonly 'type': string;
-                    readonly 'type arguments': D.Type__Arguments;
-                };
-            }
-            type Type = ['array', D.Type] | ['boolean', null] | ['dictionary', D.Type] | ['function', D.Function__Signature] | [
-                'group',
-                {
-                    readonly 'members': pt.Dictionary<D.Type>;
-                }
-            ] | ['integer', null] | ['null', null] | ['optional', D.Type] | ['parameter selection', string] | ['string', null] | ['tagged union', pt.Dictionary<D.Type>] | [
-                'type selection',
-                {
-                    readonly 'import': pt.OptionalValue<string>;
-                    readonly 'namespace path': pt.Array<string>;
-                    readonly 'type': string;
-                    readonly 'type arguments': D.Type__Arguments;
-                }
-            ];
-            namespace Type__Arguments {
-                type DX = D.Type;
-            }
-            type Type__Arguments = pt.Dictionary<D.Type>;
-            namespace Type__Parameters {
-                type DX = null;
-            }
-            type Type__Parameters = pt.Dictionary<null>;
-            namespace Variables {
-                namespace DX {
-                    type expression = D.Expression;
-                    type mutable = boolean;
-                    namespace _r_type {
-                        type O = D.Type;
-                    }
-                    type _r_type = pt.OptionalValue<D.Type>;
-                }
-                type DX = {
-                    readonly 'expression': D.Expression;
-                    readonly 'mutable': boolean;
-                    readonly 'type': pt.OptionalValue<D.Type>;
-                };
-            }
-            type Variables = pt.Dictionary<{
-                readonly 'expression': D.Expression;
-                readonly 'mutable': boolean;
-                readonly 'type': pt.OptionalValue<D.Type>;
-            }>;
-        }
-    }
-    namespace out {
-        namespace G { }
-        namespace N { }
-        namespace D {
-            namespace Lines {
-                type A = string;
-            }
-            type Lines = pt.Array<string>;
-        }
-    }
-}
-export declare namespace N { }
-export declare namespace D {
-    namespace Data {
-        type compilation__unit = G._r_in.D.Compilation__Unit;
-    }
-    type Data = {
-        readonly 'compilation unit': G._r_in.D.Compilation__Unit;
-    };
-}
-export declare namespace I { }
-export declare namespace A {
-    type Compilation__Unit__2__Indented__Lines = ($: D.Data) => G.out.D.Lines;
-}