exupery 0.1.12 → 0.1.13

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 (8) hide show
  1. package/dist/generated/interface/core/resolved.d.ts +46 -46
  2. package/dist/generated/interface/core/unconstrained.d.ts +10 -10
  3. package/dist/generated/interface/core/unresolved.d.ts +86 -86
  4. package/dist/generated/interface/schemas/implementation/data_types/resolve.d.ts +133 -133
  5. package/dist/generated/interface/schemas/implementation/data_types/unresolved.d.ts +707 -707
  6. package/dist/generated/interface/schemas/interface/data_types/resolve.d.ts +133 -133
  7. package/dist/generated/interface/schemas/interface/data_types/unresolved.d.ts +224 -224
  8. package/package.json +1 -1
package/dist/generated/interface/schemas/implementation/data_types/unresolved.d.ts CHANGED
@@ -1,82 +1,82 @@
1
1
  import * as _pt from 'exupery-core-types';
2
2
  import * as _i_core from "../../../core/unresolved";
3
3
  import * as _i_imports_interface from "../../interface/data_types/unresolved";
4
- export type _T_Initialization<G_Source> = _i_core._T_State_Group<G_Source, readonly [
4
+ export type _T_Initialization<M_Source> = _i_core._T_State_Group<M_Source, readonly [
5
5
  'block',
6
6
  {
7
- readonly 'initialization': _T_Initialization<G_Source>;
8
- readonly 'temp ordered variables': _i_core._T_List<G_Source, {
9
- readonly 'initialization': _T_Initialization<G_Source>;
7
+ readonly 'initialization': _T_Initialization<M_Source>;
8
+ readonly 'temp ordered variables': _i_core._T_List<M_Source, {
9
+ readonly 'initialization': _T_Initialization<M_Source>;
10
10
  readonly 'name': string;
11
- readonly 'type': _pt.Optional_Value<_i_imports_interface._T_Type<G_Source>>;
11
+ readonly 'type': _pt.Optional_Value<_i_imports_interface._T_Type<M_Source>>;
12
12
  }>;
13
- readonly 'variables': _T_Variables<G_Source>;
13
+ readonly 'variables': _T_Variables<M_Source>;
14
14
  }
15
15
  ] | readonly [
16
16
  'change context',
17
17
  {
18
- readonly 'initialization': _T_Initialization<G_Source>;
19
- readonly 'new context': _T_Selection<G_Source>;
18
+ readonly 'initialization': _T_Initialization<M_Source>;
19
+ readonly 'new context': _T_Selection<M_Source>;
20
20
  }
21
21
  ] | readonly [
22
22
  'literal',
23
23
  {
24
- readonly 'value': _T_Literal<G_Source>;
24
+ readonly 'value': _T_Literal<M_Source>;
25
25
  }
26
- ] | readonly ['selection', _T_Selection<G_Source>] | readonly [
26
+ ] | readonly ['selection', _T_Selection<M_Source>] | readonly [
27
27
  'transformation',
28
28
  {
29
- readonly 'source': _T_Selection<G_Source>;
30
- readonly 'type': _i_core._T_State_Group<G_Source, readonly [
29
+ readonly 'source': _T_Selection<M_Source>;
30
+ readonly 'type': _i_core._T_State_Group<M_Source, readonly [
31
31
  'array',
32
- _i_core._T_State_Group<G_Source, readonly ['map', _T_Initialization<G_Source>]>
32
+ _i_core._T_State_Group<M_Source, readonly ['map', _T_Initialization<M_Source>]>
33
33
  ] | readonly [
34
34
  'boolean',
35
- _i_core._T_State_Group<G_Source, readonly ['not', null] | readonly [
35
+ _i_core._T_State_Group<M_Source, readonly ['not', null] | readonly [
36
36
  'transform',
37
37
  {
38
- readonly 'if false': _T_Initialization<G_Source>;
39
- readonly 'if true': _T_Initialization<G_Source>;
38
+ readonly 'if false': _T_Initialization<M_Source>;
39
+ readonly 'if true': _T_Initialization<M_Source>;
40
40
  }
41
41
  ]>
42
42
  ] | readonly [
43
43
  'dictionary',
44
- _i_core._T_State_Group<G_Source, readonly ['map', _T_Initialization<G_Source>]>
44
+ _i_core._T_State_Group<M_Source, readonly ['map', _T_Initialization<M_Source>]>
45
45
  ] | readonly [
46
46
  'function',
47
- _i_core._T_State_Group<G_Source, readonly [
47
+ _i_core._T_State_Group<M_Source, readonly [
48
48
  'call',
49
49
  {
50
- readonly 'arguments': _pt.Optional_Value<_i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>>;
51
- readonly 'context': _T_Initialization<G_Source>;
50
+ readonly 'arguments': _pt.Optional_Value<_i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>>;
51
+ readonly 'context': _T_Initialization<M_Source>;
52
52
  }
53
53
  ]>
54
54
  ] | readonly [
55
55
  'optional',
56
- _i_core._T_State_Group<G_Source, readonly ['map', _T_Initialization<G_Source>] | readonly [
56
+ _i_core._T_State_Group<M_Source, readonly ['map', _T_Initialization<M_Source>] | readonly [
57
57
  'transform',
58
58
  {
59
- readonly 'if not set': _T_Initialization<G_Source>;
60
- readonly 'if set': _T_Initialization<G_Source>;
61
- readonly 'temp resulting node': _pt.Optional_Value<_i_imports_interface._T_Type<G_Source>>;
59
+ readonly 'if not set': _T_Initialization<M_Source>;
60
+ readonly 'if set': _T_Initialization<M_Source>;
61
+ readonly 'temp resulting node': _pt.Optional_Value<_i_imports_interface._T_Type<M_Source>>;
62
62
  }
63
63
  ]>
64
64
  ] | readonly [
65
65
  'tagged union',
66
- _i_core._T_State_Group<G_Source, readonly [
66
+ _i_core._T_State_Group<M_Source, readonly [
67
67
  'switch',
68
68
  {
69
- readonly 'temp resulting node': _pt.Optional_Value<_i_imports_interface._T_Type<G_Source>>;
70
- readonly 'type': _i_core._T_State_Group<G_Source, readonly [
69
+ readonly 'temp resulting node': _pt.Optional_Value<_i_imports_interface._T_Type<M_Source>>;
70
+ readonly 'type': _i_core._T_State_Group<M_Source, readonly [
71
71
  'full',
72
72
  {
73
- readonly 'cases': _i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>;
73
+ readonly 'cases': _i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>;
74
74
  }
75
75
  ] | readonly [
76
76
  'partial',
77
77
  {
78
- readonly 'cases': _i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>;
79
- readonly 'default': _T_Initialization<G_Source>;
78
+ readonly 'cases': _i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>;
79
+ readonly 'default': _T_Initialization<M_Source>;
80
80
  }
81
81
  ]>;
82
82
  }
@@ -84,40 +84,40 @@ export type _T_Initialization<G_Source> = _i_core._T_State_Group<G_Source, reado
84
84
  ]>;
85
85
  }
86
86
  ]>;
87
- export type _T_Literal<G_Source> = _i_core._T_State_Group<G_Source, readonly ['array', _i_core._T_List<G_Source, _T_Initialization<G_Source>>] | readonly [
87
+ export type _T_Literal<M_Source> = _i_core._T_State_Group<M_Source, readonly ['array', _i_core._T_List<M_Source, _T_Initialization<M_Source>>] | readonly [
88
88
  'boolean',
89
- _i_core._T_State_Group<G_Source, readonly ['false', null] | readonly ['true', null]>
90
- ] | readonly ['dictionary', _i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>] | readonly [
89
+ _i_core._T_State_Group<M_Source, readonly ['false', null] | readonly ['true', null]>
90
+ ] | readonly ['dictionary', _i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>] | readonly [
91
91
  'function',
92
92
  {
93
- readonly 'initialization': _T_Initialization<G_Source>;
93
+ readonly 'initialization': _T_Initialization<M_Source>;
94
94
  readonly 'temp has parameters': boolean;
95
- readonly 'temp resulting node': _pt.Optional_Value<_i_imports_interface._T_Type<G_Source>>;
95
+ readonly 'temp resulting node': _pt.Optional_Value<_i_imports_interface._T_Type<M_Source>>;
96
96
  }
97
- ] | readonly ['group', _i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>] | readonly ['null', null] | readonly [
97
+ ] | readonly ['group', _i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>] | readonly ['null', null] | readonly [
98
98
  'number',
99
- _i_core._T_State_Group<G_Source, readonly ['floting point', number] | readonly ['integer', number] | readonly ['signed integer', number]>
99
+ _i_core._T_State_Group<M_Source, readonly ['floting point', number] | readonly ['integer', number] | readonly ['signed integer', number]>
100
100
  ] | readonly [
101
101
  'optional',
102
- _i_core._T_State_Group<G_Source, readonly ['not set', null] | readonly ['set', _T_Initialization<G_Source>]>
102
+ _i_core._T_State_Group<M_Source, readonly ['not set', null] | readonly ['set', _T_Initialization<M_Source>]>
103
103
  ] | readonly [
104
104
  'string',
105
105
  {
106
- readonly 'delimiter': _i_core._T_State_Group<G_Source, readonly ['backtick', null] | readonly ['quote', null]>;
106
+ readonly 'delimiter': _i_core._T_State_Group<M_Source, readonly ['backtick', null] | readonly ['quote', null]>;
107
107
  readonly 'value': string;
108
108
  }
109
109
  ] | readonly [
110
110
  'tagged union',
111
111
  {
112
112
  readonly 'case': string;
113
- readonly 'value': _T_Initialization<G_Source>;
113
+ readonly 'value': _T_Initialization<M_Source>;
114
114
  }
115
115
  ]>;
116
- export type _T_Module<G_Source> = {
117
- readonly 'type imports': _i_imports_interface._T_Imports<G_Source>;
118
- readonly 'variable imports': _i_core._T_Dictionary<G_Source, {
119
- readonly 'tail': _i_core._T_List<G_Source, string>;
120
- readonly 'type': _i_core._T_State_Group<G_Source, readonly [
116
+ export type _T_Module<M_Source> = {
117
+ readonly 'type imports': _i_imports_interface._T_Imports<M_Source>;
118
+ readonly 'variable imports': _i_core._T_Dictionary<M_Source, {
119
+ readonly 'tail': _i_core._T_List<M_Source, string>;
120
+ readonly 'type': _i_core._T_State_Group<M_Source, readonly [
121
121
  'ancestor',
122
122
  {
123
123
  readonly 'dependency': string;
@@ -125,16 +125,16 @@ export type _T_Module<G_Source> = {
125
125
  }
126
126
  ] | readonly ['external', string] | readonly ['sibling', string]>;
127
127
  }>;
128
- readonly 'variables': _T_Variables<G_Source>;
128
+ readonly 'variables': _T_Variables<M_Source>;
129
129
  };
130
- export type _T_Module_Set<G_Source> = _i_core._T_Dictionary<G_Source, _i_core._T_State_Group<G_Source, readonly ['module', _T_Module<G_Source>] | readonly ['set', _T_Module_Set<G_Source>]>>;
131
- export type _T_Selection<G_Source> = {
132
- readonly 'start': _i_core._T_State_Group<G_Source, readonly ['abort', null] | readonly ['argument', string] | readonly [
130
+ export type _T_Module_Set<M_Source> = _i_core._T_Dictionary<M_Source, _i_core._T_State_Group<M_Source, readonly ['module', _T_Module<M_Source>] | readonly ['set', _T_Module_Set<M_Source>]>>;
131
+ export type _T_Selection<M_Source> = {
132
+ readonly 'start': _i_core._T_State_Group<M_Source, readonly ['abort', null] | readonly ['argument', string] | readonly [
133
133
  'call',
134
134
  {
135
- readonly 'arguments': _pt.Optional_Value<_i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>>;
136
- readonly 'context': _T_Selection<G_Source>;
137
- readonly 'source': _T_Selection<G_Source>;
135
+ readonly 'arguments': _pt.Optional_Value<_i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>>;
136
+ readonly 'context': _T_Selection<M_Source>;
137
+ readonly 'source': _T_Selection<M_Source>;
138
138
  }
139
139
  ] | readonly ['context', null] | readonly ['implement me', null] | readonly [
140
140
  'imported variable',
@@ -145,146 +145,146 @@ export type _T_Selection<G_Source> = {
145
145
  ] | readonly ['parameter', string] | readonly [
146
146
  'transform optional value',
147
147
  {
148
- readonly 'if not set': _T_Selection<G_Source>;
149
- readonly 'if set': _T_Selection<G_Source>;
150
- readonly 'source': _T_Selection<G_Source>;
148
+ readonly 'if not set': _T_Selection<M_Source>;
149
+ readonly 'if set': _T_Selection<M_Source>;
150
+ readonly 'source': _T_Selection<M_Source>;
151
151
  }
152
152
  ] | readonly ['variable', string]>;
153
- readonly 'tail': _i_core._T_List<G_Source, string>;
153
+ readonly 'tail': _i_core._T_List<M_Source, string>;
154
154
  };
155
- export type _T_Type_Parameters<G_Source> = _i_core._T_Dictionary<G_Source, null>;
156
- export type _T_Variables<G_Source> = _i_core._T_Dictionary<G_Source, {
157
- readonly 'initialization': _T_Initialization<G_Source>;
158
- readonly 'type': _pt.Optional_Value<_i_imports_interface._T_Type<G_Source>>;
155
+ export type _T_Type_Parameters<M_Source> = _i_core._T_Dictionary<M_Source, null>;
156
+ export type _T_Variables<M_Source> = _i_core._T_Dictionary<M_Source, {
157
+ readonly 'initialization': _T_Initialization<M_Source>;
158
+ readonly 'type': _pt.Optional_Value<_i_imports_interface._T_Type<M_Source>>;
159
159
  }>;
160
- export type Initialization<G_Source> = _T_Initialization<G_Source>;
161
- export type Literal<G_Source> = _T_Literal<G_Source>;
162
- export type Module<G_Source> = _T_Module<G_Source>;
163
- export type Module_Set<G_Source> = _T_Module_Set<G_Source>;
164
- export type Selection<G_Source> = _T_Selection<G_Source>;
165
- export type Type_Parameters<G_Source> = _T_Type_Parameters<G_Source>;
166
- export type Variables<G_Source> = _T_Variables<G_Source>;
160
+ export type Initialization<M_Source> = _T_Initialization<M_Source>;
161
+ export type Literal<M_Source> = _T_Literal<M_Source>;
162
+ export type Module<M_Source> = _T_Module<M_Source>;
163
+ export type Module_Set<M_Source> = _T_Module_Set<M_Source>;
164
+ export type Selection<M_Source> = _T_Selection<M_Source>;
165
+ export type Type_Parameters<M_Source> = _T_Type_Parameters<M_Source>;
166
+ export type Variables<M_Source> = _T_Variables<M_Source>;
167
167
  export declare namespace _T_Initialization {
168
168
  namespace SG {
169
169
  namespace block {
170
170
  namespace initialization {
171
171
  }
172
- type initialization<G_Source> = _T_Initialization<G_Source>;
172
+ type initialization<M_Source> = _T_Initialization<M_Source>;
173
173
  namespace temp_ordered_variables {
174
174
  namespace L {
175
175
  namespace initialization {
176
176
  }
177
- type initialization<G_Source> = _T_Initialization<G_Source>;
178
- type name<G_Source> = string;
177
+ type initialization<M_Source> = _T_Initialization<M_Source>;
178
+ type name<M_Source> = string;
179
179
  namespace _type {
180
180
  namespace O {
181
181
  }
182
- type O<G_Source> = _i_imports_interface._T_Type<G_Source>;
182
+ type O<M_Source> = _i_imports_interface._T_Type<M_Source>;
183
183
  }
184
- type _type<G_Source> = _pt.Optional_Value<_i_imports_interface._T_Type<G_Source>>;
184
+ type _type<M_Source> = _pt.Optional_Value<_i_imports_interface._T_Type<M_Source>>;
185
185
  }
186
- type L<G_Source> = {
187
- readonly 'initialization': _T_Initialization<G_Source>;
186
+ type L<M_Source> = {
187
+ readonly 'initialization': _T_Initialization<M_Source>;
188
188
  readonly 'name': string;
189
- readonly 'type': _pt.Optional_Value<_i_imports_interface._T_Type<G_Source>>;
189
+ readonly 'type': _pt.Optional_Value<_i_imports_interface._T_Type<M_Source>>;
190
190
  };
191
191
  }
192
- type temp_ordered_variables<G_Source> = _i_core._T_List<G_Source, {
193
- readonly 'initialization': _T_Initialization<G_Source>;
192
+ type temp_ordered_variables<M_Source> = _i_core._T_List<M_Source, {
193
+ readonly 'initialization': _T_Initialization<M_Source>;
194
194
  readonly 'name': string;
195
- readonly 'type': _pt.Optional_Value<_i_imports_interface._T_Type<G_Source>>;
195
+ readonly 'type': _pt.Optional_Value<_i_imports_interface._T_Type<M_Source>>;
196
196
  }>;
197
197
  namespace variables {
198
198
  }
199
- type variables<G_Source> = _T_Variables<G_Source>;
199
+ type variables<M_Source> = _T_Variables<M_Source>;
200
200
  }
201
- type block<G_Source> = {
202
- readonly 'initialization': _T_Initialization<G_Source>;
203
- readonly 'temp ordered variables': _i_core._T_List<G_Source, {
204
- readonly 'initialization': _T_Initialization<G_Source>;
201
+ type block<M_Source> = {
202
+ readonly 'initialization': _T_Initialization<M_Source>;
203
+ readonly 'temp ordered variables': _i_core._T_List<M_Source, {
204
+ readonly 'initialization': _T_Initialization<M_Source>;
205
205
  readonly 'name': string;
206
- readonly 'type': _pt.Optional_Value<_i_imports_interface._T_Type<G_Source>>;
206
+ readonly 'type': _pt.Optional_Value<_i_imports_interface._T_Type<M_Source>>;
207
207
  }>;
208
- readonly 'variables': _T_Variables<G_Source>;
208
+ readonly 'variables': _T_Variables<M_Source>;
209
209
  };
210
210
  namespace change_context {
211
211
  namespace initialization {
212
212
  }
213
- type initialization<G_Source> = _T_Initialization<G_Source>;
213
+ type initialization<M_Source> = _T_Initialization<M_Source>;
214
214
  namespace new_context {
215
215
  }
216
- type new_context<G_Source> = _T_Selection<G_Source>;
216
+ type new_context<M_Source> = _T_Selection<M_Source>;
217
217
  }
218
- type change_context<G_Source> = {
219
- readonly 'initialization': _T_Initialization<G_Source>;
220
- readonly 'new context': _T_Selection<G_Source>;
218
+ type change_context<M_Source> = {
219
+ readonly 'initialization': _T_Initialization<M_Source>;
220
+ readonly 'new context': _T_Selection<M_Source>;
221
221
  };
222
222
  namespace literal {
223
223
  namespace value {
224
224
  }
225
- type value<G_Source> = _T_Literal<G_Source>;
225
+ type value<M_Source> = _T_Literal<M_Source>;
226
226
  }
227
- type literal<G_Source> = {
228
- readonly 'value': _T_Literal<G_Source>;
227
+ type literal<M_Source> = {
228
+ readonly 'value': _T_Literal<M_Source>;
229
229
  };
230
230
  namespace selection {
231
231
  }
232
- type selection<G_Source> = _T_Selection<G_Source>;
232
+ type selection<M_Source> = _T_Selection<M_Source>;
233
233
  namespace transformation {
234
234
  namespace source {
235
235
  }
236
- type source<G_Source> = _T_Selection<G_Source>;
236
+ type source<M_Source> = _T_Selection<M_Source>;
237
237
  namespace _type {
238
238
  namespace SG {
239
239
  namespace array {
240
240
  namespace SG {
241
241
  namespace map {
242
242
  }
243
- type map<G_Source> = _T_Initialization<G_Source>;
243
+ type map<M_Source> = _T_Initialization<M_Source>;
244
244
  }
245
- type SG<G_Source> = readonly ['map', _T_Initialization<G_Source>];
245
+ type SG<M_Source> = readonly ['map', _T_Initialization<M_Source>];
246
246
  }
247
- type array<G_Source> = _i_core._T_State_Group<G_Source, readonly ['map', _T_Initialization<G_Source>]>;
247
+ type array<M_Source> = _i_core._T_State_Group<M_Source, readonly ['map', _T_Initialization<M_Source>]>;
248
248
  namespace _boolean {
249
249
  namespace SG {
250
- type not<G_Source> = null;
250
+ type not<M_Source> = null;
251
251
  namespace transform {
252
252
  namespace if_false {
253
253
  }
254
- type if_false<G_Source> = _T_Initialization<G_Source>;
254
+ type if_false<M_Source> = _T_Initialization<M_Source>;
255
255
  namespace if_true {
256
256
  }
257
- type if_true<G_Source> = _T_Initialization<G_Source>;
257
+ type if_true<M_Source> = _T_Initialization<M_Source>;
258
258
  }
259
- type transform<G_Source> = {
260
- readonly 'if false': _T_Initialization<G_Source>;
261
- readonly 'if true': _T_Initialization<G_Source>;
259
+ type transform<M_Source> = {
260
+ readonly 'if false': _T_Initialization<M_Source>;
261
+ readonly 'if true': _T_Initialization<M_Source>;
262
262
  };
263
263
  }
264
- type SG<G_Source> = readonly ['not', null] | readonly [
264
+ type SG<M_Source> = readonly ['not', null] | readonly [
265
265
  'transform',
266
266
  {
267
- readonly 'if false': _T_Initialization<G_Source>;
268
- readonly 'if true': _T_Initialization<G_Source>;
267
+ readonly 'if false': _T_Initialization<M_Source>;
268
+ readonly 'if true': _T_Initialization<M_Source>;
269
269
  }
270
270
  ];
271
271
  }
272
- type _boolean<G_Source> = _i_core._T_State_Group<G_Source, readonly ['not', null] | readonly [
272
+ type _boolean<M_Source> = _i_core._T_State_Group<M_Source, readonly ['not', null] | readonly [
273
273
  'transform',
274
274
  {
275
- readonly 'if false': _T_Initialization<G_Source>;
276
- readonly 'if true': _T_Initialization<G_Source>;
275
+ readonly 'if false': _T_Initialization<M_Source>;
276
+ readonly 'if true': _T_Initialization<M_Source>;
277
277
  }
278
278
  ]>;
279
279
  namespace dictionary {
280
280
  namespace SG {
281
281
  namespace map {
282
282
  }
283
- type map<G_Source> = _T_Initialization<G_Source>;
283
+ type map<M_Source> = _T_Initialization<M_Source>;
284
284
  }
285
- type SG<G_Source> = readonly ['map', _T_Initialization<G_Source>];
285
+ type SG<M_Source> = readonly ['map', _T_Initialization<M_Source>];
286
286
  }
287
- type dictionary<G_Source> = _i_core._T_State_Group<G_Source, readonly ['map', _T_Initialization<G_Source>]>;
287
+ type dictionary<M_Source> = _i_core._T_State_Group<M_Source, readonly ['map', _T_Initialization<M_Source>]>;
288
288
  namespace _function {
289
289
  namespace SG {
290
290
  namespace call {
@@ -292,75 +292,75 @@ export declare namespace _T_Initialization {
292
292
  namespace O {
293
293
  namespace D {
294
294
  }
295
- type D<G_Source> = _T_Initialization<G_Source>;
295
+ type D<M_Source> = _T_Initialization<M_Source>;
296
296
  }
297
- type O<G_Source> = _i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>;
297
+ type O<M_Source> = _i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>;
298
298
  }
299
- type _arguments<G_Source> = _pt.Optional_Value<_i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>>;
299
+ type _arguments<M_Source> = _pt.Optional_Value<_i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>>;
300
300
  namespace context {
301
301
  }
302
- type context<G_Source> = _T_Initialization<G_Source>;
302
+ type context<M_Source> = _T_Initialization<M_Source>;
303
303
  }
304
- type call<G_Source> = {
305
- readonly 'arguments': _pt.Optional_Value<_i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>>;
306
- readonly 'context': _T_Initialization<G_Source>;
304
+ type call<M_Source> = {
305
+ readonly 'arguments': _pt.Optional_Value<_i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>>;
306
+ readonly 'context': _T_Initialization<M_Source>;
307
307
  };
308
308
  }
309
- type SG<G_Source> = readonly [
309
+ type SG<M_Source> = readonly [
310
310
  'call',
311
311
  {
312
- readonly 'arguments': _pt.Optional_Value<_i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>>;
313
- readonly 'context': _T_Initialization<G_Source>;
312
+ readonly 'arguments': _pt.Optional_Value<_i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>>;
313
+ readonly 'context': _T_Initialization<M_Source>;
314
314
  }
315
315
  ];
316
316
  }
317
- type _function<G_Source> = _i_core._T_State_Group<G_Source, readonly [
317
+ type _function<M_Source> = _i_core._T_State_Group<M_Source, readonly [
318
318
  'call',
319
319
  {
320
- readonly 'arguments': _pt.Optional_Value<_i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>>;
321
- readonly 'context': _T_Initialization<G_Source>;
320
+ readonly 'arguments': _pt.Optional_Value<_i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>>;
321
+ readonly 'context': _T_Initialization<M_Source>;
322
322
  }
323
323
  ]>;
324
324
  namespace optional {
325
325
  namespace SG {
326
326
  namespace map {
327
327
  }
328
- type map<G_Source> = _T_Initialization<G_Source>;
328
+ type map<M_Source> = _T_Initialization<M_Source>;
329
329
  namespace transform {
330
330
  namespace if_not_set {
331
331
  }
332
- type if_not_set<G_Source> = _T_Initialization<G_Source>;
332
+ type if_not_set<M_Source> = _T_Initialization<M_Source>;
333
333
  namespace if_set {
334
334
  }
335
- type if_set<G_Source> = _T_Initialization<G_Source>;
335
+ type if_set<M_Source> = _T_Initialization<M_Source>;
336
336
  namespace temp_resulting_node {
337
337
  namespace O {
338
338
  }
339
- type O<G_Source> = _i_imports_interface._T_Type<G_Source>;
339
+ type O<M_Source> = _i_imports_interface._T_Type<M_Source>;
340
340
  }
341
- type temp_resulting_node<G_Source> = _pt.Optional_Value<_i_imports_interface._T_Type<G_Source>>;
341
+ type temp_resulting_node<M_Source> = _pt.Optional_Value<_i_imports_interface._T_Type<M_Source>>;
342
342
  }
343
- type transform<G_Source> = {
344
- readonly 'if not set': _T_Initialization<G_Source>;
345
- readonly 'if set': _T_Initialization<G_Source>;
346
- readonly 'temp resulting node': _pt.Optional_Value<_i_imports_interface._T_Type<G_Source>>;
343
+ type transform<M_Source> = {
344
+ readonly 'if not set': _T_Initialization<M_Source>;
345
+ readonly 'if set': _T_Initialization<M_Source>;
346
+ readonly 'temp resulting node': _pt.Optional_Value<_i_imports_interface._T_Type<M_Source>>;
347
347
  };
348
348
  }
349
- type SG<G_Source> = readonly ['map', _T_Initialization<G_Source>] | readonly [
349
+ type SG<M_Source> = readonly ['map', _T_Initialization<M_Source>] | readonly [
350
350
  'transform',
351
351
  {
352
- readonly 'if not set': _T_Initialization<G_Source>;
353
- readonly 'if set': _T_Initialization<G_Source>;
354
- readonly 'temp resulting node': _pt.Optional_Value<_i_imports_interface._T_Type<G_Source>>;
352
+ readonly 'if not set': _T_Initialization<M_Source>;
353
+ readonly 'if set': _T_Initialization<M_Source>;
354
+ readonly 'temp resulting node': _pt.Optional_Value<_i_imports_interface._T_Type<M_Source>>;
355
355
  }
356
356
  ];
357
357
  }
358
- type optional<G_Source> = _i_core._T_State_Group<G_Source, readonly ['map', _T_Initialization<G_Source>] | readonly [
358
+ type optional<M_Source> = _i_core._T_State_Group<M_Source, readonly ['map', _T_Initialization<M_Source>] | readonly [
359
359
  'transform',
360
360
  {
361
- readonly 'if not set': _T_Initialization<G_Source>;
362
- readonly 'if set': _T_Initialization<G_Source>;
363
- readonly 'temp resulting node': _pt.Optional_Value<_i_imports_interface._T_Type<G_Source>>;
361
+ readonly 'if not set': _T_Initialization<M_Source>;
362
+ readonly 'if set': _T_Initialization<M_Source>;
363
+ readonly 'temp resulting node': _pt.Optional_Value<_i_imports_interface._T_Type<M_Source>>;
364
364
  }
365
365
  ]>;
366
366
  namespace tagged_union {
@@ -369,282 +369,282 @@ export declare namespace _T_Initialization {
369
369
  namespace temp_resulting_node {
370
370
  namespace O {
371
371
  }
372
- type O<G_Source> = _i_imports_interface._T_Type<G_Source>;
372
+ type O<M_Source> = _i_imports_interface._T_Type<M_Source>;
373
373
  }
374
- type temp_resulting_node<G_Source> = _pt.Optional_Value<_i_imports_interface._T_Type<G_Source>>;
374
+ type temp_resulting_node<M_Source> = _pt.Optional_Value<_i_imports_interface._T_Type<M_Source>>;
375
375
  namespace _type {
376
376
  namespace SG {
377
377
  namespace full {
378
378
  namespace cases {
379
379
  namespace D {
380
380
  }
381
- type D<G_Source> = _T_Initialization<G_Source>;
381
+ type D<M_Source> = _T_Initialization<M_Source>;
382
382
  }
383
- type cases<G_Source> = _i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>;
383
+ type cases<M_Source> = _i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>;
384
384
  }
385
- type full<G_Source> = {
386
- readonly 'cases': _i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>;
385
+ type full<M_Source> = {
386
+ readonly 'cases': _i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>;
387
387
  };
388
388
  namespace partial {
389
389
  namespace cases {
390
390
  namespace D {
391
391
  }
392
- type D<G_Source> = _T_Initialization<G_Source>;
392
+ type D<M_Source> = _T_Initialization<M_Source>;
393
393
  }
394
- type cases<G_Source> = _i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>;
394
+ type cases<M_Source> = _i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>;
395
395
  namespace _default {
396
396
  }
397
- type _default<G_Source> = _T_Initialization<G_Source>;
397
+ type _default<M_Source> = _T_Initialization<M_Source>;
398
398
  }
399
- type partial<G_Source> = {
400
- readonly 'cases': _i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>;
401
- readonly 'default': _T_Initialization<G_Source>;
399
+ type partial<M_Source> = {
400
+ readonly 'cases': _i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>;
401
+ readonly 'default': _T_Initialization<M_Source>;
402
402
  };
403
403
  }
404
- type SG<G_Source> = readonly [
404
+ type SG<M_Source> = readonly [
405
405
  'full',
406
406
  {
407
- readonly 'cases': _i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>;
407
+ readonly 'cases': _i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>;
408
408
  }
409
409
  ] | readonly [
410
410
  'partial',
411
411
  {
412
- readonly 'cases': _i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>;
413
- readonly 'default': _T_Initialization<G_Source>;
412
+ readonly 'cases': _i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>;
413
+ readonly 'default': _T_Initialization<M_Source>;
414
414
  }
415
415
  ];
416
416
  }
417
- type _type<G_Source> = _i_core._T_State_Group<G_Source, readonly [
417
+ type _type<M_Source> = _i_core._T_State_Group<M_Source, readonly [
418
418
  'full',
419
419
  {
420
- readonly 'cases': _i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>;
420
+ readonly 'cases': _i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>;
421
421
  }
422
422
  ] | readonly [
423
423
  'partial',
424
424
  {
425
- readonly 'cases': _i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>;
426
- readonly 'default': _T_Initialization<G_Source>;
425
+ readonly 'cases': _i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>;
426
+ readonly 'default': _T_Initialization<M_Source>;
427
427
  }
428
428
  ]>;
429
429
  }
430
- type _switch<G_Source> = {
431
- readonly 'temp resulting node': _pt.Optional_Value<_i_imports_interface._T_Type<G_Source>>;
432
- readonly 'type': _i_core._T_State_Group<G_Source, readonly [
430
+ type _switch<M_Source> = {
431
+ readonly 'temp resulting node': _pt.Optional_Value<_i_imports_interface._T_Type<M_Source>>;
432
+ readonly 'type': _i_core._T_State_Group<M_Source, readonly [
433
433
  'full',
434
434
  {
435
- readonly 'cases': _i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>;
435
+ readonly 'cases': _i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>;
436
436
  }
437
437
  ] | readonly [
438
438
  'partial',
439
439
  {
440
- readonly 'cases': _i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>;
441
- readonly 'default': _T_Initialization<G_Source>;
440
+ readonly 'cases': _i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>;
441
+ readonly 'default': _T_Initialization<M_Source>;
442
442
  }
443
443
  ]>;
444
444
  };
445
445
  }
446
- type SG<G_Source> = readonly [
446
+ type SG<M_Source> = readonly [
447
447
  'switch',
448
448
  {
449
- readonly 'temp resulting node': _pt.Optional_Value<_i_imports_interface._T_Type<G_Source>>;
450
- readonly 'type': _i_core._T_State_Group<G_Source, readonly [
449
+ readonly 'temp resulting node': _pt.Optional_Value<_i_imports_interface._T_Type<M_Source>>;
450
+ readonly 'type': _i_core._T_State_Group<M_Source, readonly [
451
451
  'full',
452
452
  {
453
- readonly 'cases': _i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>;
453
+ readonly 'cases': _i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>;
454
454
  }
455
455
  ] | readonly [
456
456
  'partial',
457
457
  {
458
- readonly 'cases': _i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>;
459
- readonly 'default': _T_Initialization<G_Source>;
458
+ readonly 'cases': _i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>;
459
+ readonly 'default': _T_Initialization<M_Source>;
460
460
  }
461
461
  ]>;
462
462
  }
463
463
  ];
464
464
  }
465
- type tagged_union<G_Source> = _i_core._T_State_Group<G_Source, readonly [
465
+ type tagged_union<M_Source> = _i_core._T_State_Group<M_Source, readonly [
466
466
  'switch',
467
467
  {
468
- readonly 'temp resulting node': _pt.Optional_Value<_i_imports_interface._T_Type<G_Source>>;
469
- readonly 'type': _i_core._T_State_Group<G_Source, readonly [
468
+ readonly 'temp resulting node': _pt.Optional_Value<_i_imports_interface._T_Type<M_Source>>;
469
+ readonly 'type': _i_core._T_State_Group<M_Source, readonly [
470
470
  'full',
471
471
  {
472
- readonly 'cases': _i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>;
472
+ readonly 'cases': _i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>;
473
473
  }
474
474
  ] | readonly [
475
475
  'partial',
476
476
  {
477
- readonly 'cases': _i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>;
478
- readonly 'default': _T_Initialization<G_Source>;
477
+ readonly 'cases': _i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>;
478
+ readonly 'default': _T_Initialization<M_Source>;
479
479
  }
480
480
  ]>;
481
481
  }
482
482
  ]>;
483
483
  }
484
- type SG<G_Source> = readonly [
484
+ type SG<M_Source> = readonly [
485
485
  'array',
486
- _i_core._T_State_Group<G_Source, readonly ['map', _T_Initialization<G_Source>]>
486
+ _i_core._T_State_Group<M_Source, readonly ['map', _T_Initialization<M_Source>]>
487
487
  ] | readonly [
488
488
  'boolean',
489
- _i_core._T_State_Group<G_Source, readonly ['not', null] | readonly [
489
+ _i_core._T_State_Group<M_Source, readonly ['not', null] | readonly [
490
490
  'transform',
491
491
  {
492
- readonly 'if false': _T_Initialization<G_Source>;
493
- readonly 'if true': _T_Initialization<G_Source>;
492
+ readonly 'if false': _T_Initialization<M_Source>;
493
+ readonly 'if true': _T_Initialization<M_Source>;
494
494
  }
495
495
  ]>
496
496
  ] | readonly [
497
497
  'dictionary',
498
- _i_core._T_State_Group<G_Source, readonly ['map', _T_Initialization<G_Source>]>
498
+ _i_core._T_State_Group<M_Source, readonly ['map', _T_Initialization<M_Source>]>
499
499
  ] | readonly [
500
500
  'function',
501
- _i_core._T_State_Group<G_Source, readonly [
501
+ _i_core._T_State_Group<M_Source, readonly [
502
502
  'call',
503
503
  {
504
- readonly 'arguments': _pt.Optional_Value<_i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>>;
505
- readonly 'context': _T_Initialization<G_Source>;
504
+ readonly 'arguments': _pt.Optional_Value<_i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>>;
505
+ readonly 'context': _T_Initialization<M_Source>;
506
506
  }
507
507
  ]>
508
508
  ] | readonly [
509
509
  'optional',
510
- _i_core._T_State_Group<G_Source, readonly ['map', _T_Initialization<G_Source>] | readonly [
510
+ _i_core._T_State_Group<M_Source, readonly ['map', _T_Initialization<M_Source>] | readonly [
511
511
  'transform',
512
512
  {
513
- readonly 'if not set': _T_Initialization<G_Source>;
514
- readonly 'if set': _T_Initialization<G_Source>;
515
- readonly 'temp resulting node': _pt.Optional_Value<_i_imports_interface._T_Type<G_Source>>;
513
+ readonly 'if not set': _T_Initialization<M_Source>;
514
+ readonly 'if set': _T_Initialization<M_Source>;
515
+ readonly 'temp resulting node': _pt.Optional_Value<_i_imports_interface._T_Type<M_Source>>;
516
516
  }
517
517
  ]>
518
518
  ] | readonly [
519
519
  'tagged union',
520
- _i_core._T_State_Group<G_Source, readonly [
520
+ _i_core._T_State_Group<M_Source, readonly [
521
521
  'switch',
522
522
  {
523
- readonly 'temp resulting node': _pt.Optional_Value<_i_imports_interface._T_Type<G_Source>>;
524
- readonly 'type': _i_core._T_State_Group<G_Source, readonly [
523
+ readonly 'temp resulting node': _pt.Optional_Value<_i_imports_interface._T_Type<M_Source>>;
524
+ readonly 'type': _i_core._T_State_Group<M_Source, readonly [
525
525
  'full',
526
526
  {
527
- readonly 'cases': _i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>;
527
+ readonly 'cases': _i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>;
528
528
  }
529
529
  ] | readonly [
530
530
  'partial',
531
531
  {
532
- readonly 'cases': _i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>;
533
- readonly 'default': _T_Initialization<G_Source>;
532
+ readonly 'cases': _i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>;
533
+ readonly 'default': _T_Initialization<M_Source>;
534
534
  }
535
535
  ]>;
536
536
  }
537
537
  ]>
538
538
  ];
539
539
  }
540
- type _type<G_Source> = _i_core._T_State_Group<G_Source, readonly [
540
+ type _type<M_Source> = _i_core._T_State_Group<M_Source, readonly [
541
541
  'array',
542
- _i_core._T_State_Group<G_Source, readonly ['map', _T_Initialization<G_Source>]>
542
+ _i_core._T_State_Group<M_Source, readonly ['map', _T_Initialization<M_Source>]>
543
543
  ] | readonly [
544
544
  'boolean',
545
- _i_core._T_State_Group<G_Source, readonly ['not', null] | readonly [
545
+ _i_core._T_State_Group<M_Source, readonly ['not', null] | readonly [
546
546
  'transform',
547
547
  {
548
- readonly 'if false': _T_Initialization<G_Source>;
549
- readonly 'if true': _T_Initialization<G_Source>;
548
+ readonly 'if false': _T_Initialization<M_Source>;
549
+ readonly 'if true': _T_Initialization<M_Source>;
550
550
  }
551
551
  ]>
552
552
  ] | readonly [
553
553
  'dictionary',
554
- _i_core._T_State_Group<G_Source, readonly ['map', _T_Initialization<G_Source>]>
554
+ _i_core._T_State_Group<M_Source, readonly ['map', _T_Initialization<M_Source>]>
555
555
  ] | readonly [
556
556
  'function',
557
- _i_core._T_State_Group<G_Source, readonly [
557
+ _i_core._T_State_Group<M_Source, readonly [
558
558
  'call',
559
559
  {
560
- readonly 'arguments': _pt.Optional_Value<_i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>>;
561
- readonly 'context': _T_Initialization<G_Source>;
560
+ readonly 'arguments': _pt.Optional_Value<_i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>>;
561
+ readonly 'context': _T_Initialization<M_Source>;
562
562
  }
563
563
  ]>
564
564
  ] | readonly [
565
565
  'optional',
566
- _i_core._T_State_Group<G_Source, readonly ['map', _T_Initialization<G_Source>] | readonly [
566
+ _i_core._T_State_Group<M_Source, readonly ['map', _T_Initialization<M_Source>] | readonly [
567
567
  'transform',
568
568
  {
569
- readonly 'if not set': _T_Initialization<G_Source>;
570
- readonly 'if set': _T_Initialization<G_Source>;
571
- readonly 'temp resulting node': _pt.Optional_Value<_i_imports_interface._T_Type<G_Source>>;
569
+ readonly 'if not set': _T_Initialization<M_Source>;
570
+ readonly 'if set': _T_Initialization<M_Source>;
571
+ readonly 'temp resulting node': _pt.Optional_Value<_i_imports_interface._T_Type<M_Source>>;
572
572
  }
573
573
  ]>
574
574
  ] | readonly [
575
575
  'tagged union',
576
- _i_core._T_State_Group<G_Source, readonly [
576
+ _i_core._T_State_Group<M_Source, readonly [
577
577
  'switch',
578
578
  {
579
- readonly 'temp resulting node': _pt.Optional_Value<_i_imports_interface._T_Type<G_Source>>;
580
- readonly 'type': _i_core._T_State_Group<G_Source, readonly [
579
+ readonly 'temp resulting node': _pt.Optional_Value<_i_imports_interface._T_Type<M_Source>>;
580
+ readonly 'type': _i_core._T_State_Group<M_Source, readonly [
581
581
  'full',
582
582
  {
583
- readonly 'cases': _i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>;
583
+ readonly 'cases': _i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>;
584
584
  }
585
585
  ] | readonly [
586
586
  'partial',
587
587
  {
588
- readonly 'cases': _i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>;
589
- readonly 'default': _T_Initialization<G_Source>;
588
+ readonly 'cases': _i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>;
589
+ readonly 'default': _T_Initialization<M_Source>;
590
590
  }
591
591
  ]>;
592
592
  }
593
593
  ]>
594
594
  ]>;
595
595
  }
596
- type transformation<G_Source> = {
597
- readonly 'source': _T_Selection<G_Source>;
598
- readonly 'type': _i_core._T_State_Group<G_Source, readonly [
596
+ type transformation<M_Source> = {
597
+ readonly 'source': _T_Selection<M_Source>;
598
+ readonly 'type': _i_core._T_State_Group<M_Source, readonly [
599
599
  'array',
600
- _i_core._T_State_Group<G_Source, readonly ['map', _T_Initialization<G_Source>]>
600
+ _i_core._T_State_Group<M_Source, readonly ['map', _T_Initialization<M_Source>]>
601
601
  ] | readonly [
602
602
  'boolean',
603
- _i_core._T_State_Group<G_Source, readonly ['not', null] | readonly [
603
+ _i_core._T_State_Group<M_Source, readonly ['not', null] | readonly [
604
604
  'transform',
605
605
  {
606
- readonly 'if false': _T_Initialization<G_Source>;
607
- readonly 'if true': _T_Initialization<G_Source>;
606
+ readonly 'if false': _T_Initialization<M_Source>;
607
+ readonly 'if true': _T_Initialization<M_Source>;
608
608
  }
609
609
  ]>
610
610
  ] | readonly [
611
611
  'dictionary',
612
- _i_core._T_State_Group<G_Source, readonly ['map', _T_Initialization<G_Source>]>
612
+ _i_core._T_State_Group<M_Source, readonly ['map', _T_Initialization<M_Source>]>
613
613
  ] | readonly [
614
614
  'function',
615
- _i_core._T_State_Group<G_Source, readonly [
615
+ _i_core._T_State_Group<M_Source, readonly [
616
616
  'call',
617
617
  {
618
- readonly 'arguments': _pt.Optional_Value<_i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>>;
619
- readonly 'context': _T_Initialization<G_Source>;
618
+ readonly 'arguments': _pt.Optional_Value<_i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>>;
619
+ readonly 'context': _T_Initialization<M_Source>;
620
620
  }
621
621
  ]>
622
622
  ] | readonly [
623
623
  'optional',
624
- _i_core._T_State_Group<G_Source, readonly ['map', _T_Initialization<G_Source>] | readonly [
624
+ _i_core._T_State_Group<M_Source, readonly ['map', _T_Initialization<M_Source>] | readonly [
625
625
  'transform',
626
626
  {
627
- readonly 'if not set': _T_Initialization<G_Source>;
628
- readonly 'if set': _T_Initialization<G_Source>;
629
- readonly 'temp resulting node': _pt.Optional_Value<_i_imports_interface._T_Type<G_Source>>;
627
+ readonly 'if not set': _T_Initialization<M_Source>;
628
+ readonly 'if set': _T_Initialization<M_Source>;
629
+ readonly 'temp resulting node': _pt.Optional_Value<_i_imports_interface._T_Type<M_Source>>;
630
630
  }
631
631
  ]>
632
632
  ] | readonly [
633
633
  'tagged union',
634
- _i_core._T_State_Group<G_Source, readonly [
634
+ _i_core._T_State_Group<M_Source, readonly [
635
635
  'switch',
636
636
  {
637
- readonly 'temp resulting node': _pt.Optional_Value<_i_imports_interface._T_Type<G_Source>>;
638
- readonly 'type': _i_core._T_State_Group<G_Source, readonly [
637
+ readonly 'temp resulting node': _pt.Optional_Value<_i_imports_interface._T_Type<M_Source>>;
638
+ readonly 'type': _i_core._T_State_Group<M_Source, readonly [
639
639
  'full',
640
640
  {
641
- readonly 'cases': _i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>;
641
+ readonly 'cases': _i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>;
642
642
  }
643
643
  ] | readonly [
644
644
  'partial',
645
645
  {
646
- readonly 'cases': _i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>;
647
- readonly 'default': _T_Initialization<G_Source>;
646
+ readonly 'cases': _i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>;
647
+ readonly 'default': _T_Initialization<M_Source>;
648
648
  }
649
649
  ]>;
650
650
  }
@@ -652,82 +652,82 @@ export declare namespace _T_Initialization {
652
652
  ]>;
653
653
  };
654
654
  }
655
- type SG<G_Source> = readonly [
655
+ type SG<M_Source> = readonly [
656
656
  'block',
657
657
  {
658
- readonly 'initialization': _T_Initialization<G_Source>;
659
- readonly 'temp ordered variables': _i_core._T_List<G_Source, {
660
- readonly 'initialization': _T_Initialization<G_Source>;
658
+ readonly 'initialization': _T_Initialization<M_Source>;
659
+ readonly 'temp ordered variables': _i_core._T_List<M_Source, {
660
+ readonly 'initialization': _T_Initialization<M_Source>;
661
661
  readonly 'name': string;
662
- readonly 'type': _pt.Optional_Value<_i_imports_interface._T_Type<G_Source>>;
662
+ readonly 'type': _pt.Optional_Value<_i_imports_interface._T_Type<M_Source>>;
663
663
  }>;
664
- readonly 'variables': _T_Variables<G_Source>;
664
+ readonly 'variables': _T_Variables<M_Source>;
665
665
  }
666
666
  ] | readonly [
667
667
  'change context',
668
668
  {
669
- readonly 'initialization': _T_Initialization<G_Source>;
670
- readonly 'new context': _T_Selection<G_Source>;
669
+ readonly 'initialization': _T_Initialization<M_Source>;
670
+ readonly 'new context': _T_Selection<M_Source>;
671
671
  }
672
672
  ] | readonly [
673
673
  'literal',
674
674
  {
675
- readonly 'value': _T_Literal<G_Source>;
675
+ readonly 'value': _T_Literal<M_Source>;
676
676
  }
677
- ] | readonly ['selection', _T_Selection<G_Source>] | readonly [
677
+ ] | readonly ['selection', _T_Selection<M_Source>] | readonly [
678
678
  'transformation',
679
679
  {
680
- readonly 'source': _T_Selection<G_Source>;
681
- readonly 'type': _i_core._T_State_Group<G_Source, readonly [
680
+ readonly 'source': _T_Selection<M_Source>;
681
+ readonly 'type': _i_core._T_State_Group<M_Source, readonly [
682
682
  'array',
683
- _i_core._T_State_Group<G_Source, readonly ['map', _T_Initialization<G_Source>]>
683
+ _i_core._T_State_Group<M_Source, readonly ['map', _T_Initialization<M_Source>]>
684
684
  ] | readonly [
685
685
  'boolean',
686
- _i_core._T_State_Group<G_Source, readonly ['not', null] | readonly [
686
+ _i_core._T_State_Group<M_Source, readonly ['not', null] | readonly [
687
687
  'transform',
688
688
  {
689
- readonly 'if false': _T_Initialization<G_Source>;
690
- readonly 'if true': _T_Initialization<G_Source>;
689
+ readonly 'if false': _T_Initialization<M_Source>;
690
+ readonly 'if true': _T_Initialization<M_Source>;
691
691
  }
692
692
  ]>
693
693
  ] | readonly [
694
694
  'dictionary',
695
- _i_core._T_State_Group<G_Source, readonly ['map', _T_Initialization<G_Source>]>
695
+ _i_core._T_State_Group<M_Source, readonly ['map', _T_Initialization<M_Source>]>
696
696
  ] | readonly [
697
697
  'function',
698
- _i_core._T_State_Group<G_Source, readonly [
698
+ _i_core._T_State_Group<M_Source, readonly [
699
699
  'call',
700
700
  {
701
- readonly 'arguments': _pt.Optional_Value<_i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>>;
702
- readonly 'context': _T_Initialization<G_Source>;
701
+ readonly 'arguments': _pt.Optional_Value<_i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>>;
702
+ readonly 'context': _T_Initialization<M_Source>;
703
703
  }
704
704
  ]>
705
705
  ] | readonly [
706
706
  'optional',
707
- _i_core._T_State_Group<G_Source, readonly ['map', _T_Initialization<G_Source>] | readonly [
707
+ _i_core._T_State_Group<M_Source, readonly ['map', _T_Initialization<M_Source>] | readonly [
708
708
  'transform',
709
709
  {
710
- readonly 'if not set': _T_Initialization<G_Source>;
711
- readonly 'if set': _T_Initialization<G_Source>;
712
- readonly 'temp resulting node': _pt.Optional_Value<_i_imports_interface._T_Type<G_Source>>;
710
+ readonly 'if not set': _T_Initialization<M_Source>;
711
+ readonly 'if set': _T_Initialization<M_Source>;
712
+ readonly 'temp resulting node': _pt.Optional_Value<_i_imports_interface._T_Type<M_Source>>;
713
713
  }
714
714
  ]>
715
715
  ] | readonly [
716
716
  'tagged union',
717
- _i_core._T_State_Group<G_Source, readonly [
717
+ _i_core._T_State_Group<M_Source, readonly [
718
718
  'switch',
719
719
  {
720
- readonly 'temp resulting node': _pt.Optional_Value<_i_imports_interface._T_Type<G_Source>>;
721
- readonly 'type': _i_core._T_State_Group<G_Source, readonly [
720
+ readonly 'temp resulting node': _pt.Optional_Value<_i_imports_interface._T_Type<M_Source>>;
721
+ readonly 'type': _i_core._T_State_Group<M_Source, readonly [
722
722
  'full',
723
723
  {
724
- readonly 'cases': _i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>;
724
+ readonly 'cases': _i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>;
725
725
  }
726
726
  ] | readonly [
727
727
  'partial',
728
728
  {
729
- readonly 'cases': _i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>;
730
- readonly 'default': _T_Initialization<G_Source>;
729
+ readonly 'cases': _i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>;
730
+ readonly 'default': _T_Initialization<M_Source>;
731
731
  }
732
732
  ]>;
733
733
  }
@@ -741,146 +741,146 @@ export declare namespace _T_Literal {
741
741
  namespace array {
742
742
  namespace L {
743
743
  }
744
- type L<G_Source> = _T_Initialization<G_Source>;
744
+ type L<M_Source> = _T_Initialization<M_Source>;
745
745
  }
746
- type array<G_Source> = _i_core._T_List<G_Source, _T_Initialization<G_Source>>;
746
+ type array<M_Source> = _i_core._T_List<M_Source, _T_Initialization<M_Source>>;
747
747
  namespace _boolean {
748
748
  namespace SG {
749
- type _false<G_Source> = null;
750
- type _true<G_Source> = null;
749
+ type _false<M_Source> = null;
750
+ type _true<M_Source> = null;
751
751
  }
752
- type SG<G_Source> = readonly ['false', null] | readonly ['true', null];
752
+ type SG<M_Source> = readonly ['false', null] | readonly ['true', null];
753
753
  }
754
- type _boolean<G_Source> = _i_core._T_State_Group<G_Source, readonly ['false', null] | readonly ['true', null]>;
754
+ type _boolean<M_Source> = _i_core._T_State_Group<M_Source, readonly ['false', null] | readonly ['true', null]>;
755
755
  namespace dictionary {
756
756
  namespace D {
757
757
  }
758
- type D<G_Source> = _T_Initialization<G_Source>;
758
+ type D<M_Source> = _T_Initialization<M_Source>;
759
759
  }
760
- type dictionary<G_Source> = _i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>;
760
+ type dictionary<M_Source> = _i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>;
761
761
  namespace _function {
762
762
  namespace initialization {
763
763
  }
764
- type initialization<G_Source> = _T_Initialization<G_Source>;
765
- type temp_has_parameters<G_Source> = boolean;
764
+ type initialization<M_Source> = _T_Initialization<M_Source>;
765
+ type temp_has_parameters<M_Source> = boolean;
766
766
  namespace temp_resulting_node {
767
767
  namespace O {
768
768
  }
769
- type O<G_Source> = _i_imports_interface._T_Type<G_Source>;
769
+ type O<M_Source> = _i_imports_interface._T_Type<M_Source>;
770
770
  }
771
- type temp_resulting_node<G_Source> = _pt.Optional_Value<_i_imports_interface._T_Type<G_Source>>;
771
+ type temp_resulting_node<M_Source> = _pt.Optional_Value<_i_imports_interface._T_Type<M_Source>>;
772
772
  }
773
- type _function<G_Source> = {
774
- readonly 'initialization': _T_Initialization<G_Source>;
773
+ type _function<M_Source> = {
774
+ readonly 'initialization': _T_Initialization<M_Source>;
775
775
  readonly 'temp has parameters': boolean;
776
- readonly 'temp resulting node': _pt.Optional_Value<_i_imports_interface._T_Type<G_Source>>;
776
+ readonly 'temp resulting node': _pt.Optional_Value<_i_imports_interface._T_Type<M_Source>>;
777
777
  };
778
778
  namespace group {
779
779
  namespace D {
780
780
  }
781
- type D<G_Source> = _T_Initialization<G_Source>;
781
+ type D<M_Source> = _T_Initialization<M_Source>;
782
782
  }
783
- type group<G_Source> = _i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>;
784
- type _null<G_Source> = null;
783
+ type group<M_Source> = _i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>;
784
+ type _null<M_Source> = null;
785
785
  namespace _number {
786
786
  namespace SG {
787
- type floting_point<G_Source> = number;
788
- type integer<G_Source> = number;
789
- type signed_integer<G_Source> = number;
787
+ type floting_point<M_Source> = number;
788
+ type integer<M_Source> = number;
789
+ type signed_integer<M_Source> = number;
790
790
  }
791
- type SG<G_Source> = readonly ['floting point', number] | readonly ['integer', number] | readonly ['signed integer', number];
791
+ type SG<M_Source> = readonly ['floting point', number] | readonly ['integer', number] | readonly ['signed integer', number];
792
792
  }
793
- type _number<G_Source> = _i_core._T_State_Group<G_Source, readonly ['floting point', number] | readonly ['integer', number] | readonly ['signed integer', number]>;
793
+ type _number<M_Source> = _i_core._T_State_Group<M_Source, readonly ['floting point', number] | readonly ['integer', number] | readonly ['signed integer', number]>;
794
794
  namespace optional {
795
795
  namespace SG {
796
- type not_set<G_Source> = null;
796
+ type not_set<M_Source> = null;
797
797
  namespace _set {
798
798
  }
799
- type _set<G_Source> = _T_Initialization<G_Source>;
799
+ type _set<M_Source> = _T_Initialization<M_Source>;
800
800
  }
801
- type SG<G_Source> = readonly ['not set', null] | readonly ['set', _T_Initialization<G_Source>];
801
+ type SG<M_Source> = readonly ['not set', null] | readonly ['set', _T_Initialization<M_Source>];
802
802
  }
803
- type optional<G_Source> = _i_core._T_State_Group<G_Source, readonly ['not set', null] | readonly ['set', _T_Initialization<G_Source>]>;
803
+ type optional<M_Source> = _i_core._T_State_Group<M_Source, readonly ['not set', null] | readonly ['set', _T_Initialization<M_Source>]>;
804
804
  namespace _string {
805
805
  namespace delimiter {
806
806
  namespace SG {
807
- type backtick<G_Source> = null;
808
- type quote<G_Source> = null;
807
+ type backtick<M_Source> = null;
808
+ type quote<M_Source> = null;
809
809
  }
810
- type SG<G_Source> = readonly ['backtick', null] | readonly ['quote', null];
810
+ type SG<M_Source> = readonly ['backtick', null] | readonly ['quote', null];
811
811
  }
812
- type delimiter<G_Source> = _i_core._T_State_Group<G_Source, readonly ['backtick', null] | readonly ['quote', null]>;
813
- type value<G_Source> = string;
812
+ type delimiter<M_Source> = _i_core._T_State_Group<M_Source, readonly ['backtick', null] | readonly ['quote', null]>;
813
+ type value<M_Source> = string;
814
814
  }
815
- type _string<G_Source> = {
816
- readonly 'delimiter': _i_core._T_State_Group<G_Source, readonly ['backtick', null] | readonly ['quote', null]>;
815
+ type _string<M_Source> = {
816
+ readonly 'delimiter': _i_core._T_State_Group<M_Source, readonly ['backtick', null] | readonly ['quote', null]>;
817
817
  readonly 'value': string;
818
818
  };
819
819
  namespace tagged_union {
820
- type _case<G_Source> = string;
820
+ type _case<M_Source> = string;
821
821
  namespace value {
822
822
  }
823
- type value<G_Source> = _T_Initialization<G_Source>;
823
+ type value<M_Source> = _T_Initialization<M_Source>;
824
824
  }
825
- type tagged_union<G_Source> = {
825
+ type tagged_union<M_Source> = {
826
826
  readonly 'case': string;
827
- readonly 'value': _T_Initialization<G_Source>;
827
+ readonly 'value': _T_Initialization<M_Source>;
828
828
  };
829
829
  }
830
- type SG<G_Source> = readonly ['array', _i_core._T_List<G_Source, _T_Initialization<G_Source>>] | readonly [
830
+ type SG<M_Source> = readonly ['array', _i_core._T_List<M_Source, _T_Initialization<M_Source>>] | readonly [
831
831
  'boolean',
832
- _i_core._T_State_Group<G_Source, readonly ['false', null] | readonly ['true', null]>
833
- ] | readonly ['dictionary', _i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>] | readonly [
832
+ _i_core._T_State_Group<M_Source, readonly ['false', null] | readonly ['true', null]>
833
+ ] | readonly ['dictionary', _i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>] | readonly [
834
834
  'function',
835
835
  {
836
- readonly 'initialization': _T_Initialization<G_Source>;
836
+ readonly 'initialization': _T_Initialization<M_Source>;
837
837
  readonly 'temp has parameters': boolean;
838
- readonly 'temp resulting node': _pt.Optional_Value<_i_imports_interface._T_Type<G_Source>>;
838
+ readonly 'temp resulting node': _pt.Optional_Value<_i_imports_interface._T_Type<M_Source>>;
839
839
  }
840
- ] | readonly ['group', _i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>] | readonly ['null', null] | readonly [
840
+ ] | readonly ['group', _i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>] | readonly ['null', null] | readonly [
841
841
  'number',
842
- _i_core._T_State_Group<G_Source, readonly ['floting point', number] | readonly ['integer', number] | readonly ['signed integer', number]>
842
+ _i_core._T_State_Group<M_Source, readonly ['floting point', number] | readonly ['integer', number] | readonly ['signed integer', number]>
843
843
  ] | readonly [
844
844
  'optional',
845
- _i_core._T_State_Group<G_Source, readonly ['not set', null] | readonly ['set', _T_Initialization<G_Source>]>
845
+ _i_core._T_State_Group<M_Source, readonly ['not set', null] | readonly ['set', _T_Initialization<M_Source>]>
846
846
  ] | readonly [
847
847
  'string',
848
848
  {
849
- readonly 'delimiter': _i_core._T_State_Group<G_Source, readonly ['backtick', null] | readonly ['quote', null]>;
849
+ readonly 'delimiter': _i_core._T_State_Group<M_Source, readonly ['backtick', null] | readonly ['quote', null]>;
850
850
  readonly 'value': string;
851
851
  }
852
852
  ] | readonly [
853
853
  'tagged union',
854
854
  {
855
855
  readonly 'case': string;
856
- readonly 'value': _T_Initialization<G_Source>;
856
+ readonly 'value': _T_Initialization<M_Source>;
857
857
  }
858
858
  ];
859
859
  }
860
860
  export declare namespace _T_Module {
861
861
  namespace type_imports {
862
862
  }
863
- type type_imports<G_Source> = _i_imports_interface._T_Imports<G_Source>;
863
+ type type_imports<M_Source> = _i_imports_interface._T_Imports<M_Source>;
864
864
  namespace variable_imports {
865
865
  namespace D {
866
866
  namespace tail {
867
- type L<G_Source> = string;
867
+ type L<M_Source> = string;
868
868
  }
869
- type tail<G_Source> = _i_core._T_List<G_Source, string>;
869
+ type tail<M_Source> = _i_core._T_List<M_Source, string>;
870
870
  namespace _type {
871
871
  namespace SG {
872
872
  namespace ancestor {
873
- type dependency<G_Source> = string;
874
- type number_of_steps<G_Source> = number;
873
+ type dependency<M_Source> = string;
874
+ type number_of_steps<M_Source> = number;
875
875
  }
876
- type ancestor<G_Source> = {
876
+ type ancestor<M_Source> = {
877
877
  readonly 'dependency': string;
878
878
  readonly 'number of steps': number;
879
879
  };
880
- type external<G_Source> = string;
881
- type sibling<G_Source> = string;
880
+ type external<M_Source> = string;
881
+ type sibling<M_Source> = string;
882
882
  }
883
- type SG<G_Source> = readonly [
883
+ type SG<M_Source> = readonly [
884
884
  'ancestor',
885
885
  {
886
886
  readonly 'dependency': string;
@@ -888,7 +888,7 @@ export declare namespace _T_Module {
888
888
  }
889
889
  ] | readonly ['external', string] | readonly ['sibling', string];
890
890
  }
891
- type _type<G_Source> = _i_core._T_State_Group<G_Source, readonly [
891
+ type _type<M_Source> = _i_core._T_State_Group<M_Source, readonly [
892
892
  'ancestor',
893
893
  {
894
894
  readonly 'dependency': string;
@@ -896,9 +896,9 @@ export declare namespace _T_Module {
896
896
  }
897
897
  ] | readonly ['external', string] | readonly ['sibling', string]>;
898
898
  }
899
- type D<G_Source> = {
900
- readonly 'tail': _i_core._T_List<G_Source, string>;
901
- readonly 'type': _i_core._T_State_Group<G_Source, readonly [
899
+ type D<M_Source> = {
900
+ readonly 'tail': _i_core._T_List<M_Source, string>;
901
+ readonly 'type': _i_core._T_State_Group<M_Source, readonly [
902
902
  'ancestor',
903
903
  {
904
904
  readonly 'dependency': string;
@@ -907,9 +907,9 @@ export declare namespace _T_Module {
907
907
  ] | readonly ['external', string] | readonly ['sibling', string]>;
908
908
  };
909
909
  }
910
- type variable_imports<G_Source> = _i_core._T_Dictionary<G_Source, {
911
- readonly 'tail': _i_core._T_List<G_Source, string>;
912
- readonly 'type': _i_core._T_State_Group<G_Source, readonly [
910
+ type variable_imports<M_Source> = _i_core._T_Dictionary<M_Source, {
911
+ readonly 'tail': _i_core._T_List<M_Source, string>;
912
+ readonly 'type': _i_core._T_State_Group<M_Source, readonly [
913
913
  'ancestor',
914
914
  {
915
915
  readonly 'dependency': string;
@@ -919,84 +919,84 @@ export declare namespace _T_Module {
919
919
  }>;
920
920
  namespace variables {
921
921
  }
922
- type variables<G_Source> = _T_Variables<G_Source>;
922
+ type variables<M_Source> = _T_Variables<M_Source>;
923
923
  }
924
924
  export declare namespace _T_Module_Set {
925
925
  namespace D {
926
926
  namespace SG {
927
927
  namespace _module {
928
928
  }
929
- type _module<G_Source> = _T_Module<G_Source>;
929
+ type _module<M_Source> = _T_Module<M_Source>;
930
930
  namespace _set {
931
931
  }
932
- type _set<G_Source> = _T_Module_Set<G_Source>;
932
+ type _set<M_Source> = _T_Module_Set<M_Source>;
933
933
  }
934
- type SG<G_Source> = readonly ['module', _T_Module<G_Source>] | readonly ['set', _T_Module_Set<G_Source>];
934
+ type SG<M_Source> = readonly ['module', _T_Module<M_Source>] | readonly ['set', _T_Module_Set<M_Source>];
935
935
  }
936
- type D<G_Source> = _i_core._T_State_Group<G_Source, readonly ['module', _T_Module<G_Source>] | readonly ['set', _T_Module_Set<G_Source>]>;
936
+ type D<M_Source> = _i_core._T_State_Group<M_Source, readonly ['module', _T_Module<M_Source>] | readonly ['set', _T_Module_Set<M_Source>]>;
937
937
  }
938
938
  export declare namespace _T_Selection {
939
939
  namespace start {
940
940
  namespace SG {
941
- type abort<G_Source> = null;
942
- type argument<G_Source> = string;
941
+ type abort<M_Source> = null;
942
+ type argument<M_Source> = string;
943
943
  namespace call {
944
944
  namespace _arguments {
945
945
  namespace O {
946
946
  namespace D {
947
947
  }
948
- type D<G_Source> = _T_Initialization<G_Source>;
948
+ type D<M_Source> = _T_Initialization<M_Source>;
949
949
  }
950
- type O<G_Source> = _i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>;
950
+ type O<M_Source> = _i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>;
951
951
  }
952
- type _arguments<G_Source> = _pt.Optional_Value<_i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>>;
952
+ type _arguments<M_Source> = _pt.Optional_Value<_i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>>;
953
953
  namespace context {
954
954
  }
955
- type context<G_Source> = _T_Selection<G_Source>;
955
+ type context<M_Source> = _T_Selection<M_Source>;
956
956
  namespace source {
957
957
  }
958
- type source<G_Source> = _T_Selection<G_Source>;
958
+ type source<M_Source> = _T_Selection<M_Source>;
959
959
  }
960
- type call<G_Source> = {
961
- readonly 'arguments': _pt.Optional_Value<_i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>>;
962
- readonly 'context': _T_Selection<G_Source>;
963
- readonly 'source': _T_Selection<G_Source>;
960
+ type call<M_Source> = {
961
+ readonly 'arguments': _pt.Optional_Value<_i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>>;
962
+ readonly 'context': _T_Selection<M_Source>;
963
+ readonly 'source': _T_Selection<M_Source>;
964
964
  };
965
- type context<G_Source> = null;
966
- type implement_me<G_Source> = null;
965
+ type context<M_Source> = null;
966
+ type implement_me<M_Source> = null;
967
967
  namespace imported_variable {
968
- type _import<G_Source> = string;
969
- type variable<G_Source> = string;
968
+ type _import<M_Source> = string;
969
+ type variable<M_Source> = string;
970
970
  }
971
- type imported_variable<G_Source> = {
971
+ type imported_variable<M_Source> = {
972
972
  readonly 'import': string;
973
973
  readonly 'variable': string;
974
974
  };
975
- type parameter<G_Source> = string;
975
+ type parameter<M_Source> = string;
976
976
  namespace transform_optional_value {
977
977
  namespace if_not_set {
978
978
  }
979
- type if_not_set<G_Source> = _T_Selection<G_Source>;
979
+ type if_not_set<M_Source> = _T_Selection<M_Source>;
980
980
  namespace if_set {
981
981
  }
982
- type if_set<G_Source> = _T_Selection<G_Source>;
982
+ type if_set<M_Source> = _T_Selection<M_Source>;
983
983
  namespace source {
984
984
  }
985
- type source<G_Source> = _T_Selection<G_Source>;
985
+ type source<M_Source> = _T_Selection<M_Source>;
986
986
  }
987
- type transform_optional_value<G_Source> = {
988
- readonly 'if not set': _T_Selection<G_Source>;
989
- readonly 'if set': _T_Selection<G_Source>;
990
- readonly 'source': _T_Selection<G_Source>;
987
+ type transform_optional_value<M_Source> = {
988
+ readonly 'if not set': _T_Selection<M_Source>;
989
+ readonly 'if set': _T_Selection<M_Source>;
990
+ readonly 'source': _T_Selection<M_Source>;
991
991
  };
992
- type variable<G_Source> = string;
992
+ type variable<M_Source> = string;
993
993
  }
994
- type SG<G_Source> = readonly ['abort', null] | readonly ['argument', string] | readonly [
994
+ type SG<M_Source> = readonly ['abort', null] | readonly ['argument', string] | readonly [
995
995
  'call',
996
996
  {
997
- readonly 'arguments': _pt.Optional_Value<_i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>>;
998
- readonly 'context': _T_Selection<G_Source>;
999
- readonly 'source': _T_Selection<G_Source>;
997
+ readonly 'arguments': _pt.Optional_Value<_i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>>;
998
+ readonly 'context': _T_Selection<M_Source>;
999
+ readonly 'source': _T_Selection<M_Source>;
1000
1000
  }
1001
1001
  ] | readonly ['context', null] | readonly ['implement me', null] | readonly [
1002
1002
  'imported variable',
@@ -1007,18 +1007,18 @@ export declare namespace _T_Selection {
1007
1007
  ] | readonly ['parameter', string] | readonly [
1008
1008
  'transform optional value',
1009
1009
  {
1010
- readonly 'if not set': _T_Selection<G_Source>;
1011
- readonly 'if set': _T_Selection<G_Source>;
1012
- readonly 'source': _T_Selection<G_Source>;
1010
+ readonly 'if not set': _T_Selection<M_Source>;
1011
+ readonly 'if set': _T_Selection<M_Source>;
1012
+ readonly 'source': _T_Selection<M_Source>;
1013
1013
  }
1014
1014
  ] | readonly ['variable', string];
1015
1015
  }
1016
- type start<G_Source> = _i_core._T_State_Group<G_Source, readonly ['abort', null] | readonly ['argument', string] | readonly [
1016
+ type start<M_Source> = _i_core._T_State_Group<M_Source, readonly ['abort', null] | readonly ['argument', string] | readonly [
1017
1017
  'call',
1018
1018
  {
1019
- readonly 'arguments': _pt.Optional_Value<_i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>>;
1020
- readonly 'context': _T_Selection<G_Source>;
1021
- readonly 'source': _T_Selection<G_Source>;
1019
+ readonly 'arguments': _pt.Optional_Value<_i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>>;
1020
+ readonly 'context': _T_Selection<M_Source>;
1021
+ readonly 'source': _T_Selection<M_Source>;
1022
1022
  }
1023
1023
  ] | readonly ['context', null] | readonly ['implement me', null] | readonly [
1024
1024
  'imported variable',
@@ -1029,34 +1029,34 @@ export declare namespace _T_Selection {
1029
1029
  ] | readonly ['parameter', string] | readonly [
1030
1030
  'transform optional value',
1031
1031
  {
1032
- readonly 'if not set': _T_Selection<G_Source>;
1033
- readonly 'if set': _T_Selection<G_Source>;
1034
- readonly 'source': _T_Selection<G_Source>;
1032
+ readonly 'if not set': _T_Selection<M_Source>;
1033
+ readonly 'if set': _T_Selection<M_Source>;
1034
+ readonly 'source': _T_Selection<M_Source>;
1035
1035
  }
1036
1036
  ] | readonly ['variable', string]>;
1037
1037
  namespace tail {
1038
- type L<G_Source> = string;
1038
+ type L<M_Source> = string;
1039
1039
  }
1040
- type tail<G_Source> = _i_core._T_List<G_Source, string>;
1040
+ type tail<M_Source> = _i_core._T_List<M_Source, string>;
1041
1041
  }
1042
1042
  export declare namespace _T_Type_Parameters {
1043
- type D<G_Source> = null;
1043
+ type D<M_Source> = null;
1044
1044
  }
1045
1045
  export declare namespace _T_Variables {
1046
1046
  namespace D {
1047
1047
  namespace initialization {
1048
1048
  }
1049
- type initialization<G_Source> = _T_Initialization<G_Source>;
1049
+ type initialization<M_Source> = _T_Initialization<M_Source>;
1050
1050
  namespace _type {
1051
1051
  namespace O {
1052
1052
  }
1053
- type O<G_Source> = _i_imports_interface._T_Type<G_Source>;
1053
+ type O<M_Source> = _i_imports_interface._T_Type<M_Source>;
1054
1054
  }
1055
- type _type<G_Source> = _pt.Optional_Value<_i_imports_interface._T_Type<G_Source>>;
1055
+ type _type<M_Source> = _pt.Optional_Value<_i_imports_interface._T_Type<M_Source>>;
1056
1056
  }
1057
- type D<G_Source> = {
1058
- readonly 'initialization': _T_Initialization<G_Source>;
1059
- readonly 'type': _pt.Optional_Value<_i_imports_interface._T_Type<G_Source>>;
1057
+ type D<M_Source> = {
1058
+ readonly 'initialization': _T_Initialization<M_Source>;
1059
+ readonly 'type': _pt.Optional_Value<_i_imports_interface._T_Type<M_Source>>;
1060
1060
  };
1061
1061
  }
1062
1062
  export declare namespace Initialization {
@@ -1064,122 +1064,122 @@ export declare namespace Initialization {
1064
1064
  namespace block {
1065
1065
  namespace initialization {
1066
1066
  }
1067
- type initialization<G_Source> = _T_Initialization<G_Source>;
1067
+ type initialization<M_Source> = _T_Initialization<M_Source>;
1068
1068
  namespace temp_ordered_variables {
1069
1069
  namespace L {
1070
1070
  namespace initialization {
1071
1071
  }
1072
- type initialization<G_Source> = _T_Initialization<G_Source>;
1073
- type name<G_Source> = string;
1072
+ type initialization<M_Source> = _T_Initialization<M_Source>;
1073
+ type name<M_Source> = string;
1074
1074
  namespace _type {
1075
1075
  namespace O {
1076
1076
  }
1077
- type O<G_Source> = _i_imports_interface._T_Type<G_Source>;
1077
+ type O<M_Source> = _i_imports_interface._T_Type<M_Source>;
1078
1078
  }
1079
- type _type<G_Source> = _pt.Optional_Value<_i_imports_interface._T_Type<G_Source>>;
1079
+ type _type<M_Source> = _pt.Optional_Value<_i_imports_interface._T_Type<M_Source>>;
1080
1080
  }
1081
- type L<G_Source> = {
1082
- readonly 'initialization': _T_Initialization<G_Source>;
1081
+ type L<M_Source> = {
1082
+ readonly 'initialization': _T_Initialization<M_Source>;
1083
1083
  readonly 'name': string;
1084
- readonly 'type': _pt.Optional_Value<_i_imports_interface._T_Type<G_Source>>;
1084
+ readonly 'type': _pt.Optional_Value<_i_imports_interface._T_Type<M_Source>>;
1085
1085
  };
1086
1086
  }
1087
- type temp_ordered_variables<G_Source> = _i_core._T_List<G_Source, {
1088
- readonly 'initialization': _T_Initialization<G_Source>;
1087
+ type temp_ordered_variables<M_Source> = _i_core._T_List<M_Source, {
1088
+ readonly 'initialization': _T_Initialization<M_Source>;
1089
1089
  readonly 'name': string;
1090
- readonly 'type': _pt.Optional_Value<_i_imports_interface._T_Type<G_Source>>;
1090
+ readonly 'type': _pt.Optional_Value<_i_imports_interface._T_Type<M_Source>>;
1091
1091
  }>;
1092
1092
  namespace variables {
1093
1093
  }
1094
- type variables<G_Source> = _T_Variables<G_Source>;
1094
+ type variables<M_Source> = _T_Variables<M_Source>;
1095
1095
  }
1096
- type block<G_Source> = {
1097
- readonly 'initialization': _T_Initialization<G_Source>;
1098
- readonly 'temp ordered variables': _i_core._T_List<G_Source, {
1099
- readonly 'initialization': _T_Initialization<G_Source>;
1096
+ type block<M_Source> = {
1097
+ readonly 'initialization': _T_Initialization<M_Source>;
1098
+ readonly 'temp ordered variables': _i_core._T_List<M_Source, {
1099
+ readonly 'initialization': _T_Initialization<M_Source>;
1100
1100
  readonly 'name': string;
1101
- readonly 'type': _pt.Optional_Value<_i_imports_interface._T_Type<G_Source>>;
1101
+ readonly 'type': _pt.Optional_Value<_i_imports_interface._T_Type<M_Source>>;
1102
1102
  }>;
1103
- readonly 'variables': _T_Variables<G_Source>;
1103
+ readonly 'variables': _T_Variables<M_Source>;
1104
1104
  };
1105
1105
  namespace change_context {
1106
1106
  namespace initialization {
1107
1107
  }
1108
- type initialization<G_Source> = _T_Initialization<G_Source>;
1108
+ type initialization<M_Source> = _T_Initialization<M_Source>;
1109
1109
  namespace new_context {
1110
1110
  }
1111
- type new_context<G_Source> = _T_Selection<G_Source>;
1111
+ type new_context<M_Source> = _T_Selection<M_Source>;
1112
1112
  }
1113
- type change_context<G_Source> = {
1114
- readonly 'initialization': _T_Initialization<G_Source>;
1115
- readonly 'new context': _T_Selection<G_Source>;
1113
+ type change_context<M_Source> = {
1114
+ readonly 'initialization': _T_Initialization<M_Source>;
1115
+ readonly 'new context': _T_Selection<M_Source>;
1116
1116
  };
1117
1117
  namespace literal {
1118
1118
  namespace value {
1119
1119
  }
1120
- type value<G_Source> = _T_Literal<G_Source>;
1120
+ type value<M_Source> = _T_Literal<M_Source>;
1121
1121
  }
1122
- type literal<G_Source> = {
1123
- readonly 'value': _T_Literal<G_Source>;
1122
+ type literal<M_Source> = {
1123
+ readonly 'value': _T_Literal<M_Source>;
1124
1124
  };
1125
1125
  namespace selection {
1126
1126
  }
1127
- type selection<G_Source> = _T_Selection<G_Source>;
1127
+ type selection<M_Source> = _T_Selection<M_Source>;
1128
1128
  namespace transformation {
1129
1129
  namespace source {
1130
1130
  }
1131
- type source<G_Source> = _T_Selection<G_Source>;
1131
+ type source<M_Source> = _T_Selection<M_Source>;
1132
1132
  namespace _type {
1133
1133
  namespace SG {
1134
1134
  namespace array {
1135
1135
  namespace SG {
1136
1136
  namespace map {
1137
1137
  }
1138
- type map<G_Source> = _T_Initialization<G_Source>;
1138
+ type map<M_Source> = _T_Initialization<M_Source>;
1139
1139
  }
1140
- type SG<G_Source> = readonly ['map', _T_Initialization<G_Source>];
1140
+ type SG<M_Source> = readonly ['map', _T_Initialization<M_Source>];
1141
1141
  }
1142
- type array<G_Source> = _i_core._T_State_Group<G_Source, readonly ['map', _T_Initialization<G_Source>]>;
1142
+ type array<M_Source> = _i_core._T_State_Group<M_Source, readonly ['map', _T_Initialization<M_Source>]>;
1143
1143
  namespace _boolean {
1144
1144
  namespace SG {
1145
- type not<G_Source> = null;
1145
+ type not<M_Source> = null;
1146
1146
  namespace transform {
1147
1147
  namespace if_false {
1148
1148
  }
1149
- type if_false<G_Source> = _T_Initialization<G_Source>;
1149
+ type if_false<M_Source> = _T_Initialization<M_Source>;
1150
1150
  namespace if_true {
1151
1151
  }
1152
- type if_true<G_Source> = _T_Initialization<G_Source>;
1152
+ type if_true<M_Source> = _T_Initialization<M_Source>;
1153
1153
  }
1154
- type transform<G_Source> = {
1155
- readonly 'if false': _T_Initialization<G_Source>;
1156
- readonly 'if true': _T_Initialization<G_Source>;
1154
+ type transform<M_Source> = {
1155
+ readonly 'if false': _T_Initialization<M_Source>;
1156
+ readonly 'if true': _T_Initialization<M_Source>;
1157
1157
  };
1158
1158
  }
1159
- type SG<G_Source> = readonly ['not', null] | readonly [
1159
+ type SG<M_Source> = readonly ['not', null] | readonly [
1160
1160
  'transform',
1161
1161
  {
1162
- readonly 'if false': _T_Initialization<G_Source>;
1163
- readonly 'if true': _T_Initialization<G_Source>;
1162
+ readonly 'if false': _T_Initialization<M_Source>;
1163
+ readonly 'if true': _T_Initialization<M_Source>;
1164
1164
  }
1165
1165
  ];
1166
1166
  }
1167
- type _boolean<G_Source> = _i_core._T_State_Group<G_Source, readonly ['not', null] | readonly [
1167
+ type _boolean<M_Source> = _i_core._T_State_Group<M_Source, readonly ['not', null] | readonly [
1168
1168
  'transform',
1169
1169
  {
1170
- readonly 'if false': _T_Initialization<G_Source>;
1171
- readonly 'if true': _T_Initialization<G_Source>;
1170
+ readonly 'if false': _T_Initialization<M_Source>;
1171
+ readonly 'if true': _T_Initialization<M_Source>;
1172
1172
  }
1173
1173
  ]>;
1174
1174
  namespace dictionary {
1175
1175
  namespace SG {
1176
1176
  namespace map {
1177
1177
  }
1178
- type map<G_Source> = _T_Initialization<G_Source>;
1178
+ type map<M_Source> = _T_Initialization<M_Source>;
1179
1179
  }
1180
- type SG<G_Source> = readonly ['map', _T_Initialization<G_Source>];
1180
+ type SG<M_Source> = readonly ['map', _T_Initialization<M_Source>];
1181
1181
  }
1182
- type dictionary<G_Source> = _i_core._T_State_Group<G_Source, readonly ['map', _T_Initialization<G_Source>]>;
1182
+ type dictionary<M_Source> = _i_core._T_State_Group<M_Source, readonly ['map', _T_Initialization<M_Source>]>;
1183
1183
  namespace _function {
1184
1184
  namespace SG {
1185
1185
  namespace call {
@@ -1187,75 +1187,75 @@ export declare namespace Initialization {
1187
1187
  namespace O {
1188
1188
  namespace D {
1189
1189
  }
1190
- type D<G_Source> = _T_Initialization<G_Source>;
1190
+ type D<M_Source> = _T_Initialization<M_Source>;
1191
1191
  }
1192
- type O<G_Source> = _i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>;
1192
+ type O<M_Source> = _i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>;
1193
1193
  }
1194
- type _arguments<G_Source> = _pt.Optional_Value<_i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>>;
1194
+ type _arguments<M_Source> = _pt.Optional_Value<_i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>>;
1195
1195
  namespace context {
1196
1196
  }
1197
- type context<G_Source> = _T_Initialization<G_Source>;
1197
+ type context<M_Source> = _T_Initialization<M_Source>;
1198
1198
  }
1199
- type call<G_Source> = {
1200
- readonly 'arguments': _pt.Optional_Value<_i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>>;
1201
- readonly 'context': _T_Initialization<G_Source>;
1199
+ type call<M_Source> = {
1200
+ readonly 'arguments': _pt.Optional_Value<_i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>>;
1201
+ readonly 'context': _T_Initialization<M_Source>;
1202
1202
  };
1203
1203
  }
1204
- type SG<G_Source> = readonly [
1204
+ type SG<M_Source> = readonly [
1205
1205
  'call',
1206
1206
  {
1207
- readonly 'arguments': _pt.Optional_Value<_i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>>;
1208
- readonly 'context': _T_Initialization<G_Source>;
1207
+ readonly 'arguments': _pt.Optional_Value<_i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>>;
1208
+ readonly 'context': _T_Initialization<M_Source>;
1209
1209
  }
1210
1210
  ];
1211
1211
  }
1212
- type _function<G_Source> = _i_core._T_State_Group<G_Source, readonly [
1212
+ type _function<M_Source> = _i_core._T_State_Group<M_Source, readonly [
1213
1213
  'call',
1214
1214
  {
1215
- readonly 'arguments': _pt.Optional_Value<_i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>>;
1216
- readonly 'context': _T_Initialization<G_Source>;
1215
+ readonly 'arguments': _pt.Optional_Value<_i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>>;
1216
+ readonly 'context': _T_Initialization<M_Source>;
1217
1217
  }
1218
1218
  ]>;
1219
1219
  namespace optional {
1220
1220
  namespace SG {
1221
1221
  namespace map {
1222
1222
  }
1223
- type map<G_Source> = _T_Initialization<G_Source>;
1223
+ type map<M_Source> = _T_Initialization<M_Source>;
1224
1224
  namespace transform {
1225
1225
  namespace if_not_set {
1226
1226
  }
1227
- type if_not_set<G_Source> = _T_Initialization<G_Source>;
1227
+ type if_not_set<M_Source> = _T_Initialization<M_Source>;
1228
1228
  namespace if_set {
1229
1229
  }
1230
- type if_set<G_Source> = _T_Initialization<G_Source>;
1230
+ type if_set<M_Source> = _T_Initialization<M_Source>;
1231
1231
  namespace temp_resulting_node {
1232
1232
  namespace O {
1233
1233
  }
1234
- type O<G_Source> = _i_imports_interface._T_Type<G_Source>;
1234
+ type O<M_Source> = _i_imports_interface._T_Type<M_Source>;
1235
1235
  }
1236
- type temp_resulting_node<G_Source> = _pt.Optional_Value<_i_imports_interface._T_Type<G_Source>>;
1236
+ type temp_resulting_node<M_Source> = _pt.Optional_Value<_i_imports_interface._T_Type<M_Source>>;
1237
1237
  }
1238
- type transform<G_Source> = {
1239
- readonly 'if not set': _T_Initialization<G_Source>;
1240
- readonly 'if set': _T_Initialization<G_Source>;
1241
- readonly 'temp resulting node': _pt.Optional_Value<_i_imports_interface._T_Type<G_Source>>;
1238
+ type transform<M_Source> = {
1239
+ readonly 'if not set': _T_Initialization<M_Source>;
1240
+ readonly 'if set': _T_Initialization<M_Source>;
1241
+ readonly 'temp resulting node': _pt.Optional_Value<_i_imports_interface._T_Type<M_Source>>;
1242
1242
  };
1243
1243
  }
1244
- type SG<G_Source> = readonly ['map', _T_Initialization<G_Source>] | readonly [
1244
+ type SG<M_Source> = readonly ['map', _T_Initialization<M_Source>] | readonly [
1245
1245
  'transform',
1246
1246
  {
1247
- readonly 'if not set': _T_Initialization<G_Source>;
1248
- readonly 'if set': _T_Initialization<G_Source>;
1249
- readonly 'temp resulting node': _pt.Optional_Value<_i_imports_interface._T_Type<G_Source>>;
1247
+ readonly 'if not set': _T_Initialization<M_Source>;
1248
+ readonly 'if set': _T_Initialization<M_Source>;
1249
+ readonly 'temp resulting node': _pt.Optional_Value<_i_imports_interface._T_Type<M_Source>>;
1250
1250
  }
1251
1251
  ];
1252
1252
  }
1253
- type optional<G_Source> = _i_core._T_State_Group<G_Source, readonly ['map', _T_Initialization<G_Source>] | readonly [
1253
+ type optional<M_Source> = _i_core._T_State_Group<M_Source, readonly ['map', _T_Initialization<M_Source>] | readonly [
1254
1254
  'transform',
1255
1255
  {
1256
- readonly 'if not set': _T_Initialization<G_Source>;
1257
- readonly 'if set': _T_Initialization<G_Source>;
1258
- readonly 'temp resulting node': _pt.Optional_Value<_i_imports_interface._T_Type<G_Source>>;
1256
+ readonly 'if not set': _T_Initialization<M_Source>;
1257
+ readonly 'if set': _T_Initialization<M_Source>;
1258
+ readonly 'temp resulting node': _pt.Optional_Value<_i_imports_interface._T_Type<M_Source>>;
1259
1259
  }
1260
1260
  ]>;
1261
1261
  namespace tagged_union {
@@ -1264,282 +1264,282 @@ export declare namespace Initialization {
1264
1264
  namespace temp_resulting_node {
1265
1265
  namespace O {
1266
1266
  }
1267
- type O<G_Source> = _i_imports_interface._T_Type<G_Source>;
1267
+ type O<M_Source> = _i_imports_interface._T_Type<M_Source>;
1268
1268
  }
1269
- type temp_resulting_node<G_Source> = _pt.Optional_Value<_i_imports_interface._T_Type<G_Source>>;
1269
+ type temp_resulting_node<M_Source> = _pt.Optional_Value<_i_imports_interface._T_Type<M_Source>>;
1270
1270
  namespace _type {
1271
1271
  namespace SG {
1272
1272
  namespace full {
1273
1273
  namespace cases {
1274
1274
  namespace D {
1275
1275
  }
1276
- type D<G_Source> = _T_Initialization<G_Source>;
1276
+ type D<M_Source> = _T_Initialization<M_Source>;
1277
1277
  }
1278
- type cases<G_Source> = _i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>;
1278
+ type cases<M_Source> = _i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>;
1279
1279
  }
1280
- type full<G_Source> = {
1281
- readonly 'cases': _i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>;
1280
+ type full<M_Source> = {
1281
+ readonly 'cases': _i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>;
1282
1282
  };
1283
1283
  namespace partial {
1284
1284
  namespace cases {
1285
1285
  namespace D {
1286
1286
  }
1287
- type D<G_Source> = _T_Initialization<G_Source>;
1287
+ type D<M_Source> = _T_Initialization<M_Source>;
1288
1288
  }
1289
- type cases<G_Source> = _i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>;
1289
+ type cases<M_Source> = _i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>;
1290
1290
  namespace _default {
1291
1291
  }
1292
- type _default<G_Source> = _T_Initialization<G_Source>;
1292
+ type _default<M_Source> = _T_Initialization<M_Source>;
1293
1293
  }
1294
- type partial<G_Source> = {
1295
- readonly 'cases': _i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>;
1296
- readonly 'default': _T_Initialization<G_Source>;
1294
+ type partial<M_Source> = {
1295
+ readonly 'cases': _i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>;
1296
+ readonly 'default': _T_Initialization<M_Source>;
1297
1297
  };
1298
1298
  }
1299
- type SG<G_Source> = readonly [
1299
+ type SG<M_Source> = readonly [
1300
1300
  'full',
1301
1301
  {
1302
- readonly 'cases': _i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>;
1302
+ readonly 'cases': _i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>;
1303
1303
  }
1304
1304
  ] | readonly [
1305
1305
  'partial',
1306
1306
  {
1307
- readonly 'cases': _i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>;
1308
- readonly 'default': _T_Initialization<G_Source>;
1307
+ readonly 'cases': _i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>;
1308
+ readonly 'default': _T_Initialization<M_Source>;
1309
1309
  }
1310
1310
  ];
1311
1311
  }
1312
- type _type<G_Source> = _i_core._T_State_Group<G_Source, readonly [
1312
+ type _type<M_Source> = _i_core._T_State_Group<M_Source, readonly [
1313
1313
  'full',
1314
1314
  {
1315
- readonly 'cases': _i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>;
1315
+ readonly 'cases': _i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>;
1316
1316
  }
1317
1317
  ] | readonly [
1318
1318
  'partial',
1319
1319
  {
1320
- readonly 'cases': _i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>;
1321
- readonly 'default': _T_Initialization<G_Source>;
1320
+ readonly 'cases': _i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>;
1321
+ readonly 'default': _T_Initialization<M_Source>;
1322
1322
  }
1323
1323
  ]>;
1324
1324
  }
1325
- type _switch<G_Source> = {
1326
- readonly 'temp resulting node': _pt.Optional_Value<_i_imports_interface._T_Type<G_Source>>;
1327
- readonly 'type': _i_core._T_State_Group<G_Source, readonly [
1325
+ type _switch<M_Source> = {
1326
+ readonly 'temp resulting node': _pt.Optional_Value<_i_imports_interface._T_Type<M_Source>>;
1327
+ readonly 'type': _i_core._T_State_Group<M_Source, readonly [
1328
1328
  'full',
1329
1329
  {
1330
- readonly 'cases': _i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>;
1330
+ readonly 'cases': _i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>;
1331
1331
  }
1332
1332
  ] | readonly [
1333
1333
  'partial',
1334
1334
  {
1335
- readonly 'cases': _i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>;
1336
- readonly 'default': _T_Initialization<G_Source>;
1335
+ readonly 'cases': _i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>;
1336
+ readonly 'default': _T_Initialization<M_Source>;
1337
1337
  }
1338
1338
  ]>;
1339
1339
  };
1340
1340
  }
1341
- type SG<G_Source> = readonly [
1341
+ type SG<M_Source> = readonly [
1342
1342
  'switch',
1343
1343
  {
1344
- readonly 'temp resulting node': _pt.Optional_Value<_i_imports_interface._T_Type<G_Source>>;
1345
- readonly 'type': _i_core._T_State_Group<G_Source, readonly [
1344
+ readonly 'temp resulting node': _pt.Optional_Value<_i_imports_interface._T_Type<M_Source>>;
1345
+ readonly 'type': _i_core._T_State_Group<M_Source, readonly [
1346
1346
  'full',
1347
1347
  {
1348
- readonly 'cases': _i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>;
1348
+ readonly 'cases': _i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>;
1349
1349
  }
1350
1350
  ] | readonly [
1351
1351
  'partial',
1352
1352
  {
1353
- readonly 'cases': _i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>;
1354
- readonly 'default': _T_Initialization<G_Source>;
1353
+ readonly 'cases': _i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>;
1354
+ readonly 'default': _T_Initialization<M_Source>;
1355
1355
  }
1356
1356
  ]>;
1357
1357
  }
1358
1358
  ];
1359
1359
  }
1360
- type tagged_union<G_Source> = _i_core._T_State_Group<G_Source, readonly [
1360
+ type tagged_union<M_Source> = _i_core._T_State_Group<M_Source, readonly [
1361
1361
  'switch',
1362
1362
  {
1363
- readonly 'temp resulting node': _pt.Optional_Value<_i_imports_interface._T_Type<G_Source>>;
1364
- readonly 'type': _i_core._T_State_Group<G_Source, readonly [
1363
+ readonly 'temp resulting node': _pt.Optional_Value<_i_imports_interface._T_Type<M_Source>>;
1364
+ readonly 'type': _i_core._T_State_Group<M_Source, readonly [
1365
1365
  'full',
1366
1366
  {
1367
- readonly 'cases': _i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>;
1367
+ readonly 'cases': _i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>;
1368
1368
  }
1369
1369
  ] | readonly [
1370
1370
  'partial',
1371
1371
  {
1372
- readonly 'cases': _i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>;
1373
- readonly 'default': _T_Initialization<G_Source>;
1372
+ readonly 'cases': _i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>;
1373
+ readonly 'default': _T_Initialization<M_Source>;
1374
1374
  }
1375
1375
  ]>;
1376
1376
  }
1377
1377
  ]>;
1378
1378
  }
1379
- type SG<G_Source> = readonly [
1379
+ type SG<M_Source> = readonly [
1380
1380
  'array',
1381
- _i_core._T_State_Group<G_Source, readonly ['map', _T_Initialization<G_Source>]>
1381
+ _i_core._T_State_Group<M_Source, readonly ['map', _T_Initialization<M_Source>]>
1382
1382
  ] | readonly [
1383
1383
  'boolean',
1384
- _i_core._T_State_Group<G_Source, readonly ['not', null] | readonly [
1384
+ _i_core._T_State_Group<M_Source, readonly ['not', null] | readonly [
1385
1385
  'transform',
1386
1386
  {
1387
- readonly 'if false': _T_Initialization<G_Source>;
1388
- readonly 'if true': _T_Initialization<G_Source>;
1387
+ readonly 'if false': _T_Initialization<M_Source>;
1388
+ readonly 'if true': _T_Initialization<M_Source>;
1389
1389
  }
1390
1390
  ]>
1391
1391
  ] | readonly [
1392
1392
  'dictionary',
1393
- _i_core._T_State_Group<G_Source, readonly ['map', _T_Initialization<G_Source>]>
1393
+ _i_core._T_State_Group<M_Source, readonly ['map', _T_Initialization<M_Source>]>
1394
1394
  ] | readonly [
1395
1395
  'function',
1396
- _i_core._T_State_Group<G_Source, readonly [
1396
+ _i_core._T_State_Group<M_Source, readonly [
1397
1397
  'call',
1398
1398
  {
1399
- readonly 'arguments': _pt.Optional_Value<_i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>>;
1400
- readonly 'context': _T_Initialization<G_Source>;
1399
+ readonly 'arguments': _pt.Optional_Value<_i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>>;
1400
+ readonly 'context': _T_Initialization<M_Source>;
1401
1401
  }
1402
1402
  ]>
1403
1403
  ] | readonly [
1404
1404
  'optional',
1405
- _i_core._T_State_Group<G_Source, readonly ['map', _T_Initialization<G_Source>] | readonly [
1405
+ _i_core._T_State_Group<M_Source, readonly ['map', _T_Initialization<M_Source>] | readonly [
1406
1406
  'transform',
1407
1407
  {
1408
- readonly 'if not set': _T_Initialization<G_Source>;
1409
- readonly 'if set': _T_Initialization<G_Source>;
1410
- readonly 'temp resulting node': _pt.Optional_Value<_i_imports_interface._T_Type<G_Source>>;
1408
+ readonly 'if not set': _T_Initialization<M_Source>;
1409
+ readonly 'if set': _T_Initialization<M_Source>;
1410
+ readonly 'temp resulting node': _pt.Optional_Value<_i_imports_interface._T_Type<M_Source>>;
1411
1411
  }
1412
1412
  ]>
1413
1413
  ] | readonly [
1414
1414
  'tagged union',
1415
- _i_core._T_State_Group<G_Source, readonly [
1415
+ _i_core._T_State_Group<M_Source, readonly [
1416
1416
  'switch',
1417
1417
  {
1418
- readonly 'temp resulting node': _pt.Optional_Value<_i_imports_interface._T_Type<G_Source>>;
1419
- readonly 'type': _i_core._T_State_Group<G_Source, readonly [
1418
+ readonly 'temp resulting node': _pt.Optional_Value<_i_imports_interface._T_Type<M_Source>>;
1419
+ readonly 'type': _i_core._T_State_Group<M_Source, readonly [
1420
1420
  'full',
1421
1421
  {
1422
- readonly 'cases': _i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>;
1422
+ readonly 'cases': _i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>;
1423
1423
  }
1424
1424
  ] | readonly [
1425
1425
  'partial',
1426
1426
  {
1427
- readonly 'cases': _i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>;
1428
- readonly 'default': _T_Initialization<G_Source>;
1427
+ readonly 'cases': _i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>;
1428
+ readonly 'default': _T_Initialization<M_Source>;
1429
1429
  }
1430
1430
  ]>;
1431
1431
  }
1432
1432
  ]>
1433
1433
  ];
1434
1434
  }
1435
- type _type<G_Source> = _i_core._T_State_Group<G_Source, readonly [
1435
+ type _type<M_Source> = _i_core._T_State_Group<M_Source, readonly [
1436
1436
  'array',
1437
- _i_core._T_State_Group<G_Source, readonly ['map', _T_Initialization<G_Source>]>
1437
+ _i_core._T_State_Group<M_Source, readonly ['map', _T_Initialization<M_Source>]>
1438
1438
  ] | readonly [
1439
1439
  'boolean',
1440
- _i_core._T_State_Group<G_Source, readonly ['not', null] | readonly [
1440
+ _i_core._T_State_Group<M_Source, readonly ['not', null] | readonly [
1441
1441
  'transform',
1442
1442
  {
1443
- readonly 'if false': _T_Initialization<G_Source>;
1444
- readonly 'if true': _T_Initialization<G_Source>;
1443
+ readonly 'if false': _T_Initialization<M_Source>;
1444
+ readonly 'if true': _T_Initialization<M_Source>;
1445
1445
  }
1446
1446
  ]>
1447
1447
  ] | readonly [
1448
1448
  'dictionary',
1449
- _i_core._T_State_Group<G_Source, readonly ['map', _T_Initialization<G_Source>]>
1449
+ _i_core._T_State_Group<M_Source, readonly ['map', _T_Initialization<M_Source>]>
1450
1450
  ] | readonly [
1451
1451
  'function',
1452
- _i_core._T_State_Group<G_Source, readonly [
1452
+ _i_core._T_State_Group<M_Source, readonly [
1453
1453
  'call',
1454
1454
  {
1455
- readonly 'arguments': _pt.Optional_Value<_i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>>;
1456
- readonly 'context': _T_Initialization<G_Source>;
1455
+ readonly 'arguments': _pt.Optional_Value<_i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>>;
1456
+ readonly 'context': _T_Initialization<M_Source>;
1457
1457
  }
1458
1458
  ]>
1459
1459
  ] | readonly [
1460
1460
  'optional',
1461
- _i_core._T_State_Group<G_Source, readonly ['map', _T_Initialization<G_Source>] | readonly [
1461
+ _i_core._T_State_Group<M_Source, readonly ['map', _T_Initialization<M_Source>] | readonly [
1462
1462
  'transform',
1463
1463
  {
1464
- readonly 'if not set': _T_Initialization<G_Source>;
1465
- readonly 'if set': _T_Initialization<G_Source>;
1466
- readonly 'temp resulting node': _pt.Optional_Value<_i_imports_interface._T_Type<G_Source>>;
1464
+ readonly 'if not set': _T_Initialization<M_Source>;
1465
+ readonly 'if set': _T_Initialization<M_Source>;
1466
+ readonly 'temp resulting node': _pt.Optional_Value<_i_imports_interface._T_Type<M_Source>>;
1467
1467
  }
1468
1468
  ]>
1469
1469
  ] | readonly [
1470
1470
  'tagged union',
1471
- _i_core._T_State_Group<G_Source, readonly [
1471
+ _i_core._T_State_Group<M_Source, readonly [
1472
1472
  'switch',
1473
1473
  {
1474
- readonly 'temp resulting node': _pt.Optional_Value<_i_imports_interface._T_Type<G_Source>>;
1475
- readonly 'type': _i_core._T_State_Group<G_Source, readonly [
1474
+ readonly 'temp resulting node': _pt.Optional_Value<_i_imports_interface._T_Type<M_Source>>;
1475
+ readonly 'type': _i_core._T_State_Group<M_Source, readonly [
1476
1476
  'full',
1477
1477
  {
1478
- readonly 'cases': _i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>;
1478
+ readonly 'cases': _i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>;
1479
1479
  }
1480
1480
  ] | readonly [
1481
1481
  'partial',
1482
1482
  {
1483
- readonly 'cases': _i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>;
1484
- readonly 'default': _T_Initialization<G_Source>;
1483
+ readonly 'cases': _i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>;
1484
+ readonly 'default': _T_Initialization<M_Source>;
1485
1485
  }
1486
1486
  ]>;
1487
1487
  }
1488
1488
  ]>
1489
1489
  ]>;
1490
1490
  }
1491
- type transformation<G_Source> = {
1492
- readonly 'source': _T_Selection<G_Source>;
1493
- readonly 'type': _i_core._T_State_Group<G_Source, readonly [
1491
+ type transformation<M_Source> = {
1492
+ readonly 'source': _T_Selection<M_Source>;
1493
+ readonly 'type': _i_core._T_State_Group<M_Source, readonly [
1494
1494
  'array',
1495
- _i_core._T_State_Group<G_Source, readonly ['map', _T_Initialization<G_Source>]>
1495
+ _i_core._T_State_Group<M_Source, readonly ['map', _T_Initialization<M_Source>]>
1496
1496
  ] | readonly [
1497
1497
  'boolean',
1498
- _i_core._T_State_Group<G_Source, readonly ['not', null] | readonly [
1498
+ _i_core._T_State_Group<M_Source, readonly ['not', null] | readonly [
1499
1499
  'transform',
1500
1500
  {
1501
- readonly 'if false': _T_Initialization<G_Source>;
1502
- readonly 'if true': _T_Initialization<G_Source>;
1501
+ readonly 'if false': _T_Initialization<M_Source>;
1502
+ readonly 'if true': _T_Initialization<M_Source>;
1503
1503
  }
1504
1504
  ]>
1505
1505
  ] | readonly [
1506
1506
  'dictionary',
1507
- _i_core._T_State_Group<G_Source, readonly ['map', _T_Initialization<G_Source>]>
1507
+ _i_core._T_State_Group<M_Source, readonly ['map', _T_Initialization<M_Source>]>
1508
1508
  ] | readonly [
1509
1509
  'function',
1510
- _i_core._T_State_Group<G_Source, readonly [
1510
+ _i_core._T_State_Group<M_Source, readonly [
1511
1511
  'call',
1512
1512
  {
1513
- readonly 'arguments': _pt.Optional_Value<_i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>>;
1514
- readonly 'context': _T_Initialization<G_Source>;
1513
+ readonly 'arguments': _pt.Optional_Value<_i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>>;
1514
+ readonly 'context': _T_Initialization<M_Source>;
1515
1515
  }
1516
1516
  ]>
1517
1517
  ] | readonly [
1518
1518
  'optional',
1519
- _i_core._T_State_Group<G_Source, readonly ['map', _T_Initialization<G_Source>] | readonly [
1519
+ _i_core._T_State_Group<M_Source, readonly ['map', _T_Initialization<M_Source>] | readonly [
1520
1520
  'transform',
1521
1521
  {
1522
- readonly 'if not set': _T_Initialization<G_Source>;
1523
- readonly 'if set': _T_Initialization<G_Source>;
1524
- readonly 'temp resulting node': _pt.Optional_Value<_i_imports_interface._T_Type<G_Source>>;
1522
+ readonly 'if not set': _T_Initialization<M_Source>;
1523
+ readonly 'if set': _T_Initialization<M_Source>;
1524
+ readonly 'temp resulting node': _pt.Optional_Value<_i_imports_interface._T_Type<M_Source>>;
1525
1525
  }
1526
1526
  ]>
1527
1527
  ] | readonly [
1528
1528
  'tagged union',
1529
- _i_core._T_State_Group<G_Source, readonly [
1529
+ _i_core._T_State_Group<M_Source, readonly [
1530
1530
  'switch',
1531
1531
  {
1532
- readonly 'temp resulting node': _pt.Optional_Value<_i_imports_interface._T_Type<G_Source>>;
1533
- readonly 'type': _i_core._T_State_Group<G_Source, readonly [
1532
+ readonly 'temp resulting node': _pt.Optional_Value<_i_imports_interface._T_Type<M_Source>>;
1533
+ readonly 'type': _i_core._T_State_Group<M_Source, readonly [
1534
1534
  'full',
1535
1535
  {
1536
- readonly 'cases': _i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>;
1536
+ readonly 'cases': _i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>;
1537
1537
  }
1538
1538
  ] | readonly [
1539
1539
  'partial',
1540
1540
  {
1541
- readonly 'cases': _i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>;
1542
- readonly 'default': _T_Initialization<G_Source>;
1541
+ readonly 'cases': _i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>;
1542
+ readonly 'default': _T_Initialization<M_Source>;
1543
1543
  }
1544
1544
  ]>;
1545
1545
  }
@@ -1547,82 +1547,82 @@ export declare namespace Initialization {
1547
1547
  ]>;
1548
1548
  };
1549
1549
  }
1550
- type SG<G_Source> = readonly [
1550
+ type SG<M_Source> = readonly [
1551
1551
  'block',
1552
1552
  {
1553
- readonly 'initialization': _T_Initialization<G_Source>;
1554
- readonly 'temp ordered variables': _i_core._T_List<G_Source, {
1555
- readonly 'initialization': _T_Initialization<G_Source>;
1553
+ readonly 'initialization': _T_Initialization<M_Source>;
1554
+ readonly 'temp ordered variables': _i_core._T_List<M_Source, {
1555
+ readonly 'initialization': _T_Initialization<M_Source>;
1556
1556
  readonly 'name': string;
1557
- readonly 'type': _pt.Optional_Value<_i_imports_interface._T_Type<G_Source>>;
1557
+ readonly 'type': _pt.Optional_Value<_i_imports_interface._T_Type<M_Source>>;
1558
1558
  }>;
1559
- readonly 'variables': _T_Variables<G_Source>;
1559
+ readonly 'variables': _T_Variables<M_Source>;
1560
1560
  }
1561
1561
  ] | readonly [
1562
1562
  'change context',
1563
1563
  {
1564
- readonly 'initialization': _T_Initialization<G_Source>;
1565
- readonly 'new context': _T_Selection<G_Source>;
1564
+ readonly 'initialization': _T_Initialization<M_Source>;
1565
+ readonly 'new context': _T_Selection<M_Source>;
1566
1566
  }
1567
1567
  ] | readonly [
1568
1568
  'literal',
1569
1569
  {
1570
- readonly 'value': _T_Literal<G_Source>;
1570
+ readonly 'value': _T_Literal<M_Source>;
1571
1571
  }
1572
- ] | readonly ['selection', _T_Selection<G_Source>] | readonly [
1572
+ ] | readonly ['selection', _T_Selection<M_Source>] | readonly [
1573
1573
  'transformation',
1574
1574
  {
1575
- readonly 'source': _T_Selection<G_Source>;
1576
- readonly 'type': _i_core._T_State_Group<G_Source, readonly [
1575
+ readonly 'source': _T_Selection<M_Source>;
1576
+ readonly 'type': _i_core._T_State_Group<M_Source, readonly [
1577
1577
  'array',
1578
- _i_core._T_State_Group<G_Source, readonly ['map', _T_Initialization<G_Source>]>
1578
+ _i_core._T_State_Group<M_Source, readonly ['map', _T_Initialization<M_Source>]>
1579
1579
  ] | readonly [
1580
1580
  'boolean',
1581
- _i_core._T_State_Group<G_Source, readonly ['not', null] | readonly [
1581
+ _i_core._T_State_Group<M_Source, readonly ['not', null] | readonly [
1582
1582
  'transform',
1583
1583
  {
1584
- readonly 'if false': _T_Initialization<G_Source>;
1585
- readonly 'if true': _T_Initialization<G_Source>;
1584
+ readonly 'if false': _T_Initialization<M_Source>;
1585
+ readonly 'if true': _T_Initialization<M_Source>;
1586
1586
  }
1587
1587
  ]>
1588
1588
  ] | readonly [
1589
1589
  'dictionary',
1590
- _i_core._T_State_Group<G_Source, readonly ['map', _T_Initialization<G_Source>]>
1590
+ _i_core._T_State_Group<M_Source, readonly ['map', _T_Initialization<M_Source>]>
1591
1591
  ] | readonly [
1592
1592
  'function',
1593
- _i_core._T_State_Group<G_Source, readonly [
1593
+ _i_core._T_State_Group<M_Source, readonly [
1594
1594
  'call',
1595
1595
  {
1596
- readonly 'arguments': _pt.Optional_Value<_i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>>;
1597
- readonly 'context': _T_Initialization<G_Source>;
1596
+ readonly 'arguments': _pt.Optional_Value<_i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>>;
1597
+ readonly 'context': _T_Initialization<M_Source>;
1598
1598
  }
1599
1599
  ]>
1600
1600
  ] | readonly [
1601
1601
  'optional',
1602
- _i_core._T_State_Group<G_Source, readonly ['map', _T_Initialization<G_Source>] | readonly [
1602
+ _i_core._T_State_Group<M_Source, readonly ['map', _T_Initialization<M_Source>] | readonly [
1603
1603
  'transform',
1604
1604
  {
1605
- readonly 'if not set': _T_Initialization<G_Source>;
1606
- readonly 'if set': _T_Initialization<G_Source>;
1607
- readonly 'temp resulting node': _pt.Optional_Value<_i_imports_interface._T_Type<G_Source>>;
1605
+ readonly 'if not set': _T_Initialization<M_Source>;
1606
+ readonly 'if set': _T_Initialization<M_Source>;
1607
+ readonly 'temp resulting node': _pt.Optional_Value<_i_imports_interface._T_Type<M_Source>>;
1608
1608
  }
1609
1609
  ]>
1610
1610
  ] | readonly [
1611
1611
  'tagged union',
1612
- _i_core._T_State_Group<G_Source, readonly [
1612
+ _i_core._T_State_Group<M_Source, readonly [
1613
1613
  'switch',
1614
1614
  {
1615
- readonly 'temp resulting node': _pt.Optional_Value<_i_imports_interface._T_Type<G_Source>>;
1616
- readonly 'type': _i_core._T_State_Group<G_Source, readonly [
1615
+ readonly 'temp resulting node': _pt.Optional_Value<_i_imports_interface._T_Type<M_Source>>;
1616
+ readonly 'type': _i_core._T_State_Group<M_Source, readonly [
1617
1617
  'full',
1618
1618
  {
1619
- readonly 'cases': _i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>;
1619
+ readonly 'cases': _i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>;
1620
1620
  }
1621
1621
  ] | readonly [
1622
1622
  'partial',
1623
1623
  {
1624
- readonly 'cases': _i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>;
1625
- readonly 'default': _T_Initialization<G_Source>;
1624
+ readonly 'cases': _i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>;
1625
+ readonly 'default': _T_Initialization<M_Source>;
1626
1626
  }
1627
1627
  ]>;
1628
1628
  }
@@ -1636,146 +1636,146 @@ export declare namespace Literal {
1636
1636
  namespace array {
1637
1637
  namespace L {
1638
1638
  }
1639
- type L<G_Source> = _T_Initialization<G_Source>;
1639
+ type L<M_Source> = _T_Initialization<M_Source>;
1640
1640
  }
1641
- type array<G_Source> = _i_core._T_List<G_Source, _T_Initialization<G_Source>>;
1641
+ type array<M_Source> = _i_core._T_List<M_Source, _T_Initialization<M_Source>>;
1642
1642
  namespace _boolean {
1643
1643
  namespace SG {
1644
- type _false<G_Source> = null;
1645
- type _true<G_Source> = null;
1644
+ type _false<M_Source> = null;
1645
+ type _true<M_Source> = null;
1646
1646
  }
1647
- type SG<G_Source> = readonly ['false', null] | readonly ['true', null];
1647
+ type SG<M_Source> = readonly ['false', null] | readonly ['true', null];
1648
1648
  }
1649
- type _boolean<G_Source> = _i_core._T_State_Group<G_Source, readonly ['false', null] | readonly ['true', null]>;
1649
+ type _boolean<M_Source> = _i_core._T_State_Group<M_Source, readonly ['false', null] | readonly ['true', null]>;
1650
1650
  namespace dictionary {
1651
1651
  namespace D {
1652
1652
  }
1653
- type D<G_Source> = _T_Initialization<G_Source>;
1653
+ type D<M_Source> = _T_Initialization<M_Source>;
1654
1654
  }
1655
- type dictionary<G_Source> = _i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>;
1655
+ type dictionary<M_Source> = _i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>;
1656
1656
  namespace _function {
1657
1657
  namespace initialization {
1658
1658
  }
1659
- type initialization<G_Source> = _T_Initialization<G_Source>;
1660
- type temp_has_parameters<G_Source> = boolean;
1659
+ type initialization<M_Source> = _T_Initialization<M_Source>;
1660
+ type temp_has_parameters<M_Source> = boolean;
1661
1661
  namespace temp_resulting_node {
1662
1662
  namespace O {
1663
1663
  }
1664
- type O<G_Source> = _i_imports_interface._T_Type<G_Source>;
1664
+ type O<M_Source> = _i_imports_interface._T_Type<M_Source>;
1665
1665
  }
1666
- type temp_resulting_node<G_Source> = _pt.Optional_Value<_i_imports_interface._T_Type<G_Source>>;
1666
+ type temp_resulting_node<M_Source> = _pt.Optional_Value<_i_imports_interface._T_Type<M_Source>>;
1667
1667
  }
1668
- type _function<G_Source> = {
1669
- readonly 'initialization': _T_Initialization<G_Source>;
1668
+ type _function<M_Source> = {
1669
+ readonly 'initialization': _T_Initialization<M_Source>;
1670
1670
  readonly 'temp has parameters': boolean;
1671
- readonly 'temp resulting node': _pt.Optional_Value<_i_imports_interface._T_Type<G_Source>>;
1671
+ readonly 'temp resulting node': _pt.Optional_Value<_i_imports_interface._T_Type<M_Source>>;
1672
1672
  };
1673
1673
  namespace group {
1674
1674
  namespace D {
1675
1675
  }
1676
- type D<G_Source> = _T_Initialization<G_Source>;
1676
+ type D<M_Source> = _T_Initialization<M_Source>;
1677
1677
  }
1678
- type group<G_Source> = _i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>;
1679
- type _null<G_Source> = null;
1678
+ type group<M_Source> = _i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>;
1679
+ type _null<M_Source> = null;
1680
1680
  namespace _number {
1681
1681
  namespace SG {
1682
- type floting_point<G_Source> = number;
1683
- type integer<G_Source> = number;
1684
- type signed_integer<G_Source> = number;
1682
+ type floting_point<M_Source> = number;
1683
+ type integer<M_Source> = number;
1684
+ type signed_integer<M_Source> = number;
1685
1685
  }
1686
- type SG<G_Source> = readonly ['floting point', number] | readonly ['integer', number] | readonly ['signed integer', number];
1686
+ type SG<M_Source> = readonly ['floting point', number] | readonly ['integer', number] | readonly ['signed integer', number];
1687
1687
  }
1688
- type _number<G_Source> = _i_core._T_State_Group<G_Source, readonly ['floting point', number] | readonly ['integer', number] | readonly ['signed integer', number]>;
1688
+ type _number<M_Source> = _i_core._T_State_Group<M_Source, readonly ['floting point', number] | readonly ['integer', number] | readonly ['signed integer', number]>;
1689
1689
  namespace optional {
1690
1690
  namespace SG {
1691
- type not_set<G_Source> = null;
1691
+ type not_set<M_Source> = null;
1692
1692
  namespace _set {
1693
1693
  }
1694
- type _set<G_Source> = _T_Initialization<G_Source>;
1694
+ type _set<M_Source> = _T_Initialization<M_Source>;
1695
1695
  }
1696
- type SG<G_Source> = readonly ['not set', null] | readonly ['set', _T_Initialization<G_Source>];
1696
+ type SG<M_Source> = readonly ['not set', null] | readonly ['set', _T_Initialization<M_Source>];
1697
1697
  }
1698
- type optional<G_Source> = _i_core._T_State_Group<G_Source, readonly ['not set', null] | readonly ['set', _T_Initialization<G_Source>]>;
1698
+ type optional<M_Source> = _i_core._T_State_Group<M_Source, readonly ['not set', null] | readonly ['set', _T_Initialization<M_Source>]>;
1699
1699
  namespace _string {
1700
1700
  namespace delimiter {
1701
1701
  namespace SG {
1702
- type backtick<G_Source> = null;
1703
- type quote<G_Source> = null;
1702
+ type backtick<M_Source> = null;
1703
+ type quote<M_Source> = null;
1704
1704
  }
1705
- type SG<G_Source> = readonly ['backtick', null] | readonly ['quote', null];
1705
+ type SG<M_Source> = readonly ['backtick', null] | readonly ['quote', null];
1706
1706
  }
1707
- type delimiter<G_Source> = _i_core._T_State_Group<G_Source, readonly ['backtick', null] | readonly ['quote', null]>;
1708
- type value<G_Source> = string;
1707
+ type delimiter<M_Source> = _i_core._T_State_Group<M_Source, readonly ['backtick', null] | readonly ['quote', null]>;
1708
+ type value<M_Source> = string;
1709
1709
  }
1710
- type _string<G_Source> = {
1711
- readonly 'delimiter': _i_core._T_State_Group<G_Source, readonly ['backtick', null] | readonly ['quote', null]>;
1710
+ type _string<M_Source> = {
1711
+ readonly 'delimiter': _i_core._T_State_Group<M_Source, readonly ['backtick', null] | readonly ['quote', null]>;
1712
1712
  readonly 'value': string;
1713
1713
  };
1714
1714
  namespace tagged_union {
1715
- type _case<G_Source> = string;
1715
+ type _case<M_Source> = string;
1716
1716
  namespace value {
1717
1717
  }
1718
- type value<G_Source> = _T_Initialization<G_Source>;
1718
+ type value<M_Source> = _T_Initialization<M_Source>;
1719
1719
  }
1720
- type tagged_union<G_Source> = {
1720
+ type tagged_union<M_Source> = {
1721
1721
  readonly 'case': string;
1722
- readonly 'value': _T_Initialization<G_Source>;
1722
+ readonly 'value': _T_Initialization<M_Source>;
1723
1723
  };
1724
1724
  }
1725
- type SG<G_Source> = readonly ['array', _i_core._T_List<G_Source, _T_Initialization<G_Source>>] | readonly [
1725
+ type SG<M_Source> = readonly ['array', _i_core._T_List<M_Source, _T_Initialization<M_Source>>] | readonly [
1726
1726
  'boolean',
1727
- _i_core._T_State_Group<G_Source, readonly ['false', null] | readonly ['true', null]>
1728
- ] | readonly ['dictionary', _i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>] | readonly [
1727
+ _i_core._T_State_Group<M_Source, readonly ['false', null] | readonly ['true', null]>
1728
+ ] | readonly ['dictionary', _i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>] | readonly [
1729
1729
  'function',
1730
1730
  {
1731
- readonly 'initialization': _T_Initialization<G_Source>;
1731
+ readonly 'initialization': _T_Initialization<M_Source>;
1732
1732
  readonly 'temp has parameters': boolean;
1733
- readonly 'temp resulting node': _pt.Optional_Value<_i_imports_interface._T_Type<G_Source>>;
1733
+ readonly 'temp resulting node': _pt.Optional_Value<_i_imports_interface._T_Type<M_Source>>;
1734
1734
  }
1735
- ] | readonly ['group', _i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>] | readonly ['null', null] | readonly [
1735
+ ] | readonly ['group', _i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>] | readonly ['null', null] | readonly [
1736
1736
  'number',
1737
- _i_core._T_State_Group<G_Source, readonly ['floting point', number] | readonly ['integer', number] | readonly ['signed integer', number]>
1737
+ _i_core._T_State_Group<M_Source, readonly ['floting point', number] | readonly ['integer', number] | readonly ['signed integer', number]>
1738
1738
  ] | readonly [
1739
1739
  'optional',
1740
- _i_core._T_State_Group<G_Source, readonly ['not set', null] | readonly ['set', _T_Initialization<G_Source>]>
1740
+ _i_core._T_State_Group<M_Source, readonly ['not set', null] | readonly ['set', _T_Initialization<M_Source>]>
1741
1741
  ] | readonly [
1742
1742
  'string',
1743
1743
  {
1744
- readonly 'delimiter': _i_core._T_State_Group<G_Source, readonly ['backtick', null] | readonly ['quote', null]>;
1744
+ readonly 'delimiter': _i_core._T_State_Group<M_Source, readonly ['backtick', null] | readonly ['quote', null]>;
1745
1745
  readonly 'value': string;
1746
1746
  }
1747
1747
  ] | readonly [
1748
1748
  'tagged union',
1749
1749
  {
1750
1750
  readonly 'case': string;
1751
- readonly 'value': _T_Initialization<G_Source>;
1751
+ readonly 'value': _T_Initialization<M_Source>;
1752
1752
  }
1753
1753
  ];
1754
1754
  }
1755
1755
  export declare namespace Module {
1756
1756
  namespace type_imports {
1757
1757
  }
1758
- type type_imports<G_Source> = _i_imports_interface._T_Imports<G_Source>;
1758
+ type type_imports<M_Source> = _i_imports_interface._T_Imports<M_Source>;
1759
1759
  namespace variable_imports {
1760
1760
  namespace D {
1761
1761
  namespace tail {
1762
- type L<G_Source> = string;
1762
+ type L<M_Source> = string;
1763
1763
  }
1764
- type tail<G_Source> = _i_core._T_List<G_Source, string>;
1764
+ type tail<M_Source> = _i_core._T_List<M_Source, string>;
1765
1765
  namespace _type {
1766
1766
  namespace SG {
1767
1767
  namespace ancestor {
1768
- type dependency<G_Source> = string;
1769
- type number_of_steps<G_Source> = number;
1768
+ type dependency<M_Source> = string;
1769
+ type number_of_steps<M_Source> = number;
1770
1770
  }
1771
- type ancestor<G_Source> = {
1771
+ type ancestor<M_Source> = {
1772
1772
  readonly 'dependency': string;
1773
1773
  readonly 'number of steps': number;
1774
1774
  };
1775
- type external<G_Source> = string;
1776
- type sibling<G_Source> = string;
1775
+ type external<M_Source> = string;
1776
+ type sibling<M_Source> = string;
1777
1777
  }
1778
- type SG<G_Source> = readonly [
1778
+ type SG<M_Source> = readonly [
1779
1779
  'ancestor',
1780
1780
  {
1781
1781
  readonly 'dependency': string;
@@ -1783,7 +1783,7 @@ export declare namespace Module {
1783
1783
  }
1784
1784
  ] | readonly ['external', string] | readonly ['sibling', string];
1785
1785
  }
1786
- type _type<G_Source> = _i_core._T_State_Group<G_Source, readonly [
1786
+ type _type<M_Source> = _i_core._T_State_Group<M_Source, readonly [
1787
1787
  'ancestor',
1788
1788
  {
1789
1789
  readonly 'dependency': string;
@@ -1791,9 +1791,9 @@ export declare namespace Module {
1791
1791
  }
1792
1792
  ] | readonly ['external', string] | readonly ['sibling', string]>;
1793
1793
  }
1794
- type D<G_Source> = {
1795
- readonly 'tail': _i_core._T_List<G_Source, string>;
1796
- readonly 'type': _i_core._T_State_Group<G_Source, readonly [
1794
+ type D<M_Source> = {
1795
+ readonly 'tail': _i_core._T_List<M_Source, string>;
1796
+ readonly 'type': _i_core._T_State_Group<M_Source, readonly [
1797
1797
  'ancestor',
1798
1798
  {
1799
1799
  readonly 'dependency': string;
@@ -1802,9 +1802,9 @@ export declare namespace Module {
1802
1802
  ] | readonly ['external', string] | readonly ['sibling', string]>;
1803
1803
  };
1804
1804
  }
1805
- type variable_imports<G_Source> = _i_core._T_Dictionary<G_Source, {
1806
- readonly 'tail': _i_core._T_List<G_Source, string>;
1807
- readonly 'type': _i_core._T_State_Group<G_Source, readonly [
1805
+ type variable_imports<M_Source> = _i_core._T_Dictionary<M_Source, {
1806
+ readonly 'tail': _i_core._T_List<M_Source, string>;
1807
+ readonly 'type': _i_core._T_State_Group<M_Source, readonly [
1808
1808
  'ancestor',
1809
1809
  {
1810
1810
  readonly 'dependency': string;
@@ -1814,84 +1814,84 @@ export declare namespace Module {
1814
1814
  }>;
1815
1815
  namespace variables {
1816
1816
  }
1817
- type variables<G_Source> = _T_Variables<G_Source>;
1817
+ type variables<M_Source> = _T_Variables<M_Source>;
1818
1818
  }
1819
1819
  export declare namespace Module_Set {
1820
1820
  namespace D {
1821
1821
  namespace SG {
1822
1822
  namespace _module {
1823
1823
  }
1824
- type _module<G_Source> = _T_Module<G_Source>;
1824
+ type _module<M_Source> = _T_Module<M_Source>;
1825
1825
  namespace _set {
1826
1826
  }
1827
- type _set<G_Source> = _T_Module_Set<G_Source>;
1827
+ type _set<M_Source> = _T_Module_Set<M_Source>;
1828
1828
  }
1829
- type SG<G_Source> = readonly ['module', _T_Module<G_Source>] | readonly ['set', _T_Module_Set<G_Source>];
1829
+ type SG<M_Source> = readonly ['module', _T_Module<M_Source>] | readonly ['set', _T_Module_Set<M_Source>];
1830
1830
  }
1831
- type D<G_Source> = _i_core._T_State_Group<G_Source, readonly ['module', _T_Module<G_Source>] | readonly ['set', _T_Module_Set<G_Source>]>;
1831
+ type D<M_Source> = _i_core._T_State_Group<M_Source, readonly ['module', _T_Module<M_Source>] | readonly ['set', _T_Module_Set<M_Source>]>;
1832
1832
  }
1833
1833
  export declare namespace Selection {
1834
1834
  namespace start {
1835
1835
  namespace SG {
1836
- type abort<G_Source> = null;
1837
- type argument<G_Source> = string;
1836
+ type abort<M_Source> = null;
1837
+ type argument<M_Source> = string;
1838
1838
  namespace call {
1839
1839
  namespace _arguments {
1840
1840
  namespace O {
1841
1841
  namespace D {
1842
1842
  }
1843
- type D<G_Source> = _T_Initialization<G_Source>;
1843
+ type D<M_Source> = _T_Initialization<M_Source>;
1844
1844
  }
1845
- type O<G_Source> = _i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>;
1845
+ type O<M_Source> = _i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>;
1846
1846
  }
1847
- type _arguments<G_Source> = _pt.Optional_Value<_i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>>;
1847
+ type _arguments<M_Source> = _pt.Optional_Value<_i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>>;
1848
1848
  namespace context {
1849
1849
  }
1850
- type context<G_Source> = _T_Selection<G_Source>;
1850
+ type context<M_Source> = _T_Selection<M_Source>;
1851
1851
  namespace source {
1852
1852
  }
1853
- type source<G_Source> = _T_Selection<G_Source>;
1853
+ type source<M_Source> = _T_Selection<M_Source>;
1854
1854
  }
1855
- type call<G_Source> = {
1856
- readonly 'arguments': _pt.Optional_Value<_i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>>;
1857
- readonly 'context': _T_Selection<G_Source>;
1858
- readonly 'source': _T_Selection<G_Source>;
1855
+ type call<M_Source> = {
1856
+ readonly 'arguments': _pt.Optional_Value<_i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>>;
1857
+ readonly 'context': _T_Selection<M_Source>;
1858
+ readonly 'source': _T_Selection<M_Source>;
1859
1859
  };
1860
- type context<G_Source> = null;
1861
- type implement_me<G_Source> = null;
1860
+ type context<M_Source> = null;
1861
+ type implement_me<M_Source> = null;
1862
1862
  namespace imported_variable {
1863
- type _import<G_Source> = string;
1864
- type variable<G_Source> = string;
1863
+ type _import<M_Source> = string;
1864
+ type variable<M_Source> = string;
1865
1865
  }
1866
- type imported_variable<G_Source> = {
1866
+ type imported_variable<M_Source> = {
1867
1867
  readonly 'import': string;
1868
1868
  readonly 'variable': string;
1869
1869
  };
1870
- type parameter<G_Source> = string;
1870
+ type parameter<M_Source> = string;
1871
1871
  namespace transform_optional_value {
1872
1872
  namespace if_not_set {
1873
1873
  }
1874
- type if_not_set<G_Source> = _T_Selection<G_Source>;
1874
+ type if_not_set<M_Source> = _T_Selection<M_Source>;
1875
1875
  namespace if_set {
1876
1876
  }
1877
- type if_set<G_Source> = _T_Selection<G_Source>;
1877
+ type if_set<M_Source> = _T_Selection<M_Source>;
1878
1878
  namespace source {
1879
1879
  }
1880
- type source<G_Source> = _T_Selection<G_Source>;
1880
+ type source<M_Source> = _T_Selection<M_Source>;
1881
1881
  }
1882
- type transform_optional_value<G_Source> = {
1883
- readonly 'if not set': _T_Selection<G_Source>;
1884
- readonly 'if set': _T_Selection<G_Source>;
1885
- readonly 'source': _T_Selection<G_Source>;
1882
+ type transform_optional_value<M_Source> = {
1883
+ readonly 'if not set': _T_Selection<M_Source>;
1884
+ readonly 'if set': _T_Selection<M_Source>;
1885
+ readonly 'source': _T_Selection<M_Source>;
1886
1886
  };
1887
- type variable<G_Source> = string;
1887
+ type variable<M_Source> = string;
1888
1888
  }
1889
- type SG<G_Source> = readonly ['abort', null] | readonly ['argument', string] | readonly [
1889
+ type SG<M_Source> = readonly ['abort', null] | readonly ['argument', string] | readonly [
1890
1890
  'call',
1891
1891
  {
1892
- readonly 'arguments': _pt.Optional_Value<_i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>>;
1893
- readonly 'context': _T_Selection<G_Source>;
1894
- readonly 'source': _T_Selection<G_Source>;
1892
+ readonly 'arguments': _pt.Optional_Value<_i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>>;
1893
+ readonly 'context': _T_Selection<M_Source>;
1894
+ readonly 'source': _T_Selection<M_Source>;
1895
1895
  }
1896
1896
  ] | readonly ['context', null] | readonly ['implement me', null] | readonly [
1897
1897
  'imported variable',
@@ -1902,18 +1902,18 @@ export declare namespace Selection {
1902
1902
  ] | readonly ['parameter', string] | readonly [
1903
1903
  'transform optional value',
1904
1904
  {
1905
- readonly 'if not set': _T_Selection<G_Source>;
1906
- readonly 'if set': _T_Selection<G_Source>;
1907
- readonly 'source': _T_Selection<G_Source>;
1905
+ readonly 'if not set': _T_Selection<M_Source>;
1906
+ readonly 'if set': _T_Selection<M_Source>;
1907
+ readonly 'source': _T_Selection<M_Source>;
1908
1908
  }
1909
1909
  ] | readonly ['variable', string];
1910
1910
  }
1911
- type start<G_Source> = _i_core._T_State_Group<G_Source, readonly ['abort', null] | readonly ['argument', string] | readonly [
1911
+ type start<M_Source> = _i_core._T_State_Group<M_Source, readonly ['abort', null] | readonly ['argument', string] | readonly [
1912
1912
  'call',
1913
1913
  {
1914
- readonly 'arguments': _pt.Optional_Value<_i_core._T_Dictionary<G_Source, _T_Initialization<G_Source>>>;
1915
- readonly 'context': _T_Selection<G_Source>;
1916
- readonly 'source': _T_Selection<G_Source>;
1914
+ readonly 'arguments': _pt.Optional_Value<_i_core._T_Dictionary<M_Source, _T_Initialization<M_Source>>>;
1915
+ readonly 'context': _T_Selection<M_Source>;
1916
+ readonly 'source': _T_Selection<M_Source>;
1917
1917
  }
1918
1918
  ] | readonly ['context', null] | readonly ['implement me', null] | readonly [
1919
1919
  'imported variable',
@@ -1924,33 +1924,33 @@ export declare namespace Selection {
1924
1924
  ] | readonly ['parameter', string] | readonly [
1925
1925
  'transform optional value',
1926
1926
  {
1927
- readonly 'if not set': _T_Selection<G_Source>;
1928
- readonly 'if set': _T_Selection<G_Source>;
1929
- readonly 'source': _T_Selection<G_Source>;
1927
+ readonly 'if not set': _T_Selection<M_Source>;
1928
+ readonly 'if set': _T_Selection<M_Source>;
1929
+ readonly 'source': _T_Selection<M_Source>;
1930
1930
  }
1931
1931
  ] | readonly ['variable', string]>;
1932
1932
  namespace tail {
1933
- type L<G_Source> = string;
1933
+ type L<M_Source> = string;
1934
1934
  }
1935
- type tail<G_Source> = _i_core._T_List<G_Source, string>;
1935
+ type tail<M_Source> = _i_core._T_List<M_Source, string>;
1936
1936
  }
1937
1937
  export declare namespace Type_Parameters {
1938
- type D<G_Source> = null;
1938
+ type D<M_Source> = null;
1939
1939
  }
1940
1940
  export declare namespace Variables {
1941
1941
  namespace D {
1942
1942
  namespace initialization {
1943
1943
  }
1944
- type initialization<G_Source> = _T_Initialization<G_Source>;
1944
+ type initialization<M_Source> = _T_Initialization<M_Source>;
1945
1945
  namespace _type {
1946
1946
  namespace O {
1947
1947
  }
1948
- type O<G_Source> = _i_imports_interface._T_Type<G_Source>;
1948
+ type O<M_Source> = _i_imports_interface._T_Type<M_Source>;
1949
1949
  }
1950
- type _type<G_Source> = _pt.Optional_Value<_i_imports_interface._T_Type<G_Source>>;
1950
+ type _type<M_Source> = _pt.Optional_Value<_i_imports_interface._T_Type<M_Source>>;
1951
1951
  }
1952
- type D<G_Source> = {
1953
- readonly 'initialization': _T_Initialization<G_Source>;
1954
- readonly 'type': _pt.Optional_Value<_i_imports_interface._T_Type<G_Source>>;
1952
+ type D<M_Source> = {
1953
+ readonly 'initialization': _T_Initialization<M_Source>;
1954
+ readonly 'type': _pt.Optional_Value<_i_imports_interface._T_Type<M_Source>>;
1955
1955
  };
1956
1956
  }