@intersystems-community/ascot 0.2.0 → 0.3.0

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 (9) hide show
  1. package/README.md +35 -30
  2. package/dist/index.d.ts +15 -11
  3. package/dist/index.js +25 -20
  4. package/dist/index.js.map +1 -1
  5. package/generated/ascot.js +1279 -1083
  6. package/generated/interfaces/iris-ascot-common.d.ts +17 -1
  7. package/generated/interfaces/iris-ascot-imported.d.ts +2 -1
  8. package/lib/ascot.core.wasm +0 -0
  9. package/package.json +5 -2
package/generated/ascot.js CHANGED
@@ -3617,33 +3617,51 @@ export function instantiate(getCoreModule, imports, instantiateCore = WebAssembl
3617
3617
  rsc[symbolRscHandle] = undefined;
3618
3618
  }
3619
3619
  curResourceBorrows = [];
3620
- var variant8 = ret;
3621
- if (variant8 === null || variant8=== undefined) {
3622
- dataView(memory0).setInt8(((arg3 >>> 0)) + 0, 0, true);
3623
- } else {
3624
- const e = variant8;
3625
- dataView(memory0).setInt8(((arg3 >>> 0)) + 0, 1, true);
3626
- var {text: v4_0, uri: v4_1 } = e;
3627
-
3628
- var encodeRes = _utf8AllocateAndEncode(v4_0, realloc0, memory0);
3629
- var ptr5= encodeRes.ptr;
3630
- var len5 = encodeRes.len;
3631
-
3632
- dataView(memory0).setUint32(((arg3 >>> 0)) + 8, len5, true);
3633
- dataView(memory0).setUint32(((arg3 >>> 0)) + 4, ptr5, true);
3634
- var variant7 = v4_1;
3635
- if (variant7 === null || variant7=== undefined) {
3636
- dataView(memory0).setInt8(((arg3 >>> 0)) + 12, 0, true);
3637
- } else {
3638
- const e = variant7;
3639
- dataView(memory0).setInt8(((arg3 >>> 0)) + 12, 1, true);
3620
+ var variant9 = ret;
3621
+ switch (variant9.tag) {
3622
+ case 'none': {
3623
+ dataView(memory0).setInt8(((arg3 >>> 0)) + 0, 0, true);
3640
3624
 
3641
- var encodeRes = _utf8AllocateAndEncode(e, realloc0, memory0);
3642
- var ptr6= encodeRes.ptr;
3643
- var len6 = encodeRes.len;
3625
+ break;
3626
+ }
3627
+ case 'some': {
3628
+ const e = variant9.val;
3629
+ dataView(memory0).setInt8(((arg3 >>> 0)) + 0, 1, true);
3630
+ var variant8 = e;
3631
+ if (variant8 === null || variant8=== undefined) {
3632
+ dataView(memory0).setInt8(((arg3 >>> 0)) + 4, 0, true);
3633
+ } else {
3634
+ const e = variant8;
3635
+ dataView(memory0).setInt8(((arg3 >>> 0)) + 4, 1, true);
3636
+ var {text: v4_0, uri: v4_1 } = e;
3637
+
3638
+ var encodeRes = _utf8AllocateAndEncode(v4_0, realloc0, memory0);
3639
+ var ptr5= encodeRes.ptr;
3640
+ var len5 = encodeRes.len;
3641
+
3642
+ dataView(memory0).setUint32(((arg3 >>> 0)) + 12, len5, true);
3643
+ dataView(memory0).setUint32(((arg3 >>> 0)) + 8, ptr5, true);
3644
+ var variant7 = v4_1;
3645
+ if (variant7 === null || variant7=== undefined) {
3646
+ dataView(memory0).setInt8(((arg3 >>> 0)) + 16, 0, true);
3647
+ } else {
3648
+ const e = variant7;
3649
+ dataView(memory0).setInt8(((arg3 >>> 0)) + 16, 1, true);
3650
+
3651
+ var encodeRes = _utf8AllocateAndEncode(e, realloc0, memory0);
3652
+ var ptr6= encodeRes.ptr;
3653
+ var len6 = encodeRes.len;
3654
+
3655
+ dataView(memory0).setUint32(((arg3 >>> 0)) + 24, len6, true);
3656
+ dataView(memory0).setUint32(((arg3 >>> 0)) + 20, ptr6, true);
3657
+ }
3658
+ }
3644
3659
 
3645
- dataView(memory0).setUint32(((arg3 >>> 0)) + 20, len6, true);
3646
- dataView(memory0).setUint32(((arg3 >>> 0)) + 16, ptr6, true);
3660
+ break;
3661
+ }
3662
+ default: {
3663
+ _debugLog("ERROR: invalid value (expected option as object with 'tag' member)", { value: variant9, valueType: typeof variant9});
3664
+ throw new TypeError('invalid variant specified for option');
3647
3665
  }
3648
3666
  }
3649
3667
  _debugLog('[iface="iris:ascot/imported", function="[method]iris-connection.get-int-or-mac"][Instruction::Return]', {
@@ -3764,11 +3782,11 @@ export function instantiate(getCoreModule, imports, instantiateCore = WebAssembl
3764
3782
  rsc[symbolRscHandle] = undefined;
3765
3783
  }
3766
3784
  curResourceBorrows = [];
3767
- var variant140 = ret;
3768
- if (variant140 === null || variant140=== undefined) {
3785
+ var variant143 = ret;
3786
+ if (variant143 === null || variant143=== undefined) {
3769
3787
  dataView(memory0).setInt8(((arg3 >>> 0)) + 0, 0, true);
3770
3788
  } else {
3771
- const e = variant140;
3789
+ const e = variant143;
3772
3790
  dataView(memory0).setInt8(((arg3 >>> 0)) + 0, 1, true);
3773
3791
  var {doc: v4_0, name: v4_1, extends: v4_2, deprecated: v4_3, members: v4_4, propertyClassNames: v4_5, includes: v4_6, isDatatype: v4_7, uri: v4_8 } = e;
3774
3792
 
@@ -3809,13 +3827,13 @@ export function instantiate(getCoreModule, imports, instantiateCore = WebAssembl
3809
3827
  dataView(memory0).setUint32(((arg3 >>> 0)) + 40, len11, true);
3810
3828
  dataView(memory0).setUint32(((arg3 >>> 0)) + 36, result11, true);
3811
3829
  dataView(memory0).setInt8(((arg3 >>> 0)) + 44, v4_3 ? 1 : 0, true);
3812
- var vec132 = v4_4;
3813
- var len132 = vec132.length;
3814
- var result132 = realloc0(0, 0, 4, len132 * 184);
3815
- if (result132 < 0 || len132 < 0 || len132 > 1458888 || result132 > memory0.buffer.byteLength || len132 > Math.floor((memory0.buffer.byteLength - result132) / 184)) throw new WebAssemblyRuntimeError('wasm trap: out of bounds memory access');
3816
- for (let i = 0; i < vec132.length; i++) {
3817
- const e = vec132[i];
3818
- const base = result132 + i * 184;var {doc: v12_0, before: v12_1, name: v12_2, aliases: v12_3, deprecated: v12_4, kind: v12_5, after: v12_6, uri: v12_7, origin: v12_8 } = e;
3830
+ var vec135 = v4_4;
3831
+ var len135 = vec135.length;
3832
+ var result135 = realloc0(0, 0, 4, len135 * 184);
3833
+ if (result135 < 0 || len135 < 0 || len135 > 1458888 || result135 > memory0.buffer.byteLength || len135 > Math.floor((memory0.buffer.byteLength - result135) / 184)) throw new WebAssemblyRuntimeError('wasm trap: out of bounds memory access');
3834
+ for (let i = 0; i < vec135.length; i++) {
3835
+ const e = vec135[i];
3836
+ const base = result135 + i * 184;var {doc: v12_0, before: v12_1, name: v12_2, aliases: v12_3, deprecated: v12_4, kind: v12_5, after: v12_6, uri: v12_7, origin: v12_8 } = e;
3819
3837
 
3820
3838
  var encodeRes = _utf8AllocateAndEncode(v12_0, realloc0, memory0);
3821
3839
  var ptr13= encodeRes.ptr;
@@ -3857,10 +3875,10 @@ export function instantiate(getCoreModule, imports, instantiateCore = WebAssembl
3857
3875
  dataView(memory0).setUint32((base) + 44, len20, true);
3858
3876
  dataView(memory0).setUint32((base) + 40, result20, true);
3859
3877
  dataView(memory0).setInt8((base) + 48, v12_4 ? 1 : 0, true);
3860
- var variant126 = v12_5;
3861
- switch (variant126.tag) {
3878
+ var variant129 = v12_5;
3879
+ switch (variant129.tag) {
3862
3880
  case 'parameter': {
3863
- const e = variant126.val;
3881
+ const e = variant129.val;
3864
3882
  dataView(memory0).setInt8((base) + 52, 0, true);
3865
3883
  var {t: v21_0, v: v21_1 } = e;
3866
3884
  var variant23 = v21_0;
@@ -3894,7 +3912,7 @@ export function instantiate(getCoreModule, imports, instantiateCore = WebAssembl
3894
3912
  break;
3895
3913
  }
3896
3914
  case 'property': {
3897
- const e = variant126.val;
3915
+ const e = variant129.val;
3898
3916
  dataView(memory0).setInt8((base) + 52, 1, true);
3899
3917
  var {t: v26_0, collection: v26_1, multidimensional: v26_2 } = e;
3900
3918
  var variant28 = v26_0;
@@ -3942,21 +3960,57 @@ export function instantiate(getCoreModule, imports, instantiateCore = WebAssembl
3942
3960
  break;
3943
3961
  }
3944
3962
  case 'relationship': {
3945
- const e = variant126.val;
3963
+ const e = variant129.val;
3946
3964
  dataView(memory0).setInt8((base) + 52, 2, true);
3947
- var variant32 = e;
3948
- if (variant32 === null || variant32=== undefined) {
3965
+ var {t: v31_0, cardinality: v31_1 } = e;
3966
+ var variant33 = v31_0;
3967
+ if (variant33 === null || variant33=== undefined) {
3949
3968
  dataView(memory0).setInt8((base) + 56, 0, true);
3950
3969
  } else {
3951
- const e = variant32;
3970
+ const e = variant33;
3952
3971
  dataView(memory0).setInt8((base) + 56, 1, true);
3953
3972
 
3954
3973
  var encodeRes = _utf8AllocateAndEncode(e, realloc0, memory0);
3955
- var ptr31= encodeRes.ptr;
3956
- var len31 = encodeRes.len;
3974
+ var ptr32= encodeRes.ptr;
3975
+ var len32 = encodeRes.len;
3957
3976
 
3958
- dataView(memory0).setUint32((base) + 64, len31, true);
3959
- dataView(memory0).setUint32((base) + 60, ptr31, true);
3977
+ dataView(memory0).setUint32((base) + 64, len32, true);
3978
+ dataView(memory0).setUint32((base) + 60, ptr32, true);
3979
+ }
3980
+ var variant35 = v31_1;
3981
+ if (variant35 === null || variant35=== undefined) {
3982
+ dataView(memory0).setInt8((base) + 68, 0, true);
3983
+ } else {
3984
+ const e = variant35;
3985
+ dataView(memory0).setInt8((base) + 68, 1, true);
3986
+ var val34 = e;
3987
+ let enum34;
3988
+ switch (val34) {
3989
+ case 'one': {
3990
+ enum34 = 0;
3991
+ break;
3992
+ }
3993
+ case 'many': {
3994
+ enum34 = 1;
3995
+ break;
3996
+ }
3997
+ case 'parent': {
3998
+ enum34 = 2;
3999
+ break;
4000
+ }
4001
+ case 'children': {
4002
+ enum34 = 3;
4003
+ break;
4004
+ }
4005
+ default: {
4006
+ if ((e) instanceof Error) {
4007
+ console.error(e);
4008
+ }
4009
+
4010
+ throw new TypeError(`"${val34}" is not one of the cases of cardinality`);
4011
+ }
4012
+ }
4013
+ dataView(memory0).setInt8((base) + 69, enum34, true);
3960
4014
  }
3961
4015
  break;
3962
4016
  }
@@ -3989,696 +4043,696 @@ export function instantiate(getCoreModule, imports, instantiateCore = WebAssembl
3989
4043
  break;
3990
4044
  }
3991
4045
  case 'method': {
3992
- const e = variant126.val;
4046
+ const e = variant129.val;
3993
4047
  dataView(memory0).setInt8((base) + 52, 10, true);
3994
- var {normal: v33_0, variadic: v33_1, t: v33_2, procedureBlock: v33_3, body: v33_4 } = e;
3995
- var vec45 = v33_0;
3996
- var len45 = vec45.length;
3997
- var result45 = realloc0(0, 0, 4, len45 * 56);
3998
- if (result45 < 0 || len45 < 0 || len45 > 4793490 || result45 > memory0.buffer.byteLength || len45 > Math.floor((memory0.buffer.byteLength - result45) / 56)) throw new WebAssemblyRuntimeError('wasm trap: out of bounds memory access');
3999
- for (let i = 0; i < vec45.length; i++) {
4000
- const e = vec45[i];
4001
- const base = result45 + i * 56;var {mode: v34_0, name: v34_1, t: v34_2, default: v34_3, declaredAt: v34_4 } = e;
4002
- var val35 = v34_0;
4003
- let enum35;
4004
- switch (val35) {
4048
+ var {normal: v36_0, variadic: v36_1, t: v36_2, procedureBlock: v36_3, body: v36_4 } = e;
4049
+ var vec48 = v36_0;
4050
+ var len48 = vec48.length;
4051
+ var result48 = realloc0(0, 0, 4, len48 * 56);
4052
+ if (result48 < 0 || len48 < 0 || len48 > 4793490 || result48 > memory0.buffer.byteLength || len48 > Math.floor((memory0.buffer.byteLength - result48) / 56)) throw new WebAssemblyRuntimeError('wasm trap: out of bounds memory access');
4053
+ for (let i = 0; i < vec48.length; i++) {
4054
+ const e = vec48[i];
4055
+ const base = result48 + i * 56;var {mode: v37_0, name: v37_1, t: v37_2, default: v37_3, declaredAt: v37_4 } = e;
4056
+ var val38 = v37_0;
4057
+ let enum38;
4058
+ switch (val38) {
4005
4059
  case 'default': {
4006
- enum35 = 0;
4060
+ enum38 = 0;
4007
4061
  break;
4008
4062
  }
4009
4063
  case 'output': {
4010
- enum35 = 1;
4064
+ enum38 = 1;
4011
4065
  break;
4012
4066
  }
4013
4067
  case 'by-ref': {
4014
- enum35 = 2;
4068
+ enum38 = 2;
4015
4069
  break;
4016
4070
  }
4017
4071
  default: {
4018
- if ((v34_0) instanceof Error) {
4019
- console.error(v34_0);
4072
+ if ((v37_0) instanceof Error) {
4073
+ console.error(v37_0);
4020
4074
  }
4021
4075
 
4022
- throw new TypeError(`"${val35}" is not one of the cases of arg-mode`);
4076
+ throw new TypeError(`"${val38}" is not one of the cases of arg-mode`);
4023
4077
  }
4024
4078
  }
4025
- dataView(memory0).setInt8((base) + 0, enum35, true);
4079
+ dataView(memory0).setInt8((base) + 0, enum38, true);
4026
4080
 
4027
- var encodeRes = _utf8AllocateAndEncode(v34_1, realloc0, memory0);
4028
- var ptr36= encodeRes.ptr;
4029
- var len36 = encodeRes.len;
4081
+ var encodeRes = _utf8AllocateAndEncode(v37_1, realloc0, memory0);
4082
+ var ptr39= encodeRes.ptr;
4083
+ var len39 = encodeRes.len;
4030
4084
 
4031
- dataView(memory0).setUint32((base) + 8, len36, true);
4032
- dataView(memory0).setUint32((base) + 4, ptr36, true);
4033
- var variant38 = v34_2;
4034
- if (variant38 === null || variant38=== undefined) {
4085
+ dataView(memory0).setUint32((base) + 8, len39, true);
4086
+ dataView(memory0).setUint32((base) + 4, ptr39, true);
4087
+ var variant41 = v37_2;
4088
+ if (variant41 === null || variant41=== undefined) {
4035
4089
  dataView(memory0).setInt8((base) + 12, 0, true);
4036
4090
  } else {
4037
- const e = variant38;
4091
+ const e = variant41;
4038
4092
  dataView(memory0).setInt8((base) + 12, 1, true);
4039
4093
 
4040
4094
  var encodeRes = _utf8AllocateAndEncode(e, realloc0, memory0);
4041
- var ptr37= encodeRes.ptr;
4042
- var len37 = encodeRes.len;
4095
+ var ptr40= encodeRes.ptr;
4096
+ var len40 = encodeRes.len;
4043
4097
 
4044
- dataView(memory0).setUint32((base) + 20, len37, true);
4045
- dataView(memory0).setUint32((base) + 16, ptr37, true);
4098
+ dataView(memory0).setUint32((base) + 20, len40, true);
4099
+ dataView(memory0).setUint32((base) + 16, ptr40, true);
4046
4100
  }
4047
- var variant40 = v34_3;
4048
- if (variant40 === null || variant40=== undefined) {
4101
+ var variant43 = v37_3;
4102
+ if (variant43 === null || variant43=== undefined) {
4049
4103
  dataView(memory0).setInt8((base) + 24, 0, true);
4050
4104
  } else {
4051
- const e = variant40;
4105
+ const e = variant43;
4052
4106
  dataView(memory0).setInt8((base) + 24, 1, true);
4053
4107
 
4054
4108
  var encodeRes = _utf8AllocateAndEncode(e, realloc0, memory0);
4055
- var ptr39= encodeRes.ptr;
4056
- var len39 = encodeRes.len;
4109
+ var ptr42= encodeRes.ptr;
4110
+ var len42 = encodeRes.len;
4057
4111
 
4058
- dataView(memory0).setUint32((base) + 32, len39, true);
4059
- dataView(memory0).setUint32((base) + 28, ptr39, true);
4112
+ dataView(memory0).setUint32((base) + 32, len42, true);
4113
+ dataView(memory0).setUint32((base) + 28, ptr42, true);
4060
4114
  }
4061
- var variant44 = v34_4;
4062
- if (variant44 === null || variant44=== undefined) {
4115
+ var variant47 = v37_4;
4116
+ if (variant47 === null || variant47=== undefined) {
4063
4117
  dataView(memory0).setInt8((base) + 36, 0, true);
4064
4118
  } else {
4065
- const e = variant44;
4119
+ const e = variant47;
4066
4120
  dataView(memory0).setInt8((base) + 36, 1, true);
4067
- var {start: v41_0, end: v41_1 } = e;
4068
- var {line: v42_0, character: v42_1 } = v41_0;
4069
- dataView(memory0).setInt32((base) + 40, toUint32(v42_0), true);
4070
- dataView(memory0).setInt32((base) + 44, toUint32(v42_1), true);
4071
- var {line: v43_0, character: v43_1 } = v41_1;
4072
- dataView(memory0).setInt32((base) + 48, toUint32(v43_0), true);
4073
- dataView(memory0).setInt32((base) + 52, toUint32(v43_1), true);
4121
+ var {start: v44_0, end: v44_1 } = e;
4122
+ var {line: v45_0, character: v45_1 } = v44_0;
4123
+ dataView(memory0).setInt32((base) + 40, toUint32(v45_0), true);
4124
+ dataView(memory0).setInt32((base) + 44, toUint32(v45_1), true);
4125
+ var {line: v46_0, character: v46_1 } = v44_1;
4126
+ dataView(memory0).setInt32((base) + 48, toUint32(v46_0), true);
4127
+ dataView(memory0).setInt32((base) + 52, toUint32(v46_1), true);
4074
4128
  }
4075
4129
  }
4076
- dataView(memory0).setUint32((base) + 60, len45, true);
4077
- dataView(memory0).setUint32((base) + 56, result45, true);
4078
- var variant55 = v33_1;
4079
- if (variant55 === null || variant55=== undefined) {
4130
+ dataView(memory0).setUint32((base) + 60, len48, true);
4131
+ dataView(memory0).setUint32((base) + 56, result48, true);
4132
+ var variant58 = v36_1;
4133
+ if (variant58 === null || variant58=== undefined) {
4080
4134
  dataView(memory0).setInt8((base) + 64, 0, true);
4081
4135
  } else {
4082
- const e = variant55;
4136
+ const e = variant58;
4083
4137
  dataView(memory0).setInt8((base) + 64, 1, true);
4084
- var {mode: v46_0, name: v46_1, t: v46_2, declaredAt: v46_3 } = e;
4085
- var val47 = v46_0;
4086
- let enum47;
4087
- switch (val47) {
4138
+ var {mode: v49_0, name: v49_1, t: v49_2, declaredAt: v49_3 } = e;
4139
+ var val50 = v49_0;
4140
+ let enum50;
4141
+ switch (val50) {
4088
4142
  case 'default': {
4089
- enum47 = 0;
4143
+ enum50 = 0;
4090
4144
  break;
4091
4145
  }
4092
4146
  case 'output': {
4093
- enum47 = 1;
4147
+ enum50 = 1;
4094
4148
  break;
4095
4149
  }
4096
4150
  case 'by-ref': {
4097
- enum47 = 2;
4151
+ enum50 = 2;
4098
4152
  break;
4099
4153
  }
4100
4154
  default: {
4101
- if ((v46_0) instanceof Error) {
4102
- console.error(v46_0);
4155
+ if ((v49_0) instanceof Error) {
4156
+ console.error(v49_0);
4103
4157
  }
4104
4158
 
4105
- throw new TypeError(`"${val47}" is not one of the cases of arg-mode`);
4159
+ throw new TypeError(`"${val50}" is not one of the cases of arg-mode`);
4106
4160
  }
4107
4161
  }
4108
- dataView(memory0).setInt8((base) + 68, enum47, true);
4162
+ dataView(memory0).setInt8((base) + 68, enum50, true);
4109
4163
 
4110
- var encodeRes = _utf8AllocateAndEncode(v46_1, realloc0, memory0);
4111
- var ptr48= encodeRes.ptr;
4112
- var len48 = encodeRes.len;
4164
+ var encodeRes = _utf8AllocateAndEncode(v49_1, realloc0, memory0);
4165
+ var ptr51= encodeRes.ptr;
4166
+ var len51 = encodeRes.len;
4113
4167
 
4114
- dataView(memory0).setUint32((base) + 76, len48, true);
4115
- dataView(memory0).setUint32((base) + 72, ptr48, true);
4116
- var variant50 = v46_2;
4117
- if (variant50 === null || variant50=== undefined) {
4168
+ dataView(memory0).setUint32((base) + 76, len51, true);
4169
+ dataView(memory0).setUint32((base) + 72, ptr51, true);
4170
+ var variant53 = v49_2;
4171
+ if (variant53 === null || variant53=== undefined) {
4118
4172
  dataView(memory0).setInt8((base) + 80, 0, true);
4119
4173
  } else {
4120
- const e = variant50;
4174
+ const e = variant53;
4121
4175
  dataView(memory0).setInt8((base) + 80, 1, true);
4122
4176
 
4123
4177
  var encodeRes = _utf8AllocateAndEncode(e, realloc0, memory0);
4124
- var ptr49= encodeRes.ptr;
4125
- var len49 = encodeRes.len;
4178
+ var ptr52= encodeRes.ptr;
4179
+ var len52 = encodeRes.len;
4126
4180
 
4127
- dataView(memory0).setUint32((base) + 88, len49, true);
4128
- dataView(memory0).setUint32((base) + 84, ptr49, true);
4181
+ dataView(memory0).setUint32((base) + 88, len52, true);
4182
+ dataView(memory0).setUint32((base) + 84, ptr52, true);
4129
4183
  }
4130
- var variant54 = v46_3;
4131
- if (variant54 === null || variant54=== undefined) {
4184
+ var variant57 = v49_3;
4185
+ if (variant57 === null || variant57=== undefined) {
4132
4186
  dataView(memory0).setInt8((base) + 92, 0, true);
4133
4187
  } else {
4134
- const e = variant54;
4188
+ const e = variant57;
4135
4189
  dataView(memory0).setInt8((base) + 92, 1, true);
4136
- var {start: v51_0, end: v51_1 } = e;
4137
- var {line: v52_0, character: v52_1 } = v51_0;
4138
- dataView(memory0).setInt32((base) + 96, toUint32(v52_0), true);
4139
- dataView(memory0).setInt32((base) + 100, toUint32(v52_1), true);
4140
- var {line: v53_0, character: v53_1 } = v51_1;
4141
- dataView(memory0).setInt32((base) + 104, toUint32(v53_0), true);
4142
- dataView(memory0).setInt32((base) + 108, toUint32(v53_1), true);
4190
+ var {start: v54_0, end: v54_1 } = e;
4191
+ var {line: v55_0, character: v55_1 } = v54_0;
4192
+ dataView(memory0).setInt32((base) + 96, toUint32(v55_0), true);
4193
+ dataView(memory0).setInt32((base) + 100, toUint32(v55_1), true);
4194
+ var {line: v56_0, character: v56_1 } = v54_1;
4195
+ dataView(memory0).setInt32((base) + 104, toUint32(v56_0), true);
4196
+ dataView(memory0).setInt32((base) + 108, toUint32(v56_1), true);
4143
4197
  }
4144
4198
  }
4145
- var variant57 = v33_2;
4146
- if (variant57 === null || variant57=== undefined) {
4199
+ var variant60 = v36_2;
4200
+ if (variant60 === null || variant60=== undefined) {
4147
4201
  dataView(memory0).setInt8((base) + 112, 0, true);
4148
4202
  } else {
4149
- const e = variant57;
4203
+ const e = variant60;
4150
4204
  dataView(memory0).setInt8((base) + 112, 1, true);
4151
4205
 
4152
4206
  var encodeRes = _utf8AllocateAndEncode(e, realloc0, memory0);
4153
- var ptr56= encodeRes.ptr;
4154
- var len56 = encodeRes.len;
4207
+ var ptr59= encodeRes.ptr;
4208
+ var len59 = encodeRes.len;
4155
4209
 
4156
- dataView(memory0).setUint32((base) + 120, len56, true);
4157
- dataView(memory0).setUint32((base) + 116, ptr56, true);
4210
+ dataView(memory0).setUint32((base) + 120, len59, true);
4211
+ dataView(memory0).setUint32((base) + 116, ptr59, true);
4158
4212
  }
4159
- var variant60 = v33_3;
4160
- if (variant60 === null || variant60=== undefined) {
4213
+ var variant63 = v36_3;
4214
+ if (variant63 === null || variant63=== undefined) {
4161
4215
  dataView(memory0).setInt8((base) + 124, 0, true);
4162
4216
  } else {
4163
- const e = variant60;
4217
+ const e = variant63;
4164
4218
  dataView(memory0).setInt8((base) + 124, 1, true);
4165
- var vec59 = e;
4166
- var len59 = vec59.length;
4167
- var result59 = realloc0(0, 0, 4, len59 * 8);
4168
- if (result59 < 0 || len59 < 0 || len59 > 33554431 || result59 > memory0.buffer.byteLength || len59 > Math.floor((memory0.buffer.byteLength - result59) / 8)) throw new WebAssemblyRuntimeError('wasm trap: out of bounds memory access');
4169
- for (let i = 0; i < vec59.length; i++) {
4170
- const e = vec59[i];
4171
- const base = result59 + i * 8;
4219
+ var vec62 = e;
4220
+ var len62 = vec62.length;
4221
+ var result62 = realloc0(0, 0, 4, len62 * 8);
4222
+ if (result62 < 0 || len62 < 0 || len62 > 33554431 || result62 > memory0.buffer.byteLength || len62 > Math.floor((memory0.buffer.byteLength - result62) / 8)) throw new WebAssemblyRuntimeError('wasm trap: out of bounds memory access');
4223
+ for (let i = 0; i < vec62.length; i++) {
4224
+ const e = vec62[i];
4225
+ const base = result62 + i * 8;
4172
4226
  var encodeRes = _utf8AllocateAndEncode(e, realloc0, memory0);
4173
- var ptr58= encodeRes.ptr;
4174
- var len58 = encodeRes.len;
4227
+ var ptr61= encodeRes.ptr;
4228
+ var len61 = encodeRes.len;
4175
4229
 
4176
- dataView(memory0).setUint32((base) + 4, len58, true);
4177
- dataView(memory0).setUint32((base) + 0, ptr58, true);
4230
+ dataView(memory0).setUint32((base) + 4, len61, true);
4231
+ dataView(memory0).setUint32((base) + 0, ptr61, true);
4178
4232
  }
4179
- dataView(memory0).setUint32((base) + 132, len59, true);
4180
- dataView(memory0).setUint32((base) + 128, result59, true);
4233
+ dataView(memory0).setUint32((base) + 132, len62, true);
4234
+ dataView(memory0).setUint32((base) + 128, result62, true);
4181
4235
  }
4182
- var {start: v61_0, end: v61_1 } = v33_4;
4183
- var {line: v62_0, character: v62_1 } = v61_0;
4184
- dataView(memory0).setInt32((base) + 136, toUint32(v62_0), true);
4185
- dataView(memory0).setInt32((base) + 140, toUint32(v62_1), true);
4186
- var {line: v63_0, character: v63_1 } = v61_1;
4187
- dataView(memory0).setInt32((base) + 144, toUint32(v63_0), true);
4188
- dataView(memory0).setInt32((base) + 148, toUint32(v63_1), true);
4236
+ var {start: v64_0, end: v64_1 } = v36_4;
4237
+ var {line: v65_0, character: v65_1 } = v64_0;
4238
+ dataView(memory0).setInt32((base) + 136, toUint32(v65_0), true);
4239
+ dataView(memory0).setInt32((base) + 140, toUint32(v65_1), true);
4240
+ var {line: v66_0, character: v66_1 } = v64_1;
4241
+ dataView(memory0).setInt32((base) + 144, toUint32(v66_0), true);
4242
+ dataView(memory0).setInt32((base) + 148, toUint32(v66_1), true);
4189
4243
  break;
4190
4244
  }
4191
4245
  case 'class-method': {
4192
- const e = variant126.val;
4246
+ const e = variant129.val;
4193
4247
  dataView(memory0).setInt8((base) + 52, 11, true);
4194
- var {normal: v64_0, variadic: v64_1, t: v64_2, procedureBlock: v64_3, body: v64_4 } = e;
4195
- var vec76 = v64_0;
4196
- var len76 = vec76.length;
4197
- var result76 = realloc0(0, 0, 4, len76 * 56);
4198
- if (result76 < 0 || len76 < 0 || len76 > 4793490 || result76 > memory0.buffer.byteLength || len76 > Math.floor((memory0.buffer.byteLength - result76) / 56)) throw new WebAssemblyRuntimeError('wasm trap: out of bounds memory access');
4199
- for (let i = 0; i < vec76.length; i++) {
4200
- const e = vec76[i];
4201
- const base = result76 + i * 56;var {mode: v65_0, name: v65_1, t: v65_2, default: v65_3, declaredAt: v65_4 } = e;
4202
- var val66 = v65_0;
4203
- let enum66;
4204
- switch (val66) {
4248
+ var {normal: v67_0, variadic: v67_1, t: v67_2, procedureBlock: v67_3, body: v67_4 } = e;
4249
+ var vec79 = v67_0;
4250
+ var len79 = vec79.length;
4251
+ var result79 = realloc0(0, 0, 4, len79 * 56);
4252
+ if (result79 < 0 || len79 < 0 || len79 > 4793490 || result79 > memory0.buffer.byteLength || len79 > Math.floor((memory0.buffer.byteLength - result79) / 56)) throw new WebAssemblyRuntimeError('wasm trap: out of bounds memory access');
4253
+ for (let i = 0; i < vec79.length; i++) {
4254
+ const e = vec79[i];
4255
+ const base = result79 + i * 56;var {mode: v68_0, name: v68_1, t: v68_2, default: v68_3, declaredAt: v68_4 } = e;
4256
+ var val69 = v68_0;
4257
+ let enum69;
4258
+ switch (val69) {
4205
4259
  case 'default': {
4206
- enum66 = 0;
4260
+ enum69 = 0;
4207
4261
  break;
4208
4262
  }
4209
4263
  case 'output': {
4210
- enum66 = 1;
4264
+ enum69 = 1;
4211
4265
  break;
4212
4266
  }
4213
4267
  case 'by-ref': {
4214
- enum66 = 2;
4268
+ enum69 = 2;
4215
4269
  break;
4216
4270
  }
4217
4271
  default: {
4218
- if ((v65_0) instanceof Error) {
4219
- console.error(v65_0);
4272
+ if ((v68_0) instanceof Error) {
4273
+ console.error(v68_0);
4220
4274
  }
4221
4275
 
4222
- throw new TypeError(`"${val66}" is not one of the cases of arg-mode`);
4276
+ throw new TypeError(`"${val69}" is not one of the cases of arg-mode`);
4223
4277
  }
4224
4278
  }
4225
- dataView(memory0).setInt8((base) + 0, enum66, true);
4279
+ dataView(memory0).setInt8((base) + 0, enum69, true);
4226
4280
 
4227
- var encodeRes = _utf8AllocateAndEncode(v65_1, realloc0, memory0);
4228
- var ptr67= encodeRes.ptr;
4229
- var len67 = encodeRes.len;
4281
+ var encodeRes = _utf8AllocateAndEncode(v68_1, realloc0, memory0);
4282
+ var ptr70= encodeRes.ptr;
4283
+ var len70 = encodeRes.len;
4230
4284
 
4231
- dataView(memory0).setUint32((base) + 8, len67, true);
4232
- dataView(memory0).setUint32((base) + 4, ptr67, true);
4233
- var variant69 = v65_2;
4234
- if (variant69 === null || variant69=== undefined) {
4285
+ dataView(memory0).setUint32((base) + 8, len70, true);
4286
+ dataView(memory0).setUint32((base) + 4, ptr70, true);
4287
+ var variant72 = v68_2;
4288
+ if (variant72 === null || variant72=== undefined) {
4235
4289
  dataView(memory0).setInt8((base) + 12, 0, true);
4236
4290
  } else {
4237
- const e = variant69;
4291
+ const e = variant72;
4238
4292
  dataView(memory0).setInt8((base) + 12, 1, true);
4239
4293
 
4240
4294
  var encodeRes = _utf8AllocateAndEncode(e, realloc0, memory0);
4241
- var ptr68= encodeRes.ptr;
4242
- var len68 = encodeRes.len;
4295
+ var ptr71= encodeRes.ptr;
4296
+ var len71 = encodeRes.len;
4243
4297
 
4244
- dataView(memory0).setUint32((base) + 20, len68, true);
4245
- dataView(memory0).setUint32((base) + 16, ptr68, true);
4298
+ dataView(memory0).setUint32((base) + 20, len71, true);
4299
+ dataView(memory0).setUint32((base) + 16, ptr71, true);
4246
4300
  }
4247
- var variant71 = v65_3;
4248
- if (variant71 === null || variant71=== undefined) {
4301
+ var variant74 = v68_3;
4302
+ if (variant74 === null || variant74=== undefined) {
4249
4303
  dataView(memory0).setInt8((base) + 24, 0, true);
4250
4304
  } else {
4251
- const e = variant71;
4305
+ const e = variant74;
4252
4306
  dataView(memory0).setInt8((base) + 24, 1, true);
4253
4307
 
4254
4308
  var encodeRes = _utf8AllocateAndEncode(e, realloc0, memory0);
4255
- var ptr70= encodeRes.ptr;
4256
- var len70 = encodeRes.len;
4309
+ var ptr73= encodeRes.ptr;
4310
+ var len73 = encodeRes.len;
4257
4311
 
4258
- dataView(memory0).setUint32((base) + 32, len70, true);
4259
- dataView(memory0).setUint32((base) + 28, ptr70, true);
4312
+ dataView(memory0).setUint32((base) + 32, len73, true);
4313
+ dataView(memory0).setUint32((base) + 28, ptr73, true);
4260
4314
  }
4261
- var variant75 = v65_4;
4262
- if (variant75 === null || variant75=== undefined) {
4315
+ var variant78 = v68_4;
4316
+ if (variant78 === null || variant78=== undefined) {
4263
4317
  dataView(memory0).setInt8((base) + 36, 0, true);
4264
4318
  } else {
4265
- const e = variant75;
4319
+ const e = variant78;
4266
4320
  dataView(memory0).setInt8((base) + 36, 1, true);
4267
- var {start: v72_0, end: v72_1 } = e;
4268
- var {line: v73_0, character: v73_1 } = v72_0;
4269
- dataView(memory0).setInt32((base) + 40, toUint32(v73_0), true);
4270
- dataView(memory0).setInt32((base) + 44, toUint32(v73_1), true);
4271
- var {line: v74_0, character: v74_1 } = v72_1;
4272
- dataView(memory0).setInt32((base) + 48, toUint32(v74_0), true);
4273
- dataView(memory0).setInt32((base) + 52, toUint32(v74_1), true);
4321
+ var {start: v75_0, end: v75_1 } = e;
4322
+ var {line: v76_0, character: v76_1 } = v75_0;
4323
+ dataView(memory0).setInt32((base) + 40, toUint32(v76_0), true);
4324
+ dataView(memory0).setInt32((base) + 44, toUint32(v76_1), true);
4325
+ var {line: v77_0, character: v77_1 } = v75_1;
4326
+ dataView(memory0).setInt32((base) + 48, toUint32(v77_0), true);
4327
+ dataView(memory0).setInt32((base) + 52, toUint32(v77_1), true);
4274
4328
  }
4275
4329
  }
4276
- dataView(memory0).setUint32((base) + 60, len76, true);
4277
- dataView(memory0).setUint32((base) + 56, result76, true);
4278
- var variant86 = v64_1;
4279
- if (variant86 === null || variant86=== undefined) {
4330
+ dataView(memory0).setUint32((base) + 60, len79, true);
4331
+ dataView(memory0).setUint32((base) + 56, result79, true);
4332
+ var variant89 = v67_1;
4333
+ if (variant89 === null || variant89=== undefined) {
4280
4334
  dataView(memory0).setInt8((base) + 64, 0, true);
4281
4335
  } else {
4282
- const e = variant86;
4336
+ const e = variant89;
4283
4337
  dataView(memory0).setInt8((base) + 64, 1, true);
4284
- var {mode: v77_0, name: v77_1, t: v77_2, declaredAt: v77_3 } = e;
4285
- var val78 = v77_0;
4286
- let enum78;
4287
- switch (val78) {
4338
+ var {mode: v80_0, name: v80_1, t: v80_2, declaredAt: v80_3 } = e;
4339
+ var val81 = v80_0;
4340
+ let enum81;
4341
+ switch (val81) {
4288
4342
  case 'default': {
4289
- enum78 = 0;
4343
+ enum81 = 0;
4290
4344
  break;
4291
4345
  }
4292
4346
  case 'output': {
4293
- enum78 = 1;
4347
+ enum81 = 1;
4294
4348
  break;
4295
4349
  }
4296
4350
  case 'by-ref': {
4297
- enum78 = 2;
4351
+ enum81 = 2;
4298
4352
  break;
4299
4353
  }
4300
4354
  default: {
4301
- if ((v77_0) instanceof Error) {
4302
- console.error(v77_0);
4355
+ if ((v80_0) instanceof Error) {
4356
+ console.error(v80_0);
4303
4357
  }
4304
4358
 
4305
- throw new TypeError(`"${val78}" is not one of the cases of arg-mode`);
4359
+ throw new TypeError(`"${val81}" is not one of the cases of arg-mode`);
4306
4360
  }
4307
4361
  }
4308
- dataView(memory0).setInt8((base) + 68, enum78, true);
4362
+ dataView(memory0).setInt8((base) + 68, enum81, true);
4309
4363
 
4310
- var encodeRes = _utf8AllocateAndEncode(v77_1, realloc0, memory0);
4311
- var ptr79= encodeRes.ptr;
4312
- var len79 = encodeRes.len;
4364
+ var encodeRes = _utf8AllocateAndEncode(v80_1, realloc0, memory0);
4365
+ var ptr82= encodeRes.ptr;
4366
+ var len82 = encodeRes.len;
4313
4367
 
4314
- dataView(memory0).setUint32((base) + 76, len79, true);
4315
- dataView(memory0).setUint32((base) + 72, ptr79, true);
4316
- var variant81 = v77_2;
4317
- if (variant81 === null || variant81=== undefined) {
4368
+ dataView(memory0).setUint32((base) + 76, len82, true);
4369
+ dataView(memory0).setUint32((base) + 72, ptr82, true);
4370
+ var variant84 = v80_2;
4371
+ if (variant84 === null || variant84=== undefined) {
4318
4372
  dataView(memory0).setInt8((base) + 80, 0, true);
4319
4373
  } else {
4320
- const e = variant81;
4374
+ const e = variant84;
4321
4375
  dataView(memory0).setInt8((base) + 80, 1, true);
4322
4376
 
4323
4377
  var encodeRes = _utf8AllocateAndEncode(e, realloc0, memory0);
4324
- var ptr80= encodeRes.ptr;
4325
- var len80 = encodeRes.len;
4378
+ var ptr83= encodeRes.ptr;
4379
+ var len83 = encodeRes.len;
4326
4380
 
4327
- dataView(memory0).setUint32((base) + 88, len80, true);
4328
- dataView(memory0).setUint32((base) + 84, ptr80, true);
4381
+ dataView(memory0).setUint32((base) + 88, len83, true);
4382
+ dataView(memory0).setUint32((base) + 84, ptr83, true);
4329
4383
  }
4330
- var variant85 = v77_3;
4331
- if (variant85 === null || variant85=== undefined) {
4384
+ var variant88 = v80_3;
4385
+ if (variant88 === null || variant88=== undefined) {
4332
4386
  dataView(memory0).setInt8((base) + 92, 0, true);
4333
4387
  } else {
4334
- const e = variant85;
4388
+ const e = variant88;
4335
4389
  dataView(memory0).setInt8((base) + 92, 1, true);
4336
- var {start: v82_0, end: v82_1 } = e;
4337
- var {line: v83_0, character: v83_1 } = v82_0;
4338
- dataView(memory0).setInt32((base) + 96, toUint32(v83_0), true);
4339
- dataView(memory0).setInt32((base) + 100, toUint32(v83_1), true);
4340
- var {line: v84_0, character: v84_1 } = v82_1;
4341
- dataView(memory0).setInt32((base) + 104, toUint32(v84_0), true);
4342
- dataView(memory0).setInt32((base) + 108, toUint32(v84_1), true);
4390
+ var {start: v85_0, end: v85_1 } = e;
4391
+ var {line: v86_0, character: v86_1 } = v85_0;
4392
+ dataView(memory0).setInt32((base) + 96, toUint32(v86_0), true);
4393
+ dataView(memory0).setInt32((base) + 100, toUint32(v86_1), true);
4394
+ var {line: v87_0, character: v87_1 } = v85_1;
4395
+ dataView(memory0).setInt32((base) + 104, toUint32(v87_0), true);
4396
+ dataView(memory0).setInt32((base) + 108, toUint32(v87_1), true);
4343
4397
  }
4344
4398
  }
4345
- var variant88 = v64_2;
4346
- if (variant88 === null || variant88=== undefined) {
4399
+ var variant91 = v67_2;
4400
+ if (variant91 === null || variant91=== undefined) {
4347
4401
  dataView(memory0).setInt8((base) + 112, 0, true);
4348
4402
  } else {
4349
- const e = variant88;
4403
+ const e = variant91;
4350
4404
  dataView(memory0).setInt8((base) + 112, 1, true);
4351
4405
 
4352
4406
  var encodeRes = _utf8AllocateAndEncode(e, realloc0, memory0);
4353
- var ptr87= encodeRes.ptr;
4354
- var len87 = encodeRes.len;
4407
+ var ptr90= encodeRes.ptr;
4408
+ var len90 = encodeRes.len;
4355
4409
 
4356
- dataView(memory0).setUint32((base) + 120, len87, true);
4357
- dataView(memory0).setUint32((base) + 116, ptr87, true);
4410
+ dataView(memory0).setUint32((base) + 120, len90, true);
4411
+ dataView(memory0).setUint32((base) + 116, ptr90, true);
4358
4412
  }
4359
- var variant91 = v64_3;
4360
- if (variant91 === null || variant91=== undefined) {
4413
+ var variant94 = v67_3;
4414
+ if (variant94 === null || variant94=== undefined) {
4361
4415
  dataView(memory0).setInt8((base) + 124, 0, true);
4362
4416
  } else {
4363
- const e = variant91;
4417
+ const e = variant94;
4364
4418
  dataView(memory0).setInt8((base) + 124, 1, true);
4365
- var vec90 = e;
4366
- var len90 = vec90.length;
4367
- var result90 = realloc0(0, 0, 4, len90 * 8);
4368
- if (result90 < 0 || len90 < 0 || len90 > 33554431 || result90 > memory0.buffer.byteLength || len90 > Math.floor((memory0.buffer.byteLength - result90) / 8)) throw new WebAssemblyRuntimeError('wasm trap: out of bounds memory access');
4369
- for (let i = 0; i < vec90.length; i++) {
4370
- const e = vec90[i];
4371
- const base = result90 + i * 8;
4419
+ var vec93 = e;
4420
+ var len93 = vec93.length;
4421
+ var result93 = realloc0(0, 0, 4, len93 * 8);
4422
+ if (result93 < 0 || len93 < 0 || len93 > 33554431 || result93 > memory0.buffer.byteLength || len93 > Math.floor((memory0.buffer.byteLength - result93) / 8)) throw new WebAssemblyRuntimeError('wasm trap: out of bounds memory access');
4423
+ for (let i = 0; i < vec93.length; i++) {
4424
+ const e = vec93[i];
4425
+ const base = result93 + i * 8;
4372
4426
  var encodeRes = _utf8AllocateAndEncode(e, realloc0, memory0);
4373
- var ptr89= encodeRes.ptr;
4374
- var len89 = encodeRes.len;
4427
+ var ptr92= encodeRes.ptr;
4428
+ var len92 = encodeRes.len;
4375
4429
 
4376
- dataView(memory0).setUint32((base) + 4, len89, true);
4377
- dataView(memory0).setUint32((base) + 0, ptr89, true);
4430
+ dataView(memory0).setUint32((base) + 4, len92, true);
4431
+ dataView(memory0).setUint32((base) + 0, ptr92, true);
4378
4432
  }
4379
- dataView(memory0).setUint32((base) + 132, len90, true);
4380
- dataView(memory0).setUint32((base) + 128, result90, true);
4433
+ dataView(memory0).setUint32((base) + 132, len93, true);
4434
+ dataView(memory0).setUint32((base) + 128, result93, true);
4381
4435
  }
4382
- var {start: v92_0, end: v92_1 } = v64_4;
4383
- var {line: v93_0, character: v93_1 } = v92_0;
4384
- dataView(memory0).setInt32((base) + 136, toUint32(v93_0), true);
4385
- dataView(memory0).setInt32((base) + 140, toUint32(v93_1), true);
4386
- var {line: v94_0, character: v94_1 } = v92_1;
4387
- dataView(memory0).setInt32((base) + 144, toUint32(v94_0), true);
4388
- dataView(memory0).setInt32((base) + 148, toUint32(v94_1), true);
4436
+ var {start: v95_0, end: v95_1 } = v67_4;
4437
+ var {line: v96_0, character: v96_1 } = v95_0;
4438
+ dataView(memory0).setInt32((base) + 136, toUint32(v96_0), true);
4439
+ dataView(memory0).setInt32((base) + 140, toUint32(v96_1), true);
4440
+ var {line: v97_0, character: v97_1 } = v95_1;
4441
+ dataView(memory0).setInt32((base) + 144, toUint32(v97_0), true);
4442
+ dataView(memory0).setInt32((base) + 148, toUint32(v97_1), true);
4389
4443
  break;
4390
4444
  }
4391
4445
  case 'client-method': {
4392
- const e = variant126.val;
4446
+ const e = variant129.val;
4393
4447
  dataView(memory0).setInt8((base) + 52, 12, true);
4394
- var {normal: v95_0, variadic: v95_1, t: v95_2, procedureBlock: v95_3, body: v95_4 } = e;
4395
- var vec107 = v95_0;
4396
- var len107 = vec107.length;
4397
- var result107 = realloc0(0, 0, 4, len107 * 56);
4398
- if (result107 < 0 || len107 < 0 || len107 > 4793490 || result107 > memory0.buffer.byteLength || len107 > Math.floor((memory0.buffer.byteLength - result107) / 56)) throw new WebAssemblyRuntimeError('wasm trap: out of bounds memory access');
4399
- for (let i = 0; i < vec107.length; i++) {
4400
- const e = vec107[i];
4401
- const base = result107 + i * 56;var {mode: v96_0, name: v96_1, t: v96_2, default: v96_3, declaredAt: v96_4 } = e;
4402
- var val97 = v96_0;
4403
- let enum97;
4404
- switch (val97) {
4448
+ var {normal: v98_0, variadic: v98_1, t: v98_2, procedureBlock: v98_3, body: v98_4 } = e;
4449
+ var vec110 = v98_0;
4450
+ var len110 = vec110.length;
4451
+ var result110 = realloc0(0, 0, 4, len110 * 56);
4452
+ if (result110 < 0 || len110 < 0 || len110 > 4793490 || result110 > memory0.buffer.byteLength || len110 > Math.floor((memory0.buffer.byteLength - result110) / 56)) throw new WebAssemblyRuntimeError('wasm trap: out of bounds memory access');
4453
+ for (let i = 0; i < vec110.length; i++) {
4454
+ const e = vec110[i];
4455
+ const base = result110 + i * 56;var {mode: v99_0, name: v99_1, t: v99_2, default: v99_3, declaredAt: v99_4 } = e;
4456
+ var val100 = v99_0;
4457
+ let enum100;
4458
+ switch (val100) {
4405
4459
  case 'default': {
4406
- enum97 = 0;
4460
+ enum100 = 0;
4407
4461
  break;
4408
4462
  }
4409
4463
  case 'output': {
4410
- enum97 = 1;
4464
+ enum100 = 1;
4411
4465
  break;
4412
4466
  }
4413
4467
  case 'by-ref': {
4414
- enum97 = 2;
4468
+ enum100 = 2;
4415
4469
  break;
4416
4470
  }
4417
4471
  default: {
4418
- if ((v96_0) instanceof Error) {
4419
- console.error(v96_0);
4472
+ if ((v99_0) instanceof Error) {
4473
+ console.error(v99_0);
4420
4474
  }
4421
4475
 
4422
- throw new TypeError(`"${val97}" is not one of the cases of arg-mode`);
4476
+ throw new TypeError(`"${val100}" is not one of the cases of arg-mode`);
4423
4477
  }
4424
4478
  }
4425
- dataView(memory0).setInt8((base) + 0, enum97, true);
4479
+ dataView(memory0).setInt8((base) + 0, enum100, true);
4426
4480
 
4427
- var encodeRes = _utf8AllocateAndEncode(v96_1, realloc0, memory0);
4428
- var ptr98= encodeRes.ptr;
4429
- var len98 = encodeRes.len;
4481
+ var encodeRes = _utf8AllocateAndEncode(v99_1, realloc0, memory0);
4482
+ var ptr101= encodeRes.ptr;
4483
+ var len101 = encodeRes.len;
4430
4484
 
4431
- dataView(memory0).setUint32((base) + 8, len98, true);
4432
- dataView(memory0).setUint32((base) + 4, ptr98, true);
4433
- var variant100 = v96_2;
4434
- if (variant100 === null || variant100=== undefined) {
4485
+ dataView(memory0).setUint32((base) + 8, len101, true);
4486
+ dataView(memory0).setUint32((base) + 4, ptr101, true);
4487
+ var variant103 = v99_2;
4488
+ if (variant103 === null || variant103=== undefined) {
4435
4489
  dataView(memory0).setInt8((base) + 12, 0, true);
4436
4490
  } else {
4437
- const e = variant100;
4491
+ const e = variant103;
4438
4492
  dataView(memory0).setInt8((base) + 12, 1, true);
4439
4493
 
4440
4494
  var encodeRes = _utf8AllocateAndEncode(e, realloc0, memory0);
4441
- var ptr99= encodeRes.ptr;
4442
- var len99 = encodeRes.len;
4495
+ var ptr102= encodeRes.ptr;
4496
+ var len102 = encodeRes.len;
4443
4497
 
4444
- dataView(memory0).setUint32((base) + 20, len99, true);
4445
- dataView(memory0).setUint32((base) + 16, ptr99, true);
4498
+ dataView(memory0).setUint32((base) + 20, len102, true);
4499
+ dataView(memory0).setUint32((base) + 16, ptr102, true);
4446
4500
  }
4447
- var variant102 = v96_3;
4448
- if (variant102 === null || variant102=== undefined) {
4501
+ var variant105 = v99_3;
4502
+ if (variant105 === null || variant105=== undefined) {
4449
4503
  dataView(memory0).setInt8((base) + 24, 0, true);
4450
4504
  } else {
4451
- const e = variant102;
4505
+ const e = variant105;
4452
4506
  dataView(memory0).setInt8((base) + 24, 1, true);
4453
4507
 
4454
4508
  var encodeRes = _utf8AllocateAndEncode(e, realloc0, memory0);
4455
- var ptr101= encodeRes.ptr;
4456
- var len101 = encodeRes.len;
4509
+ var ptr104= encodeRes.ptr;
4510
+ var len104 = encodeRes.len;
4457
4511
 
4458
- dataView(memory0).setUint32((base) + 32, len101, true);
4459
- dataView(memory0).setUint32((base) + 28, ptr101, true);
4512
+ dataView(memory0).setUint32((base) + 32, len104, true);
4513
+ dataView(memory0).setUint32((base) + 28, ptr104, true);
4460
4514
  }
4461
- var variant106 = v96_4;
4462
- if (variant106 === null || variant106=== undefined) {
4515
+ var variant109 = v99_4;
4516
+ if (variant109 === null || variant109=== undefined) {
4463
4517
  dataView(memory0).setInt8((base) + 36, 0, true);
4464
4518
  } else {
4465
- const e = variant106;
4519
+ const e = variant109;
4466
4520
  dataView(memory0).setInt8((base) + 36, 1, true);
4467
- var {start: v103_0, end: v103_1 } = e;
4468
- var {line: v104_0, character: v104_1 } = v103_0;
4469
- dataView(memory0).setInt32((base) + 40, toUint32(v104_0), true);
4470
- dataView(memory0).setInt32((base) + 44, toUint32(v104_1), true);
4471
- var {line: v105_0, character: v105_1 } = v103_1;
4472
- dataView(memory0).setInt32((base) + 48, toUint32(v105_0), true);
4473
- dataView(memory0).setInt32((base) + 52, toUint32(v105_1), true);
4521
+ var {start: v106_0, end: v106_1 } = e;
4522
+ var {line: v107_0, character: v107_1 } = v106_0;
4523
+ dataView(memory0).setInt32((base) + 40, toUint32(v107_0), true);
4524
+ dataView(memory0).setInt32((base) + 44, toUint32(v107_1), true);
4525
+ var {line: v108_0, character: v108_1 } = v106_1;
4526
+ dataView(memory0).setInt32((base) + 48, toUint32(v108_0), true);
4527
+ dataView(memory0).setInt32((base) + 52, toUint32(v108_1), true);
4474
4528
  }
4475
4529
  }
4476
- dataView(memory0).setUint32((base) + 60, len107, true);
4477
- dataView(memory0).setUint32((base) + 56, result107, true);
4478
- var variant117 = v95_1;
4479
- if (variant117 === null || variant117=== undefined) {
4530
+ dataView(memory0).setUint32((base) + 60, len110, true);
4531
+ dataView(memory0).setUint32((base) + 56, result110, true);
4532
+ var variant120 = v98_1;
4533
+ if (variant120 === null || variant120=== undefined) {
4480
4534
  dataView(memory0).setInt8((base) + 64, 0, true);
4481
4535
  } else {
4482
- const e = variant117;
4536
+ const e = variant120;
4483
4537
  dataView(memory0).setInt8((base) + 64, 1, true);
4484
- var {mode: v108_0, name: v108_1, t: v108_2, declaredAt: v108_3 } = e;
4485
- var val109 = v108_0;
4486
- let enum109;
4487
- switch (val109) {
4538
+ var {mode: v111_0, name: v111_1, t: v111_2, declaredAt: v111_3 } = e;
4539
+ var val112 = v111_0;
4540
+ let enum112;
4541
+ switch (val112) {
4488
4542
  case 'default': {
4489
- enum109 = 0;
4543
+ enum112 = 0;
4490
4544
  break;
4491
4545
  }
4492
4546
  case 'output': {
4493
- enum109 = 1;
4547
+ enum112 = 1;
4494
4548
  break;
4495
4549
  }
4496
4550
  case 'by-ref': {
4497
- enum109 = 2;
4551
+ enum112 = 2;
4498
4552
  break;
4499
4553
  }
4500
4554
  default: {
4501
- if ((v108_0) instanceof Error) {
4502
- console.error(v108_0);
4555
+ if ((v111_0) instanceof Error) {
4556
+ console.error(v111_0);
4503
4557
  }
4504
4558
 
4505
- throw new TypeError(`"${val109}" is not one of the cases of arg-mode`);
4559
+ throw new TypeError(`"${val112}" is not one of the cases of arg-mode`);
4506
4560
  }
4507
4561
  }
4508
- dataView(memory0).setInt8((base) + 68, enum109, true);
4562
+ dataView(memory0).setInt8((base) + 68, enum112, true);
4509
4563
 
4510
- var encodeRes = _utf8AllocateAndEncode(v108_1, realloc0, memory0);
4511
- var ptr110= encodeRes.ptr;
4512
- var len110 = encodeRes.len;
4564
+ var encodeRes = _utf8AllocateAndEncode(v111_1, realloc0, memory0);
4565
+ var ptr113= encodeRes.ptr;
4566
+ var len113 = encodeRes.len;
4513
4567
 
4514
- dataView(memory0).setUint32((base) + 76, len110, true);
4515
- dataView(memory0).setUint32((base) + 72, ptr110, true);
4516
- var variant112 = v108_2;
4517
- if (variant112 === null || variant112=== undefined) {
4568
+ dataView(memory0).setUint32((base) + 76, len113, true);
4569
+ dataView(memory0).setUint32((base) + 72, ptr113, true);
4570
+ var variant115 = v111_2;
4571
+ if (variant115 === null || variant115=== undefined) {
4518
4572
  dataView(memory0).setInt8((base) + 80, 0, true);
4519
4573
  } else {
4520
- const e = variant112;
4574
+ const e = variant115;
4521
4575
  dataView(memory0).setInt8((base) + 80, 1, true);
4522
4576
 
4523
4577
  var encodeRes = _utf8AllocateAndEncode(e, realloc0, memory0);
4524
- var ptr111= encodeRes.ptr;
4525
- var len111 = encodeRes.len;
4578
+ var ptr114= encodeRes.ptr;
4579
+ var len114 = encodeRes.len;
4526
4580
 
4527
- dataView(memory0).setUint32((base) + 88, len111, true);
4528
- dataView(memory0).setUint32((base) + 84, ptr111, true);
4581
+ dataView(memory0).setUint32((base) + 88, len114, true);
4582
+ dataView(memory0).setUint32((base) + 84, ptr114, true);
4529
4583
  }
4530
- var variant116 = v108_3;
4531
- if (variant116 === null || variant116=== undefined) {
4584
+ var variant119 = v111_3;
4585
+ if (variant119 === null || variant119=== undefined) {
4532
4586
  dataView(memory0).setInt8((base) + 92, 0, true);
4533
4587
  } else {
4534
- const e = variant116;
4588
+ const e = variant119;
4535
4589
  dataView(memory0).setInt8((base) + 92, 1, true);
4536
- var {start: v113_0, end: v113_1 } = e;
4537
- var {line: v114_0, character: v114_1 } = v113_0;
4538
- dataView(memory0).setInt32((base) + 96, toUint32(v114_0), true);
4539
- dataView(memory0).setInt32((base) + 100, toUint32(v114_1), true);
4540
- var {line: v115_0, character: v115_1 } = v113_1;
4541
- dataView(memory0).setInt32((base) + 104, toUint32(v115_0), true);
4542
- dataView(memory0).setInt32((base) + 108, toUint32(v115_1), true);
4590
+ var {start: v116_0, end: v116_1 } = e;
4591
+ var {line: v117_0, character: v117_1 } = v116_0;
4592
+ dataView(memory0).setInt32((base) + 96, toUint32(v117_0), true);
4593
+ dataView(memory0).setInt32((base) + 100, toUint32(v117_1), true);
4594
+ var {line: v118_0, character: v118_1 } = v116_1;
4595
+ dataView(memory0).setInt32((base) + 104, toUint32(v118_0), true);
4596
+ dataView(memory0).setInt32((base) + 108, toUint32(v118_1), true);
4543
4597
  }
4544
4598
  }
4545
- var variant119 = v95_2;
4546
- if (variant119 === null || variant119=== undefined) {
4599
+ var variant122 = v98_2;
4600
+ if (variant122 === null || variant122=== undefined) {
4547
4601
  dataView(memory0).setInt8((base) + 112, 0, true);
4548
4602
  } else {
4549
- const e = variant119;
4603
+ const e = variant122;
4550
4604
  dataView(memory0).setInt8((base) + 112, 1, true);
4551
4605
 
4552
4606
  var encodeRes = _utf8AllocateAndEncode(e, realloc0, memory0);
4553
- var ptr118= encodeRes.ptr;
4554
- var len118 = encodeRes.len;
4607
+ var ptr121= encodeRes.ptr;
4608
+ var len121 = encodeRes.len;
4555
4609
 
4556
- dataView(memory0).setUint32((base) + 120, len118, true);
4557
- dataView(memory0).setUint32((base) + 116, ptr118, true);
4610
+ dataView(memory0).setUint32((base) + 120, len121, true);
4611
+ dataView(memory0).setUint32((base) + 116, ptr121, true);
4558
4612
  }
4559
- var variant122 = v95_3;
4560
- if (variant122 === null || variant122=== undefined) {
4613
+ var variant125 = v98_3;
4614
+ if (variant125 === null || variant125=== undefined) {
4561
4615
  dataView(memory0).setInt8((base) + 124, 0, true);
4562
4616
  } else {
4563
- const e = variant122;
4617
+ const e = variant125;
4564
4618
  dataView(memory0).setInt8((base) + 124, 1, true);
4565
- var vec121 = e;
4566
- var len121 = vec121.length;
4567
- var result121 = realloc0(0, 0, 4, len121 * 8);
4568
- if (result121 < 0 || len121 < 0 || len121 > 33554431 || result121 > memory0.buffer.byteLength || len121 > Math.floor((memory0.buffer.byteLength - result121) / 8)) throw new WebAssemblyRuntimeError('wasm trap: out of bounds memory access');
4569
- for (let i = 0; i < vec121.length; i++) {
4570
- const e = vec121[i];
4571
- const base = result121 + i * 8;
4619
+ var vec124 = e;
4620
+ var len124 = vec124.length;
4621
+ var result124 = realloc0(0, 0, 4, len124 * 8);
4622
+ if (result124 < 0 || len124 < 0 || len124 > 33554431 || result124 > memory0.buffer.byteLength || len124 > Math.floor((memory0.buffer.byteLength - result124) / 8)) throw new WebAssemblyRuntimeError('wasm trap: out of bounds memory access');
4623
+ for (let i = 0; i < vec124.length; i++) {
4624
+ const e = vec124[i];
4625
+ const base = result124 + i * 8;
4572
4626
  var encodeRes = _utf8AllocateAndEncode(e, realloc0, memory0);
4573
- var ptr120= encodeRes.ptr;
4574
- var len120 = encodeRes.len;
4627
+ var ptr123= encodeRes.ptr;
4628
+ var len123 = encodeRes.len;
4575
4629
 
4576
- dataView(memory0).setUint32((base) + 4, len120, true);
4577
- dataView(memory0).setUint32((base) + 0, ptr120, true);
4630
+ dataView(memory0).setUint32((base) + 4, len123, true);
4631
+ dataView(memory0).setUint32((base) + 0, ptr123, true);
4578
4632
  }
4579
- dataView(memory0).setUint32((base) + 132, len121, true);
4580
- dataView(memory0).setUint32((base) + 128, result121, true);
4633
+ dataView(memory0).setUint32((base) + 132, len124, true);
4634
+ dataView(memory0).setUint32((base) + 128, result124, true);
4581
4635
  }
4582
- var {start: v123_0, end: v123_1 } = v95_4;
4583
- var {line: v124_0, character: v124_1 } = v123_0;
4584
- dataView(memory0).setInt32((base) + 136, toUint32(v124_0), true);
4585
- dataView(memory0).setInt32((base) + 140, toUint32(v124_1), true);
4586
- var {line: v125_0, character: v125_1 } = v123_1;
4587
- dataView(memory0).setInt32((base) + 144, toUint32(v125_0), true);
4588
- dataView(memory0).setInt32((base) + 148, toUint32(v125_1), true);
4636
+ var {start: v126_0, end: v126_1 } = v98_4;
4637
+ var {line: v127_0, character: v127_1 } = v126_0;
4638
+ dataView(memory0).setInt32((base) + 136, toUint32(v127_0), true);
4639
+ dataView(memory0).setInt32((base) + 140, toUint32(v127_1), true);
4640
+ var {line: v128_0, character: v128_1 } = v126_1;
4641
+ dataView(memory0).setInt32((base) + 144, toUint32(v128_0), true);
4642
+ dataView(memory0).setInt32((base) + 148, toUint32(v128_1), true);
4589
4643
  break;
4590
4644
  }
4591
4645
  default: {
4592
- throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant126.tag)}\` (received \`${variant126}\`) specified for \`MemberKind\``);
4646
+ throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant129.tag)}\` (received \`${variant129}\`) specified for \`MemberKind\``);
4593
4647
  }
4594
4648
  }
4595
- var {line: v127_0, character: v127_1 } = v12_6;
4596
- dataView(memory0).setInt32((base) + 152, toUint32(v127_0), true);
4597
- dataView(memory0).setInt32((base) + 156, toUint32(v127_1), true);
4598
- var variant129 = v12_7;
4599
- if (variant129 === null || variant129=== undefined) {
4649
+ var {line: v130_0, character: v130_1 } = v12_6;
4650
+ dataView(memory0).setInt32((base) + 152, toUint32(v130_0), true);
4651
+ dataView(memory0).setInt32((base) + 156, toUint32(v130_1), true);
4652
+ var variant132 = v12_7;
4653
+ if (variant132 === null || variant132=== undefined) {
4600
4654
  dataView(memory0).setInt8((base) + 160, 0, true);
4601
4655
  } else {
4602
- const e = variant129;
4656
+ const e = variant132;
4603
4657
  dataView(memory0).setInt8((base) + 160, 1, true);
4604
4658
 
4605
4659
  var encodeRes = _utf8AllocateAndEncode(e, realloc0, memory0);
4606
- var ptr128= encodeRes.ptr;
4607
- var len128 = encodeRes.len;
4660
+ var ptr131= encodeRes.ptr;
4661
+ var len131 = encodeRes.len;
4608
4662
 
4609
- dataView(memory0).setUint32((base) + 168, len128, true);
4610
- dataView(memory0).setUint32((base) + 164, ptr128, true);
4663
+ dataView(memory0).setUint32((base) + 168, len131, true);
4664
+ dataView(memory0).setUint32((base) + 164, ptr131, true);
4611
4665
  }
4612
- var variant131 = v12_8;
4613
- if (variant131 === null || variant131=== undefined) {
4666
+ var variant134 = v12_8;
4667
+ if (variant134 === null || variant134=== undefined) {
4614
4668
  dataView(memory0).setInt8((base) + 172, 0, true);
4615
4669
  } else {
4616
- const e = variant131;
4670
+ const e = variant134;
4617
4671
  dataView(memory0).setInt8((base) + 172, 1, true);
4618
4672
 
4619
4673
  var encodeRes = _utf8AllocateAndEncode(e, realloc0, memory0);
4620
- var ptr130= encodeRes.ptr;
4621
- var len130 = encodeRes.len;
4674
+ var ptr133= encodeRes.ptr;
4675
+ var len133 = encodeRes.len;
4622
4676
 
4623
- dataView(memory0).setUint32((base) + 180, len130, true);
4624
- dataView(memory0).setUint32((base) + 176, ptr130, true);
4677
+ dataView(memory0).setUint32((base) + 180, len133, true);
4678
+ dataView(memory0).setUint32((base) + 176, ptr133, true);
4625
4679
  }
4626
4680
  }
4627
- dataView(memory0).setUint32(((arg3 >>> 0)) + 52, len132, true);
4628
- dataView(memory0).setUint32(((arg3 >>> 0)) + 48, result132, true);
4629
- var vec134 = v4_5;
4630
- var len134 = vec134.length;
4631
- var result134 = realloc0(0, 0, 4, len134 * 8);
4632
- if (result134 < 0 || len134 < 0 || len134 > 33554431 || result134 > memory0.buffer.byteLength || len134 > Math.floor((memory0.buffer.byteLength - result134) / 8)) throw new WebAssemblyRuntimeError('wasm trap: out of bounds memory access');
4633
- for (let i = 0; i < vec134.length; i++) {
4634
- const e = vec134[i];
4635
- const base = result134 + i * 8;
4681
+ dataView(memory0).setUint32(((arg3 >>> 0)) + 52, len135, true);
4682
+ dataView(memory0).setUint32(((arg3 >>> 0)) + 48, result135, true);
4683
+ var vec137 = v4_5;
4684
+ var len137 = vec137.length;
4685
+ var result137 = realloc0(0, 0, 4, len137 * 8);
4686
+ if (result137 < 0 || len137 < 0 || len137 > 33554431 || result137 > memory0.buffer.byteLength || len137 > Math.floor((memory0.buffer.byteLength - result137) / 8)) throw new WebAssemblyRuntimeError('wasm trap: out of bounds memory access');
4687
+ for (let i = 0; i < vec137.length; i++) {
4688
+ const e = vec137[i];
4689
+ const base = result137 + i * 8;
4636
4690
  var encodeRes = _utf8AllocateAndEncode(e, realloc0, memory0);
4637
- var ptr133= encodeRes.ptr;
4638
- var len133 = encodeRes.len;
4691
+ var ptr136= encodeRes.ptr;
4692
+ var len136 = encodeRes.len;
4639
4693
 
4640
- dataView(memory0).setUint32((base) + 4, len133, true);
4641
- dataView(memory0).setUint32((base) + 0, ptr133, true);
4694
+ dataView(memory0).setUint32((base) + 4, len136, true);
4695
+ dataView(memory0).setUint32((base) + 0, ptr136, true);
4642
4696
  }
4643
- dataView(memory0).setUint32(((arg3 >>> 0)) + 60, len134, true);
4644
- dataView(memory0).setUint32(((arg3 >>> 0)) + 56, result134, true);
4645
- var vec136 = v4_6;
4646
- var len136 = vec136.length;
4647
- var result136 = realloc0(0, 0, 4, len136 * 8);
4648
- if (result136 < 0 || len136 < 0 || len136 > 33554431 || result136 > memory0.buffer.byteLength || len136 > Math.floor((memory0.buffer.byteLength - result136) / 8)) throw new WebAssemblyRuntimeError('wasm trap: out of bounds memory access');
4649
- for (let i = 0; i < vec136.length; i++) {
4650
- const e = vec136[i];
4651
- const base = result136 + i * 8;
4697
+ dataView(memory0).setUint32(((arg3 >>> 0)) + 60, len137, true);
4698
+ dataView(memory0).setUint32(((arg3 >>> 0)) + 56, result137, true);
4699
+ var vec139 = v4_6;
4700
+ var len139 = vec139.length;
4701
+ var result139 = realloc0(0, 0, 4, len139 * 8);
4702
+ if (result139 < 0 || len139 < 0 || len139 > 33554431 || result139 > memory0.buffer.byteLength || len139 > Math.floor((memory0.buffer.byteLength - result139) / 8)) throw new WebAssemblyRuntimeError('wasm trap: out of bounds memory access');
4703
+ for (let i = 0; i < vec139.length; i++) {
4704
+ const e = vec139[i];
4705
+ const base = result139 + i * 8;
4652
4706
  var encodeRes = _utf8AllocateAndEncode(e, realloc0, memory0);
4653
- var ptr135= encodeRes.ptr;
4654
- var len135 = encodeRes.len;
4707
+ var ptr138= encodeRes.ptr;
4708
+ var len138 = encodeRes.len;
4655
4709
 
4656
- dataView(memory0).setUint32((base) + 4, len135, true);
4657
- dataView(memory0).setUint32((base) + 0, ptr135, true);
4710
+ dataView(memory0).setUint32((base) + 4, len138, true);
4711
+ dataView(memory0).setUint32((base) + 0, ptr138, true);
4658
4712
  }
4659
- dataView(memory0).setUint32(((arg3 >>> 0)) + 68, len136, true);
4660
- dataView(memory0).setUint32(((arg3 >>> 0)) + 64, result136, true);
4661
- var variant137 = v4_7;
4662
- if (variant137 === null || variant137=== undefined) {
4713
+ dataView(memory0).setUint32(((arg3 >>> 0)) + 68, len139, true);
4714
+ dataView(memory0).setUint32(((arg3 >>> 0)) + 64, result139, true);
4715
+ var variant140 = v4_7;
4716
+ if (variant140 === null || variant140=== undefined) {
4663
4717
  dataView(memory0).setInt8(((arg3 >>> 0)) + 72, 0, true);
4664
4718
  } else {
4665
- const e = variant137;
4719
+ const e = variant140;
4666
4720
  dataView(memory0).setInt8(((arg3 >>> 0)) + 72, 1, true);
4667
4721
  dataView(memory0).setInt8(((arg3 >>> 0)) + 73, e ? 1 : 0, true);
4668
4722
  }
4669
- var variant139 = v4_8;
4670
- if (variant139 === null || variant139=== undefined) {
4723
+ var variant142 = v4_8;
4724
+ if (variant142 === null || variant142=== undefined) {
4671
4725
  dataView(memory0).setInt8(((arg3 >>> 0)) + 76, 0, true);
4672
4726
  } else {
4673
- const e = variant139;
4727
+ const e = variant142;
4674
4728
  dataView(memory0).setInt8(((arg3 >>> 0)) + 76, 1, true);
4675
4729
 
4676
4730
  var encodeRes = _utf8AllocateAndEncode(e, realloc0, memory0);
4677
- var ptr138= encodeRes.ptr;
4678
- var len138 = encodeRes.len;
4731
+ var ptr141= encodeRes.ptr;
4732
+ var len141 = encodeRes.len;
4679
4733
 
4680
- dataView(memory0).setUint32(((arg3 >>> 0)) + 84, len138, true);
4681
- dataView(memory0).setUint32(((arg3 >>> 0)) + 80, ptr138, true);
4734
+ dataView(memory0).setUint32(((arg3 >>> 0)) + 84, len141, true);
4735
+ dataView(memory0).setUint32(((arg3 >>> 0)) + 80, ptr141, true);
4682
4736
  }
4683
4737
  }
4684
4738
  _debugLog('[iface="iris:ascot/imported", function="[method]iris-connection.get-cls"][Instruction::Return]', {
@@ -18943,13 +18997,13 @@ export function instantiate(getCoreModule, imports, instantiateCore = WebAssembl
18943
18997
 
18944
18998
  }
18945
18999
 
18946
- var len96 = dataView(memory0).getUint32(((ret >>> 0)) + 4, true);
18947
- var base96 = dataView(memory0).getUint32(((ret >>> 0)) + 0, true) >>> 0;
18948
- if (base96 < 0 || len96 < 0 || len96 > 2917776 || base96 > memory0.buffer.byteLength || len96 > Math.floor((memory0.buffer.byteLength - base96) / 92)) throw new WebAssemblyRuntimeError('wasm trap: out of bounds memory access');
18949
- if (base96 % 4 !== 0) throw new TypeError(`list pointer [${base96}] is not aligned to 4`);
18950
- var result96 = [];
18951
- for (let i = 0; i < len96; i++) {
18952
- const base = base96 + i * 92;
19000
+ var len98 = dataView(memory0).getUint32(((ret >>> 0)) + 4, true);
19001
+ var base98 = dataView(memory0).getUint32(((ret >>> 0)) + 0, true) >>> 0;
19002
+ if (base98 < 0 || len98 < 0 || len98 > 2917776 || base98 > memory0.buffer.byteLength || len98 > Math.floor((memory0.buffer.byteLength - base98) / 92)) throw new WebAssemblyRuntimeError('wasm trap: out of bounds memory access');
19003
+ if (base98 % 4 !== 0) throw new TypeError(`list pointer [${base98}] is not aligned to 4`);
19004
+ var result98 = [];
19005
+ for (let i = 0; i < len98; i++) {
19006
+ const base = base98 + i * 92;
18953
19007
  var ptr3 = dataView(memory0).getUint32((base) + 0, true) >>> 0;
18954
19008
  var len3 = dataView(memory0).getUint32((base) + 4, true);
18955
19009
  var result3 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr3, len3));
@@ -18972,13 +19026,13 @@ export function instantiate(getCoreModule, imports, instantiateCore = WebAssembl
18972
19026
  result7.push(result6);
18973
19027
  }
18974
19028
  var bool8 = dataView(memory0).getUint8((base) + 48, true);
18975
- var len87 = dataView(memory0).getUint32((base) + 56, true);
18976
- var base87 = dataView(memory0).getUint32((base) + 52, true) >>> 0;
18977
- if (base87 < 0 || len87 < 0 || len87 > 1458888 || base87 > memory0.buffer.byteLength || len87 > Math.floor((memory0.buffer.byteLength - base87) / 184)) throw new WebAssemblyRuntimeError('wasm trap: out of bounds memory access');
18978
- if (base87 % 4 !== 0) throw new TypeError(`list pointer [${base87}] is not aligned to 4`);
18979
- var result87 = [];
18980
- for (let i = 0; i < len87; i++) {
18981
- const base = base87 + i * 184;
19029
+ var len89 = dataView(memory0).getUint32((base) + 56, true);
19030
+ var base89 = dataView(memory0).getUint32((base) + 52, true) >>> 0;
19031
+ if (base89 < 0 || len89 < 0 || len89 > 1458888 || base89 > memory0.buffer.byteLength || len89 > Math.floor((memory0.buffer.byteLength - base89) / 184)) throw new WebAssemblyRuntimeError('wasm trap: out of bounds memory access');
19032
+ if (base89 % 4 !== 0) throw new TypeError(`list pointer [${base89}] is not aligned to 4`);
19033
+ var result89 = [];
19034
+ for (let i = 0; i < len89; i++) {
19035
+ const base = base89 + i * 184;
18982
19036
  var ptr9 = dataView(memory0).getUint32((base) + 0, true) >>> 0;
18983
19037
  var len9 = dataView(memory0).getUint32((base) + 4, true);
18984
19038
  var result9 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr9, len9));
@@ -18998,7 +19052,7 @@ export function instantiate(getCoreModule, imports, instantiateCore = WebAssembl
18998
19052
  result12.push(result11);
18999
19053
  }
19000
19054
  var bool13 = dataView(memory0).getUint8((base) + 48, true);
19001
- let variant82;
19055
+ let variant84;
19002
19056
  switch (dataView(memory0).getUint8((base) + 52, true)) {
19003
19057
  case 0: {
19004
19058
  let variant15;
@@ -19035,7 +19089,7 @@ export function instantiate(getCoreModule, imports, instantiateCore = WebAssembl
19035
19089
  throw new TypeError('invalid variant discriminant for option');
19036
19090
  }
19037
19091
  }
19038
- variant82= {
19092
+ variant84= {
19039
19093
  tag: 'parameter',
19040
19094
  val: {
19041
19095
  t: variant15,
@@ -19091,7 +19145,7 @@ export function instantiate(getCoreModule, imports, instantiateCore = WebAssembl
19091
19145
  }
19092
19146
  }
19093
19147
  var bool22 = dataView(memory0).getUint8((base) + 70, true);
19094
- variant82= {
19148
+ variant84= {
19095
19149
  tag: 'property',
19096
19150
  val: {
19097
19151
  t: variant19,
@@ -19119,125 +19173,164 @@ export function instantiate(getCoreModule, imports, instantiateCore = WebAssembl
19119
19173
  throw new TypeError('invalid variant discriminant for option');
19120
19174
  }
19121
19175
  }
19122
- variant82= {
19176
+ let variant26;
19177
+ switch (dataView(memory0).getUint8((base) + 68, true)) {
19178
+ case 0: {
19179
+ variant26 = undefined;
19180
+ break;
19181
+ }
19182
+ case 1: {
19183
+ let enum25;
19184
+ switch (dataView(memory0).getUint8((base) + 69, true)) {
19185
+ case 0: {
19186
+ enum25 = 'one';
19187
+ break;
19188
+ }
19189
+ case 1: {
19190
+ enum25 = 'many';
19191
+ break;
19192
+ }
19193
+ case 2: {
19194
+ enum25 = 'parent';
19195
+ break;
19196
+ }
19197
+ case 3: {
19198
+ enum25 = 'children';
19199
+ break;
19200
+ }
19201
+ default: {
19202
+ throw new TypeError('invalid discriminant specified for Cardinality');
19203
+ }
19204
+ }
19205
+ variant26 = enum25;
19206
+ break;
19207
+ }
19208
+ default: {
19209
+ throw new TypeError('invalid variant discriminant for option');
19210
+ }
19211
+ }
19212
+ variant84= {
19123
19213
  tag: 'relationship',
19124
- val: variant24
19214
+ val: {
19215
+ t: variant24,
19216
+ cardinality: variant26,
19217
+ }
19125
19218
  };
19126
19219
  break;
19127
19220
  }
19128
19221
  case 3: {
19129
- variant82= {
19222
+ variant84= {
19130
19223
  tag: 'foreign-key',
19131
19224
  };
19132
19225
  break;
19133
19226
  }
19134
19227
  case 4: {
19135
- variant82= {
19228
+ variant84= {
19136
19229
  tag: 'index',
19137
19230
  };
19138
19231
  break;
19139
19232
  }
19140
19233
  case 5: {
19141
- variant82= {
19234
+ variant84= {
19142
19235
  tag: 'projection',
19143
19236
  };
19144
19237
  break;
19145
19238
  }
19146
19239
  case 6: {
19147
- variant82= {
19240
+ variant84= {
19148
19241
  tag: 'trigger',
19149
19242
  };
19150
19243
  break;
19151
19244
  }
19152
19245
  case 7: {
19153
- variant82= {
19246
+ variant84= {
19154
19247
  tag: 'x-data',
19155
19248
  };
19156
19249
  break;
19157
19250
  }
19158
19251
  case 8: {
19159
- variant82= {
19252
+ variant84= {
19160
19253
  tag: 'storage',
19161
19254
  };
19162
19255
  break;
19163
19256
  }
19164
19257
  case 9: {
19165
- variant82= {
19258
+ variant84= {
19166
19259
  tag: 'query',
19167
19260
  };
19168
19261
  break;
19169
19262
  }
19170
19263
  case 10: {
19171
- var len32 = dataView(memory0).getUint32((base) + 60, true);
19172
- var base32 = dataView(memory0).getUint32((base) + 56, true) >>> 0;
19173
- if (base32 < 0 || len32 < 0 || len32 > 4793490 || base32 > memory0.buffer.byteLength || len32 > Math.floor((memory0.buffer.byteLength - base32) / 56)) throw new WebAssemblyRuntimeError('wasm trap: out of bounds memory access');
19174
- if (base32 % 4 !== 0) throw new TypeError(`list pointer [${base32}] is not aligned to 4`);
19175
- var result32 = [];
19176
- for (let i = 0; i < len32; i++) {
19177
- const base = base32 + i * 56;
19178
- let enum25;
19264
+ var len34 = dataView(memory0).getUint32((base) + 60, true);
19265
+ var base34 = dataView(memory0).getUint32((base) + 56, true) >>> 0;
19266
+ if (base34 < 0 || len34 < 0 || len34 > 4793490 || base34 > memory0.buffer.byteLength || len34 > Math.floor((memory0.buffer.byteLength - base34) / 56)) throw new WebAssemblyRuntimeError('wasm trap: out of bounds memory access');
19267
+ if (base34 % 4 !== 0) throw new TypeError(`list pointer [${base34}] is not aligned to 4`);
19268
+ var result34 = [];
19269
+ for (let i = 0; i < len34; i++) {
19270
+ const base = base34 + i * 56;
19271
+ let enum27;
19179
19272
  switch (dataView(memory0).getUint8((base) + 0, true)) {
19180
19273
  case 0: {
19181
- enum25 = 'default';
19274
+ enum27 = 'default';
19182
19275
  break;
19183
19276
  }
19184
19277
  case 1: {
19185
- enum25 = 'output';
19278
+ enum27 = 'output';
19186
19279
  break;
19187
19280
  }
19188
19281
  case 2: {
19189
- enum25 = 'by-ref';
19282
+ enum27 = 'by-ref';
19190
19283
  break;
19191
19284
  }
19192
19285
  default: {
19193
19286
  throw new TypeError('invalid discriminant specified for ArgMode');
19194
19287
  }
19195
19288
  }
19196
- var ptr26 = dataView(memory0).getUint32((base) + 4, true) >>> 0;
19197
- var len26 = dataView(memory0).getUint32((base) + 8, true);
19198
- var result26 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr26, len26));
19199
- let variant28;
19289
+ var ptr28 = dataView(memory0).getUint32((base) + 4, true) >>> 0;
19290
+ var len28 = dataView(memory0).getUint32((base) + 8, true);
19291
+ var result28 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr28, len28));
19292
+ let variant30;
19200
19293
  switch (dataView(memory0).getUint8((base) + 12, true)) {
19201
19294
  case 0: {
19202
- variant28 = undefined;
19295
+ variant30 = undefined;
19203
19296
  break;
19204
19297
  }
19205
19298
  case 1: {
19206
- var ptr27 = dataView(memory0).getUint32((base) + 16, true) >>> 0;
19207
- var len27 = dataView(memory0).getUint32((base) + 20, true);
19208
- var result27 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr27, len27));
19209
- variant28 = result27;
19299
+ var ptr29 = dataView(memory0).getUint32((base) + 16, true) >>> 0;
19300
+ var len29 = dataView(memory0).getUint32((base) + 20, true);
19301
+ var result29 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr29, len29));
19302
+ variant30 = result29;
19210
19303
  break;
19211
19304
  }
19212
19305
  default: {
19213
19306
  throw new TypeError('invalid variant discriminant for option');
19214
19307
  }
19215
19308
  }
19216
- let variant30;
19309
+ let variant32;
19217
19310
  switch (dataView(memory0).getUint8((base) + 24, true)) {
19218
19311
  case 0: {
19219
- variant30 = undefined;
19312
+ variant32 = undefined;
19220
19313
  break;
19221
19314
  }
19222
19315
  case 1: {
19223
- var ptr29 = dataView(memory0).getUint32((base) + 28, true) >>> 0;
19224
- var len29 = dataView(memory0).getUint32((base) + 32, true);
19225
- var result29 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr29, len29));
19226
- variant30 = result29;
19316
+ var ptr31 = dataView(memory0).getUint32((base) + 28, true) >>> 0;
19317
+ var len31 = dataView(memory0).getUint32((base) + 32, true);
19318
+ var result31 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr31, len31));
19319
+ variant32 = result31;
19227
19320
  break;
19228
19321
  }
19229
19322
  default: {
19230
19323
  throw new TypeError('invalid variant discriminant for option');
19231
19324
  }
19232
19325
  }
19233
- let variant31;
19326
+ let variant33;
19234
19327
  switch (dataView(memory0).getUint8((base) + 36, true)) {
19235
19328
  case 0: {
19236
- variant31 = undefined;
19329
+ variant33 = undefined;
19237
19330
  break;
19238
19331
  }
19239
19332
  case 1: {
19240
- variant31 = {
19333
+ variant33 = {
19241
19334
  start: {
19242
19335
  line: dataView(memory0).getInt32((base) + 40, true) >>> 0,
19243
19336
  character: dataView(memory0).getInt32((base) + 44, true) >>> 0,
@@ -19253,67 +19346,67 @@ export function instantiate(getCoreModule, imports, instantiateCore = WebAssembl
19253
19346
  throw new TypeError('invalid variant discriminant for option');
19254
19347
  }
19255
19348
  }
19256
- result32.push({
19257
- mode: enum25,
19258
- name: result26,
19259
- t: variant28,
19260
- default: variant30,
19261
- declaredAt: variant31,
19349
+ result34.push({
19350
+ mode: enum27,
19351
+ name: result28,
19352
+ t: variant30,
19353
+ default: variant32,
19354
+ declaredAt: variant33,
19262
19355
  });
19263
19356
  }
19264
- let variant38;
19357
+ let variant40;
19265
19358
  switch (dataView(memory0).getUint8((base) + 64, true)) {
19266
19359
  case 0: {
19267
- variant38 = undefined;
19360
+ variant40 = undefined;
19268
19361
  break;
19269
19362
  }
19270
19363
  case 1: {
19271
- let enum33;
19364
+ let enum35;
19272
19365
  switch (dataView(memory0).getUint8((base) + 68, true)) {
19273
19366
  case 0: {
19274
- enum33 = 'default';
19367
+ enum35 = 'default';
19275
19368
  break;
19276
19369
  }
19277
19370
  case 1: {
19278
- enum33 = 'output';
19371
+ enum35 = 'output';
19279
19372
  break;
19280
19373
  }
19281
19374
  case 2: {
19282
- enum33 = 'by-ref';
19375
+ enum35 = 'by-ref';
19283
19376
  break;
19284
19377
  }
19285
19378
  default: {
19286
19379
  throw new TypeError('invalid discriminant specified for ArgMode');
19287
19380
  }
19288
19381
  }
19289
- var ptr34 = dataView(memory0).getUint32((base) + 72, true) >>> 0;
19290
- var len34 = dataView(memory0).getUint32((base) + 76, true);
19291
- var result34 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr34, len34));
19292
- let variant36;
19382
+ var ptr36 = dataView(memory0).getUint32((base) + 72, true) >>> 0;
19383
+ var len36 = dataView(memory0).getUint32((base) + 76, true);
19384
+ var result36 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr36, len36));
19385
+ let variant38;
19293
19386
  switch (dataView(memory0).getUint8((base) + 80, true)) {
19294
19387
  case 0: {
19295
- variant36 = undefined;
19388
+ variant38 = undefined;
19296
19389
  break;
19297
19390
  }
19298
19391
  case 1: {
19299
- var ptr35 = dataView(memory0).getUint32((base) + 84, true) >>> 0;
19300
- var len35 = dataView(memory0).getUint32((base) + 88, true);
19301
- var result35 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr35, len35));
19302
- variant36 = result35;
19392
+ var ptr37 = dataView(memory0).getUint32((base) + 84, true) >>> 0;
19393
+ var len37 = dataView(memory0).getUint32((base) + 88, true);
19394
+ var result37 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr37, len37));
19395
+ variant38 = result37;
19303
19396
  break;
19304
19397
  }
19305
19398
  default: {
19306
19399
  throw new TypeError('invalid variant discriminant for option');
19307
19400
  }
19308
19401
  }
19309
- let variant37;
19402
+ let variant39;
19310
19403
  switch (dataView(memory0).getUint8((base) + 92, true)) {
19311
19404
  case 0: {
19312
- variant37 = undefined;
19405
+ variant39 = undefined;
19313
19406
  break;
19314
19407
  }
19315
19408
  case 1: {
19316
- variant37 = {
19409
+ variant39 = {
19317
19410
  start: {
19318
19411
  line: dataView(memory0).getInt32((base) + 96, true) >>> 0,
19319
19412
  character: dataView(memory0).getInt32((base) + 100, true) >>> 0,
@@ -19329,11 +19422,11 @@ export function instantiate(getCoreModule, imports, instantiateCore = WebAssembl
19329
19422
  throw new TypeError('invalid variant discriminant for option');
19330
19423
  }
19331
19424
  }
19332
- variant38 = {
19333
- mode: enum33,
19334
- name: result34,
19335
- t: variant36,
19336
- declaredAt: variant37,
19425
+ variant40 = {
19426
+ mode: enum35,
19427
+ name: result36,
19428
+ t: variant38,
19429
+ declaredAt: variant39,
19337
19430
  };
19338
19431
  break;
19339
19432
  }
@@ -19341,56 +19434,56 @@ export function instantiate(getCoreModule, imports, instantiateCore = WebAssembl
19341
19434
  throw new TypeError('invalid variant discriminant for option');
19342
19435
  }
19343
19436
  }
19344
- let variant40;
19437
+ let variant42;
19345
19438
  switch (dataView(memory0).getUint8((base) + 112, true)) {
19346
19439
  case 0: {
19347
- variant40 = undefined;
19440
+ variant42 = undefined;
19348
19441
  break;
19349
19442
  }
19350
19443
  case 1: {
19351
- var ptr39 = dataView(memory0).getUint32((base) + 116, true) >>> 0;
19352
- var len39 = dataView(memory0).getUint32((base) + 120, true);
19353
- var result39 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr39, len39));
19354
- variant40 = result39;
19444
+ var ptr41 = dataView(memory0).getUint32((base) + 116, true) >>> 0;
19445
+ var len41 = dataView(memory0).getUint32((base) + 120, true);
19446
+ var result41 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr41, len41));
19447
+ variant42 = result41;
19355
19448
  break;
19356
19449
  }
19357
19450
  default: {
19358
19451
  throw new TypeError('invalid variant discriminant for option');
19359
19452
  }
19360
19453
  }
19361
- let variant43;
19454
+ let variant45;
19362
19455
  switch (dataView(memory0).getUint8((base) + 124, true)) {
19363
19456
  case 0: {
19364
- variant43 = undefined;
19457
+ variant45 = undefined;
19365
19458
  break;
19366
19459
  }
19367
19460
  case 1: {
19368
- var len42 = dataView(memory0).getUint32((base) + 132, true);
19369
- var base42 = dataView(memory0).getUint32((base) + 128, true) >>> 0;
19370
- if (base42 < 0 || len42 < 0 || len42 > 33554431 || base42 > memory0.buffer.byteLength || len42 > Math.floor((memory0.buffer.byteLength - base42) / 8)) throw new WebAssemblyRuntimeError('wasm trap: out of bounds memory access');
19371
- if (base42 % 4 !== 0) throw new TypeError(`list pointer [${base42}] is not aligned to 4`);
19372
- var result42 = [];
19373
- for (let i = 0; i < len42; i++) {
19374
- const base = base42 + i * 8;
19375
- var ptr41 = dataView(memory0).getUint32((base) + 0, true) >>> 0;
19376
- var len41 = dataView(memory0).getUint32((base) + 4, true);
19377
- var result41 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr41, len41));
19378
- result42.push(result41);
19461
+ var len44 = dataView(memory0).getUint32((base) + 132, true);
19462
+ var base44 = dataView(memory0).getUint32((base) + 128, true) >>> 0;
19463
+ if (base44 < 0 || len44 < 0 || len44 > 33554431 || base44 > memory0.buffer.byteLength || len44 > Math.floor((memory0.buffer.byteLength - base44) / 8)) throw new WebAssemblyRuntimeError('wasm trap: out of bounds memory access');
19464
+ if (base44 % 4 !== 0) throw new TypeError(`list pointer [${base44}] is not aligned to 4`);
19465
+ var result44 = [];
19466
+ for (let i = 0; i < len44; i++) {
19467
+ const base = base44 + i * 8;
19468
+ var ptr43 = dataView(memory0).getUint32((base) + 0, true) >>> 0;
19469
+ var len43 = dataView(memory0).getUint32((base) + 4, true);
19470
+ var result43 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr43, len43));
19471
+ result44.push(result43);
19379
19472
  }
19380
- variant43 = result42;
19473
+ variant45 = result44;
19381
19474
  break;
19382
19475
  }
19383
19476
  default: {
19384
19477
  throw new TypeError('invalid variant discriminant for option');
19385
19478
  }
19386
19479
  }
19387
- variant82= {
19480
+ variant84= {
19388
19481
  tag: 'method',
19389
19482
  val: {
19390
- normal: result32,
19391
- variadic: variant38,
19392
- t: variant40,
19393
- procedureBlock: variant43,
19483
+ normal: result34,
19484
+ variadic: variant40,
19485
+ t: variant42,
19486
+ procedureBlock: variant45,
19394
19487
  body: {
19395
19488
  start: {
19396
19489
  line: dataView(memory0).getInt32((base) + 136, true) >>> 0,
@@ -19406,76 +19499,76 @@ export function instantiate(getCoreModule, imports, instantiateCore = WebAssembl
19406
19499
  break;
19407
19500
  }
19408
19501
  case 11: {
19409
- var len51 = dataView(memory0).getUint32((base) + 60, true);
19410
- var base51 = dataView(memory0).getUint32((base) + 56, true) >>> 0;
19411
- if (base51 < 0 || len51 < 0 || len51 > 4793490 || base51 > memory0.buffer.byteLength || len51 > Math.floor((memory0.buffer.byteLength - base51) / 56)) throw new WebAssemblyRuntimeError('wasm trap: out of bounds memory access');
19412
- if (base51 % 4 !== 0) throw new TypeError(`list pointer [${base51}] is not aligned to 4`);
19413
- var result51 = [];
19414
- for (let i = 0; i < len51; i++) {
19415
- const base = base51 + i * 56;
19416
- let enum44;
19502
+ var len53 = dataView(memory0).getUint32((base) + 60, true);
19503
+ var base53 = dataView(memory0).getUint32((base) + 56, true) >>> 0;
19504
+ if (base53 < 0 || len53 < 0 || len53 > 4793490 || base53 > memory0.buffer.byteLength || len53 > Math.floor((memory0.buffer.byteLength - base53) / 56)) throw new WebAssemblyRuntimeError('wasm trap: out of bounds memory access');
19505
+ if (base53 % 4 !== 0) throw new TypeError(`list pointer [${base53}] is not aligned to 4`);
19506
+ var result53 = [];
19507
+ for (let i = 0; i < len53; i++) {
19508
+ const base = base53 + i * 56;
19509
+ let enum46;
19417
19510
  switch (dataView(memory0).getUint8((base) + 0, true)) {
19418
19511
  case 0: {
19419
- enum44 = 'default';
19512
+ enum46 = 'default';
19420
19513
  break;
19421
19514
  }
19422
19515
  case 1: {
19423
- enum44 = 'output';
19516
+ enum46 = 'output';
19424
19517
  break;
19425
19518
  }
19426
19519
  case 2: {
19427
- enum44 = 'by-ref';
19520
+ enum46 = 'by-ref';
19428
19521
  break;
19429
19522
  }
19430
19523
  default: {
19431
19524
  throw new TypeError('invalid discriminant specified for ArgMode');
19432
19525
  }
19433
19526
  }
19434
- var ptr45 = dataView(memory0).getUint32((base) + 4, true) >>> 0;
19435
- var len45 = dataView(memory0).getUint32((base) + 8, true);
19436
- var result45 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr45, len45));
19437
- let variant47;
19527
+ var ptr47 = dataView(memory0).getUint32((base) + 4, true) >>> 0;
19528
+ var len47 = dataView(memory0).getUint32((base) + 8, true);
19529
+ var result47 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr47, len47));
19530
+ let variant49;
19438
19531
  switch (dataView(memory0).getUint8((base) + 12, true)) {
19439
19532
  case 0: {
19440
- variant47 = undefined;
19533
+ variant49 = undefined;
19441
19534
  break;
19442
19535
  }
19443
19536
  case 1: {
19444
- var ptr46 = dataView(memory0).getUint32((base) + 16, true) >>> 0;
19445
- var len46 = dataView(memory0).getUint32((base) + 20, true);
19446
- var result46 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr46, len46));
19447
- variant47 = result46;
19537
+ var ptr48 = dataView(memory0).getUint32((base) + 16, true) >>> 0;
19538
+ var len48 = dataView(memory0).getUint32((base) + 20, true);
19539
+ var result48 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr48, len48));
19540
+ variant49 = result48;
19448
19541
  break;
19449
19542
  }
19450
19543
  default: {
19451
19544
  throw new TypeError('invalid variant discriminant for option');
19452
19545
  }
19453
19546
  }
19454
- let variant49;
19547
+ let variant51;
19455
19548
  switch (dataView(memory0).getUint8((base) + 24, true)) {
19456
19549
  case 0: {
19457
- variant49 = undefined;
19550
+ variant51 = undefined;
19458
19551
  break;
19459
19552
  }
19460
19553
  case 1: {
19461
- var ptr48 = dataView(memory0).getUint32((base) + 28, true) >>> 0;
19462
- var len48 = dataView(memory0).getUint32((base) + 32, true);
19463
- var result48 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr48, len48));
19464
- variant49 = result48;
19554
+ var ptr50 = dataView(memory0).getUint32((base) + 28, true) >>> 0;
19555
+ var len50 = dataView(memory0).getUint32((base) + 32, true);
19556
+ var result50 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr50, len50));
19557
+ variant51 = result50;
19465
19558
  break;
19466
19559
  }
19467
19560
  default: {
19468
19561
  throw new TypeError('invalid variant discriminant for option');
19469
19562
  }
19470
19563
  }
19471
- let variant50;
19564
+ let variant52;
19472
19565
  switch (dataView(memory0).getUint8((base) + 36, true)) {
19473
19566
  case 0: {
19474
- variant50 = undefined;
19567
+ variant52 = undefined;
19475
19568
  break;
19476
19569
  }
19477
19570
  case 1: {
19478
- variant50 = {
19571
+ variant52 = {
19479
19572
  start: {
19480
19573
  line: dataView(memory0).getInt32((base) + 40, true) >>> 0,
19481
19574
  character: dataView(memory0).getInt32((base) + 44, true) >>> 0,
@@ -19491,67 +19584,67 @@ export function instantiate(getCoreModule, imports, instantiateCore = WebAssembl
19491
19584
  throw new TypeError('invalid variant discriminant for option');
19492
19585
  }
19493
19586
  }
19494
- result51.push({
19495
- mode: enum44,
19496
- name: result45,
19497
- t: variant47,
19498
- default: variant49,
19499
- declaredAt: variant50,
19587
+ result53.push({
19588
+ mode: enum46,
19589
+ name: result47,
19590
+ t: variant49,
19591
+ default: variant51,
19592
+ declaredAt: variant52,
19500
19593
  });
19501
19594
  }
19502
- let variant57;
19595
+ let variant59;
19503
19596
  switch (dataView(memory0).getUint8((base) + 64, true)) {
19504
19597
  case 0: {
19505
- variant57 = undefined;
19598
+ variant59 = undefined;
19506
19599
  break;
19507
19600
  }
19508
19601
  case 1: {
19509
- let enum52;
19602
+ let enum54;
19510
19603
  switch (dataView(memory0).getUint8((base) + 68, true)) {
19511
19604
  case 0: {
19512
- enum52 = 'default';
19605
+ enum54 = 'default';
19513
19606
  break;
19514
19607
  }
19515
19608
  case 1: {
19516
- enum52 = 'output';
19609
+ enum54 = 'output';
19517
19610
  break;
19518
19611
  }
19519
19612
  case 2: {
19520
- enum52 = 'by-ref';
19613
+ enum54 = 'by-ref';
19521
19614
  break;
19522
19615
  }
19523
19616
  default: {
19524
19617
  throw new TypeError('invalid discriminant specified for ArgMode');
19525
19618
  }
19526
19619
  }
19527
- var ptr53 = dataView(memory0).getUint32((base) + 72, true) >>> 0;
19528
- var len53 = dataView(memory0).getUint32((base) + 76, true);
19529
- var result53 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr53, len53));
19530
- let variant55;
19620
+ var ptr55 = dataView(memory0).getUint32((base) + 72, true) >>> 0;
19621
+ var len55 = dataView(memory0).getUint32((base) + 76, true);
19622
+ var result55 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr55, len55));
19623
+ let variant57;
19531
19624
  switch (dataView(memory0).getUint8((base) + 80, true)) {
19532
19625
  case 0: {
19533
- variant55 = undefined;
19626
+ variant57 = undefined;
19534
19627
  break;
19535
19628
  }
19536
19629
  case 1: {
19537
- var ptr54 = dataView(memory0).getUint32((base) + 84, true) >>> 0;
19538
- var len54 = dataView(memory0).getUint32((base) + 88, true);
19539
- var result54 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr54, len54));
19540
- variant55 = result54;
19630
+ var ptr56 = dataView(memory0).getUint32((base) + 84, true) >>> 0;
19631
+ var len56 = dataView(memory0).getUint32((base) + 88, true);
19632
+ var result56 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr56, len56));
19633
+ variant57 = result56;
19541
19634
  break;
19542
19635
  }
19543
19636
  default: {
19544
19637
  throw new TypeError('invalid variant discriminant for option');
19545
19638
  }
19546
19639
  }
19547
- let variant56;
19640
+ let variant58;
19548
19641
  switch (dataView(memory0).getUint8((base) + 92, true)) {
19549
19642
  case 0: {
19550
- variant56 = undefined;
19643
+ variant58 = undefined;
19551
19644
  break;
19552
19645
  }
19553
19646
  case 1: {
19554
- variant56 = {
19647
+ variant58 = {
19555
19648
  start: {
19556
19649
  line: dataView(memory0).getInt32((base) + 96, true) >>> 0,
19557
19650
  character: dataView(memory0).getInt32((base) + 100, true) >>> 0,
@@ -19567,11 +19660,11 @@ export function instantiate(getCoreModule, imports, instantiateCore = WebAssembl
19567
19660
  throw new TypeError('invalid variant discriminant for option');
19568
19661
  }
19569
19662
  }
19570
- variant57 = {
19571
- mode: enum52,
19572
- name: result53,
19573
- t: variant55,
19574
- declaredAt: variant56,
19663
+ variant59 = {
19664
+ mode: enum54,
19665
+ name: result55,
19666
+ t: variant57,
19667
+ declaredAt: variant58,
19575
19668
  };
19576
19669
  break;
19577
19670
  }
@@ -19579,56 +19672,56 @@ export function instantiate(getCoreModule, imports, instantiateCore = WebAssembl
19579
19672
  throw new TypeError('invalid variant discriminant for option');
19580
19673
  }
19581
19674
  }
19582
- let variant59;
19675
+ let variant61;
19583
19676
  switch (dataView(memory0).getUint8((base) + 112, true)) {
19584
19677
  case 0: {
19585
- variant59 = undefined;
19678
+ variant61 = undefined;
19586
19679
  break;
19587
19680
  }
19588
19681
  case 1: {
19589
- var ptr58 = dataView(memory0).getUint32((base) + 116, true) >>> 0;
19590
- var len58 = dataView(memory0).getUint32((base) + 120, true);
19591
- var result58 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr58, len58));
19592
- variant59 = result58;
19682
+ var ptr60 = dataView(memory0).getUint32((base) + 116, true) >>> 0;
19683
+ var len60 = dataView(memory0).getUint32((base) + 120, true);
19684
+ var result60 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr60, len60));
19685
+ variant61 = result60;
19593
19686
  break;
19594
19687
  }
19595
19688
  default: {
19596
19689
  throw new TypeError('invalid variant discriminant for option');
19597
19690
  }
19598
19691
  }
19599
- let variant62;
19692
+ let variant64;
19600
19693
  switch (dataView(memory0).getUint8((base) + 124, true)) {
19601
19694
  case 0: {
19602
- variant62 = undefined;
19695
+ variant64 = undefined;
19603
19696
  break;
19604
19697
  }
19605
19698
  case 1: {
19606
- var len61 = dataView(memory0).getUint32((base) + 132, true);
19607
- var base61 = dataView(memory0).getUint32((base) + 128, true) >>> 0;
19608
- if (base61 < 0 || len61 < 0 || len61 > 33554431 || base61 > memory0.buffer.byteLength || len61 > Math.floor((memory0.buffer.byteLength - base61) / 8)) throw new WebAssemblyRuntimeError('wasm trap: out of bounds memory access');
19609
- if (base61 % 4 !== 0) throw new TypeError(`list pointer [${base61}] is not aligned to 4`);
19610
- var result61 = [];
19611
- for (let i = 0; i < len61; i++) {
19612
- const base = base61 + i * 8;
19613
- var ptr60 = dataView(memory0).getUint32((base) + 0, true) >>> 0;
19614
- var len60 = dataView(memory0).getUint32((base) + 4, true);
19615
- var result60 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr60, len60));
19616
- result61.push(result60);
19699
+ var len63 = dataView(memory0).getUint32((base) + 132, true);
19700
+ var base63 = dataView(memory0).getUint32((base) + 128, true) >>> 0;
19701
+ if (base63 < 0 || len63 < 0 || len63 > 33554431 || base63 > memory0.buffer.byteLength || len63 > Math.floor((memory0.buffer.byteLength - base63) / 8)) throw new WebAssemblyRuntimeError('wasm trap: out of bounds memory access');
19702
+ if (base63 % 4 !== 0) throw new TypeError(`list pointer [${base63}] is not aligned to 4`);
19703
+ var result63 = [];
19704
+ for (let i = 0; i < len63; i++) {
19705
+ const base = base63 + i * 8;
19706
+ var ptr62 = dataView(memory0).getUint32((base) + 0, true) >>> 0;
19707
+ var len62 = dataView(memory0).getUint32((base) + 4, true);
19708
+ var result62 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr62, len62));
19709
+ result63.push(result62);
19617
19710
  }
19618
- variant62 = result61;
19711
+ variant64 = result63;
19619
19712
  break;
19620
19713
  }
19621
19714
  default: {
19622
19715
  throw new TypeError('invalid variant discriminant for option');
19623
19716
  }
19624
19717
  }
19625
- variant82= {
19718
+ variant84= {
19626
19719
  tag: 'class-method',
19627
19720
  val: {
19628
- normal: result51,
19629
- variadic: variant57,
19630
- t: variant59,
19631
- procedureBlock: variant62,
19721
+ normal: result53,
19722
+ variadic: variant59,
19723
+ t: variant61,
19724
+ procedureBlock: variant64,
19632
19725
  body: {
19633
19726
  start: {
19634
19727
  line: dataView(memory0).getInt32((base) + 136, true) >>> 0,
@@ -19644,76 +19737,76 @@ export function instantiate(getCoreModule, imports, instantiateCore = WebAssembl
19644
19737
  break;
19645
19738
  }
19646
19739
  case 12: {
19647
- var len70 = dataView(memory0).getUint32((base) + 60, true);
19648
- var base70 = dataView(memory0).getUint32((base) + 56, true) >>> 0;
19649
- if (base70 < 0 || len70 < 0 || len70 > 4793490 || base70 > memory0.buffer.byteLength || len70 > Math.floor((memory0.buffer.byteLength - base70) / 56)) throw new WebAssemblyRuntimeError('wasm trap: out of bounds memory access');
19650
- if (base70 % 4 !== 0) throw new TypeError(`list pointer [${base70}] is not aligned to 4`);
19651
- var result70 = [];
19652
- for (let i = 0; i < len70; i++) {
19653
- const base = base70 + i * 56;
19654
- let enum63;
19740
+ var len72 = dataView(memory0).getUint32((base) + 60, true);
19741
+ var base72 = dataView(memory0).getUint32((base) + 56, true) >>> 0;
19742
+ if (base72 < 0 || len72 < 0 || len72 > 4793490 || base72 > memory0.buffer.byteLength || len72 > Math.floor((memory0.buffer.byteLength - base72) / 56)) throw new WebAssemblyRuntimeError('wasm trap: out of bounds memory access');
19743
+ if (base72 % 4 !== 0) throw new TypeError(`list pointer [${base72}] is not aligned to 4`);
19744
+ var result72 = [];
19745
+ for (let i = 0; i < len72; i++) {
19746
+ const base = base72 + i * 56;
19747
+ let enum65;
19655
19748
  switch (dataView(memory0).getUint8((base) + 0, true)) {
19656
19749
  case 0: {
19657
- enum63 = 'default';
19750
+ enum65 = 'default';
19658
19751
  break;
19659
19752
  }
19660
19753
  case 1: {
19661
- enum63 = 'output';
19754
+ enum65 = 'output';
19662
19755
  break;
19663
19756
  }
19664
19757
  case 2: {
19665
- enum63 = 'by-ref';
19758
+ enum65 = 'by-ref';
19666
19759
  break;
19667
19760
  }
19668
19761
  default: {
19669
19762
  throw new TypeError('invalid discriminant specified for ArgMode');
19670
19763
  }
19671
19764
  }
19672
- var ptr64 = dataView(memory0).getUint32((base) + 4, true) >>> 0;
19673
- var len64 = dataView(memory0).getUint32((base) + 8, true);
19674
- var result64 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr64, len64));
19675
- let variant66;
19765
+ var ptr66 = dataView(memory0).getUint32((base) + 4, true) >>> 0;
19766
+ var len66 = dataView(memory0).getUint32((base) + 8, true);
19767
+ var result66 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr66, len66));
19768
+ let variant68;
19676
19769
  switch (dataView(memory0).getUint8((base) + 12, true)) {
19677
19770
  case 0: {
19678
- variant66 = undefined;
19771
+ variant68 = undefined;
19679
19772
  break;
19680
19773
  }
19681
19774
  case 1: {
19682
- var ptr65 = dataView(memory0).getUint32((base) + 16, true) >>> 0;
19683
- var len65 = dataView(memory0).getUint32((base) + 20, true);
19684
- var result65 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr65, len65));
19685
- variant66 = result65;
19775
+ var ptr67 = dataView(memory0).getUint32((base) + 16, true) >>> 0;
19776
+ var len67 = dataView(memory0).getUint32((base) + 20, true);
19777
+ var result67 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr67, len67));
19778
+ variant68 = result67;
19686
19779
  break;
19687
19780
  }
19688
19781
  default: {
19689
19782
  throw new TypeError('invalid variant discriminant for option');
19690
19783
  }
19691
19784
  }
19692
- let variant68;
19785
+ let variant70;
19693
19786
  switch (dataView(memory0).getUint8((base) + 24, true)) {
19694
19787
  case 0: {
19695
- variant68 = undefined;
19788
+ variant70 = undefined;
19696
19789
  break;
19697
19790
  }
19698
19791
  case 1: {
19699
- var ptr67 = dataView(memory0).getUint32((base) + 28, true) >>> 0;
19700
- var len67 = dataView(memory0).getUint32((base) + 32, true);
19701
- var result67 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr67, len67));
19702
- variant68 = result67;
19792
+ var ptr69 = dataView(memory0).getUint32((base) + 28, true) >>> 0;
19793
+ var len69 = dataView(memory0).getUint32((base) + 32, true);
19794
+ var result69 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr69, len69));
19795
+ variant70 = result69;
19703
19796
  break;
19704
19797
  }
19705
19798
  default: {
19706
19799
  throw new TypeError('invalid variant discriminant for option');
19707
19800
  }
19708
19801
  }
19709
- let variant69;
19802
+ let variant71;
19710
19803
  switch (dataView(memory0).getUint8((base) + 36, true)) {
19711
19804
  case 0: {
19712
- variant69 = undefined;
19805
+ variant71 = undefined;
19713
19806
  break;
19714
19807
  }
19715
19808
  case 1: {
19716
- variant69 = {
19809
+ variant71 = {
19717
19810
  start: {
19718
19811
  line: dataView(memory0).getInt32((base) + 40, true) >>> 0,
19719
19812
  character: dataView(memory0).getInt32((base) + 44, true) >>> 0,
@@ -19729,67 +19822,67 @@ export function instantiate(getCoreModule, imports, instantiateCore = WebAssembl
19729
19822
  throw new TypeError('invalid variant discriminant for option');
19730
19823
  }
19731
19824
  }
19732
- result70.push({
19733
- mode: enum63,
19734
- name: result64,
19735
- t: variant66,
19736
- default: variant68,
19737
- declaredAt: variant69,
19825
+ result72.push({
19826
+ mode: enum65,
19827
+ name: result66,
19828
+ t: variant68,
19829
+ default: variant70,
19830
+ declaredAt: variant71,
19738
19831
  });
19739
19832
  }
19740
- let variant76;
19833
+ let variant78;
19741
19834
  switch (dataView(memory0).getUint8((base) + 64, true)) {
19742
19835
  case 0: {
19743
- variant76 = undefined;
19836
+ variant78 = undefined;
19744
19837
  break;
19745
19838
  }
19746
19839
  case 1: {
19747
- let enum71;
19840
+ let enum73;
19748
19841
  switch (dataView(memory0).getUint8((base) + 68, true)) {
19749
19842
  case 0: {
19750
- enum71 = 'default';
19843
+ enum73 = 'default';
19751
19844
  break;
19752
19845
  }
19753
19846
  case 1: {
19754
- enum71 = 'output';
19847
+ enum73 = 'output';
19755
19848
  break;
19756
19849
  }
19757
19850
  case 2: {
19758
- enum71 = 'by-ref';
19851
+ enum73 = 'by-ref';
19759
19852
  break;
19760
19853
  }
19761
19854
  default: {
19762
19855
  throw new TypeError('invalid discriminant specified for ArgMode');
19763
19856
  }
19764
19857
  }
19765
- var ptr72 = dataView(memory0).getUint32((base) + 72, true) >>> 0;
19766
- var len72 = dataView(memory0).getUint32((base) + 76, true);
19767
- var result72 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr72, len72));
19768
- let variant74;
19858
+ var ptr74 = dataView(memory0).getUint32((base) + 72, true) >>> 0;
19859
+ var len74 = dataView(memory0).getUint32((base) + 76, true);
19860
+ var result74 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr74, len74));
19861
+ let variant76;
19769
19862
  switch (dataView(memory0).getUint8((base) + 80, true)) {
19770
19863
  case 0: {
19771
- variant74 = undefined;
19864
+ variant76 = undefined;
19772
19865
  break;
19773
19866
  }
19774
19867
  case 1: {
19775
- var ptr73 = dataView(memory0).getUint32((base) + 84, true) >>> 0;
19776
- var len73 = dataView(memory0).getUint32((base) + 88, true);
19777
- var result73 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr73, len73));
19778
- variant74 = result73;
19868
+ var ptr75 = dataView(memory0).getUint32((base) + 84, true) >>> 0;
19869
+ var len75 = dataView(memory0).getUint32((base) + 88, true);
19870
+ var result75 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr75, len75));
19871
+ variant76 = result75;
19779
19872
  break;
19780
19873
  }
19781
19874
  default: {
19782
19875
  throw new TypeError('invalid variant discriminant for option');
19783
19876
  }
19784
19877
  }
19785
- let variant75;
19878
+ let variant77;
19786
19879
  switch (dataView(memory0).getUint8((base) + 92, true)) {
19787
19880
  case 0: {
19788
- variant75 = undefined;
19881
+ variant77 = undefined;
19789
19882
  break;
19790
19883
  }
19791
19884
  case 1: {
19792
- variant75 = {
19885
+ variant77 = {
19793
19886
  start: {
19794
19887
  line: dataView(memory0).getInt32((base) + 96, true) >>> 0,
19795
19888
  character: dataView(memory0).getInt32((base) + 100, true) >>> 0,
@@ -19805,11 +19898,11 @@ export function instantiate(getCoreModule, imports, instantiateCore = WebAssembl
19805
19898
  throw new TypeError('invalid variant discriminant for option');
19806
19899
  }
19807
19900
  }
19808
- variant76 = {
19809
- mode: enum71,
19810
- name: result72,
19811
- t: variant74,
19812
- declaredAt: variant75,
19901
+ variant78 = {
19902
+ mode: enum73,
19903
+ name: result74,
19904
+ t: variant76,
19905
+ declaredAt: variant77,
19813
19906
  };
19814
19907
  break;
19815
19908
  }
@@ -19817,56 +19910,56 @@ export function instantiate(getCoreModule, imports, instantiateCore = WebAssembl
19817
19910
  throw new TypeError('invalid variant discriminant for option');
19818
19911
  }
19819
19912
  }
19820
- let variant78;
19913
+ let variant80;
19821
19914
  switch (dataView(memory0).getUint8((base) + 112, true)) {
19822
19915
  case 0: {
19823
- variant78 = undefined;
19916
+ variant80 = undefined;
19824
19917
  break;
19825
19918
  }
19826
19919
  case 1: {
19827
- var ptr77 = dataView(memory0).getUint32((base) + 116, true) >>> 0;
19828
- var len77 = dataView(memory0).getUint32((base) + 120, true);
19829
- var result77 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr77, len77));
19830
- variant78 = result77;
19920
+ var ptr79 = dataView(memory0).getUint32((base) + 116, true) >>> 0;
19921
+ var len79 = dataView(memory0).getUint32((base) + 120, true);
19922
+ var result79 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr79, len79));
19923
+ variant80 = result79;
19831
19924
  break;
19832
19925
  }
19833
19926
  default: {
19834
19927
  throw new TypeError('invalid variant discriminant for option');
19835
19928
  }
19836
19929
  }
19837
- let variant81;
19930
+ let variant83;
19838
19931
  switch (dataView(memory0).getUint8((base) + 124, true)) {
19839
19932
  case 0: {
19840
- variant81 = undefined;
19933
+ variant83 = undefined;
19841
19934
  break;
19842
19935
  }
19843
19936
  case 1: {
19844
- var len80 = dataView(memory0).getUint32((base) + 132, true);
19845
- var base80 = dataView(memory0).getUint32((base) + 128, true) >>> 0;
19846
- if (base80 < 0 || len80 < 0 || len80 > 33554431 || base80 > memory0.buffer.byteLength || len80 > Math.floor((memory0.buffer.byteLength - base80) / 8)) throw new WebAssemblyRuntimeError('wasm trap: out of bounds memory access');
19847
- if (base80 % 4 !== 0) throw new TypeError(`list pointer [${base80}] is not aligned to 4`);
19848
- var result80 = [];
19849
- for (let i = 0; i < len80; i++) {
19850
- const base = base80 + i * 8;
19851
- var ptr79 = dataView(memory0).getUint32((base) + 0, true) >>> 0;
19852
- var len79 = dataView(memory0).getUint32((base) + 4, true);
19853
- var result79 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr79, len79));
19854
- result80.push(result79);
19937
+ var len82 = dataView(memory0).getUint32((base) + 132, true);
19938
+ var base82 = dataView(memory0).getUint32((base) + 128, true) >>> 0;
19939
+ if (base82 < 0 || len82 < 0 || len82 > 33554431 || base82 > memory0.buffer.byteLength || len82 > Math.floor((memory0.buffer.byteLength - base82) / 8)) throw new WebAssemblyRuntimeError('wasm trap: out of bounds memory access');
19940
+ if (base82 % 4 !== 0) throw new TypeError(`list pointer [${base82}] is not aligned to 4`);
19941
+ var result82 = [];
19942
+ for (let i = 0; i < len82; i++) {
19943
+ const base = base82 + i * 8;
19944
+ var ptr81 = dataView(memory0).getUint32((base) + 0, true) >>> 0;
19945
+ var len81 = dataView(memory0).getUint32((base) + 4, true);
19946
+ var result81 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr81, len81));
19947
+ result82.push(result81);
19855
19948
  }
19856
- variant81 = result80;
19949
+ variant83 = result82;
19857
19950
  break;
19858
19951
  }
19859
19952
  default: {
19860
19953
  throw new TypeError('invalid variant discriminant for option');
19861
19954
  }
19862
19955
  }
19863
- variant82= {
19956
+ variant84= {
19864
19957
  tag: 'client-method',
19865
19958
  val: {
19866
- normal: result70,
19867
- variadic: variant76,
19868
- t: variant78,
19869
- procedureBlock: variant81,
19959
+ normal: result72,
19960
+ variadic: variant78,
19961
+ t: variant80,
19962
+ procedureBlock: variant83,
19870
19963
  body: {
19871
19964
  start: {
19872
19965
  line: dataView(memory0).getInt32((base) + 136, true) >>> 0,
@@ -19885,41 +19978,41 @@ export function instantiate(getCoreModule, imports, instantiateCore = WebAssembl
19885
19978
  throw new TypeError('invalid variant discriminant for MemberKind');
19886
19979
  }
19887
19980
  }
19888
- let variant84;
19981
+ let variant86;
19889
19982
  switch (dataView(memory0).getUint8((base) + 160, true)) {
19890
19983
  case 0: {
19891
- variant84 = undefined;
19984
+ variant86 = undefined;
19892
19985
  break;
19893
19986
  }
19894
19987
  case 1: {
19895
- var ptr83 = dataView(memory0).getUint32((base) + 164, true) >>> 0;
19896
- var len83 = dataView(memory0).getUint32((base) + 168, true);
19897
- var result83 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr83, len83));
19898
- variant84 = result83;
19988
+ var ptr85 = dataView(memory0).getUint32((base) + 164, true) >>> 0;
19989
+ var len85 = dataView(memory0).getUint32((base) + 168, true);
19990
+ var result85 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr85, len85));
19991
+ variant86 = result85;
19899
19992
  break;
19900
19993
  }
19901
19994
  default: {
19902
19995
  throw new TypeError('invalid variant discriminant for option');
19903
19996
  }
19904
19997
  }
19905
- let variant86;
19998
+ let variant88;
19906
19999
  switch (dataView(memory0).getUint8((base) + 172, true)) {
19907
20000
  case 0: {
19908
- variant86 = undefined;
20001
+ variant88 = undefined;
19909
20002
  break;
19910
20003
  }
19911
20004
  case 1: {
19912
- var ptr85 = dataView(memory0).getUint32((base) + 176, true) >>> 0;
19913
- var len85 = dataView(memory0).getUint32((base) + 180, true);
19914
- var result85 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr85, len85));
19915
- variant86 = result85;
20005
+ var ptr87 = dataView(memory0).getUint32((base) + 176, true) >>> 0;
20006
+ var len87 = dataView(memory0).getUint32((base) + 180, true);
20007
+ var result87 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr87, len87));
20008
+ variant88 = result87;
19916
20009
  break;
19917
20010
  }
19918
20011
  default: {
19919
20012
  throw new TypeError('invalid variant discriminant for option');
19920
20013
  }
19921
20014
  }
19922
- result87.push({
20015
+ result89.push({
19923
20016
  doc: result9,
19924
20017
  before: {
19925
20018
  line: dataView(memory0).getInt32((base) + 8, true) >>> 0,
@@ -19938,29 +20031,17 @@ export function instantiate(getCoreModule, imports, instantiateCore = WebAssembl
19938
20031
  },
19939
20032
  aliases: result12,
19940
20033
  deprecated: bool13 == 0 ? false : (bool13 == 1 ? true : throwInvalidBool()),
19941
- kind: variant82,
20034
+ kind: variant84,
19942
20035
  after: {
19943
20036
  line: dataView(memory0).getInt32((base) + 152, true) >>> 0,
19944
20037
  character: dataView(memory0).getInt32((base) + 156, true) >>> 0,
19945
20038
  },
19946
- uri: variant84,
19947
- origin: variant86,
20039
+ uri: variant86,
20040
+ origin: variant88,
19948
20041
  });
19949
20042
  }
19950
- var len89 = dataView(memory0).getUint32((base) + 64, true);
19951
- var base89 = dataView(memory0).getUint32((base) + 60, true) >>> 0;
19952
- if (base89 < 0 || len89 < 0 || len89 > 33554431 || base89 > memory0.buffer.byteLength || len89 > Math.floor((memory0.buffer.byteLength - base89) / 8)) throw new WebAssemblyRuntimeError('wasm trap: out of bounds memory access');
19953
- if (base89 % 4 !== 0) throw new TypeError(`list pointer [${base89}] is not aligned to 4`);
19954
- var result89 = [];
19955
- for (let i = 0; i < len89; i++) {
19956
- const base = base89 + i * 8;
19957
- var ptr88 = dataView(memory0).getUint32((base) + 0, true) >>> 0;
19958
- var len88 = dataView(memory0).getUint32((base) + 4, true);
19959
- var result88 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr88, len88));
19960
- result89.push(result88);
19961
- }
19962
- var len91 = dataView(memory0).getUint32((base) + 72, true);
19963
- var base91 = dataView(memory0).getUint32((base) + 68, true) >>> 0;
20043
+ var len91 = dataView(memory0).getUint32((base) + 64, true);
20044
+ var base91 = dataView(memory0).getUint32((base) + 60, true) >>> 0;
19964
20045
  if (base91 < 0 || len91 < 0 || len91 > 33554431 || base91 > memory0.buffer.byteLength || len91 > Math.floor((memory0.buffer.byteLength - base91) / 8)) throw new WebAssemblyRuntimeError('wasm trap: out of bounds memory access');
19965
20046
  if (base91 % 4 !== 0) throw new TypeError(`list pointer [${base91}] is not aligned to 4`);
19966
20047
  var result91 = [];
@@ -19971,39 +20052,51 @@ export function instantiate(getCoreModule, imports, instantiateCore = WebAssembl
19971
20052
  var result90 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr90, len90));
19972
20053
  result91.push(result90);
19973
20054
  }
19974
- let variant93;
20055
+ var len93 = dataView(memory0).getUint32((base) + 72, true);
20056
+ var base93 = dataView(memory0).getUint32((base) + 68, true) >>> 0;
20057
+ if (base93 < 0 || len93 < 0 || len93 > 33554431 || base93 > memory0.buffer.byteLength || len93 > Math.floor((memory0.buffer.byteLength - base93) / 8)) throw new WebAssemblyRuntimeError('wasm trap: out of bounds memory access');
20058
+ if (base93 % 4 !== 0) throw new TypeError(`list pointer [${base93}] is not aligned to 4`);
20059
+ var result93 = [];
20060
+ for (let i = 0; i < len93; i++) {
20061
+ const base = base93 + i * 8;
20062
+ var ptr92 = dataView(memory0).getUint32((base) + 0, true) >>> 0;
20063
+ var len92 = dataView(memory0).getUint32((base) + 4, true);
20064
+ var result92 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr92, len92));
20065
+ result93.push(result92);
20066
+ }
20067
+ let variant95;
19975
20068
  switch (dataView(memory0).getUint8((base) + 76, true)) {
19976
20069
  case 0: {
19977
- variant93 = undefined;
20070
+ variant95 = undefined;
19978
20071
  break;
19979
20072
  }
19980
20073
  case 1: {
19981
- var bool92 = dataView(memory0).getUint8((base) + 77, true);
19982
- variant93 = bool92 == 0 ? false : (bool92 == 1 ? true : throwInvalidBool());
20074
+ var bool94 = dataView(memory0).getUint8((base) + 77, true);
20075
+ variant95 = bool94 == 0 ? false : (bool94 == 1 ? true : throwInvalidBool());
19983
20076
  break;
19984
20077
  }
19985
20078
  default: {
19986
20079
  throw new TypeError('invalid variant discriminant for option');
19987
20080
  }
19988
20081
  }
19989
- let variant95;
20082
+ let variant97;
19990
20083
  switch (dataView(memory0).getUint8((base) + 80, true)) {
19991
20084
  case 0: {
19992
- variant95 = undefined;
20085
+ variant97 = undefined;
19993
20086
  break;
19994
20087
  }
19995
20088
  case 1: {
19996
- var ptr94 = dataView(memory0).getUint32((base) + 84, true) >>> 0;
19997
- var len94 = dataView(memory0).getUint32((base) + 88, true);
19998
- var result94 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr94, len94));
19999
- variant95 = result94;
20089
+ var ptr96 = dataView(memory0).getUint32((base) + 84, true) >>> 0;
20090
+ var len96 = dataView(memory0).getUint32((base) + 88, true);
20091
+ var result96 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr96, len96));
20092
+ variant97 = result96;
20000
20093
  break;
20001
20094
  }
20002
20095
  default: {
20003
20096
  throw new TypeError('invalid variant discriminant for option');
20004
20097
  }
20005
20098
  }
20006
- result96.push([result3, {
20099
+ result98.push([result3, {
20007
20100
  doc: result4,
20008
20101
  name: {
20009
20102
  before: {
@@ -20018,11 +20111,11 @@ export function instantiate(getCoreModule, imports, instantiateCore = WebAssembl
20018
20111
  },
20019
20112
  extends: result7,
20020
20113
  deprecated: bool8 == 0 ? false : (bool8 == 1 ? true : throwInvalidBool()),
20021
- members: result87,
20022
- propertyClassNames: result89,
20023
- includes: result91,
20024
- isDatatype: variant93,
20025
- uri: variant95,
20114
+ members: result89,
20115
+ propertyClassNames: result91,
20116
+ includes: result93,
20117
+ isDatatype: variant95,
20118
+ uri: variant97,
20026
20119
  }]);
20027
20120
  }
20028
20121
  _debugLog('[iface="iris:ascot/exported", function="[method]workspace.query-cls"][Instruction::Return]', {
@@ -20031,8 +20124,8 @@ export function instantiate(getCoreModule, imports, instantiateCore = WebAssembl
20031
20124
  async: false,
20032
20125
  postReturn: true
20033
20126
  });
20034
- task.resolve([result96]);
20035
- const retCopy = result96;
20127
+ task.resolve([result98]);
20128
+ const retCopy = result98;
20036
20129
 
20037
20130
  let cstate = getOrCreateAsyncState(0);
20038
20131
  cstate.mayLeave = false;
@@ -20144,13 +20237,13 @@ export function instantiate(getCoreModule, imports, instantiateCore = WebAssembl
20144
20237
 
20145
20238
  }
20146
20239
 
20147
- var len83 = dataView(memory0).getUint32(((ret >>> 0)) + 4, true);
20148
- var base83 = dataView(memory0).getUint32(((ret >>> 0)) + 0, true) >>> 0;
20149
- if (base83 < 0 || len83 < 0 || len83 > 1398101 || base83 > memory0.buffer.byteLength || len83 > Math.floor((memory0.buffer.byteLength - base83) / 192)) throw new WebAssemblyRuntimeError('wasm trap: out of bounds memory access');
20150
- if (base83 % 4 !== 0) throw new TypeError(`list pointer [${base83}] is not aligned to 4`);
20151
- var result83 = [];
20152
- for (let i = 0; i < len83; i++) {
20153
- const base = base83 + i * 192;
20240
+ var len85 = dataView(memory0).getUint32(((ret >>> 0)) + 4, true);
20241
+ var base85 = dataView(memory0).getUint32(((ret >>> 0)) + 0, true) >>> 0;
20242
+ if (base85 < 0 || len85 < 0 || len85 > 1398101 || base85 > memory0.buffer.byteLength || len85 > Math.floor((memory0.buffer.byteLength - base85) / 192)) throw new WebAssemblyRuntimeError('wasm trap: out of bounds memory access');
20243
+ if (base85 % 4 !== 0) throw new TypeError(`list pointer [${base85}] is not aligned to 4`);
20244
+ var result85 = [];
20245
+ for (let i = 0; i < len85; i++) {
20246
+ const base = base85 + i * 192;
20154
20247
  var ptr4 = dataView(memory0).getUint32((base) + 0, true) >>> 0;
20155
20248
  var len4 = dataView(memory0).getUint32((base) + 4, true);
20156
20249
  var result4 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr4, len4));
@@ -20173,7 +20266,7 @@ export function instantiate(getCoreModule, imports, instantiateCore = WebAssembl
20173
20266
  result8.push(result7);
20174
20267
  }
20175
20268
  var bool9 = dataView(memory0).getUint8((base) + 56, true);
20176
- let variant78;
20269
+ let variant80;
20177
20270
  switch (dataView(memory0).getUint8((base) + 60, true)) {
20178
20271
  case 0: {
20179
20272
  let variant11;
@@ -20210,7 +20303,7 @@ export function instantiate(getCoreModule, imports, instantiateCore = WebAssembl
20210
20303
  throw new TypeError('invalid variant discriminant for option');
20211
20304
  }
20212
20305
  }
20213
- variant78= {
20306
+ variant80= {
20214
20307
  tag: 'parameter',
20215
20308
  val: {
20216
20309
  t: variant11,
@@ -20266,7 +20359,7 @@ export function instantiate(getCoreModule, imports, instantiateCore = WebAssembl
20266
20359
  }
20267
20360
  }
20268
20361
  var bool18 = dataView(memory0).getUint8((base) + 78, true);
20269
- variant78= {
20362
+ variant80= {
20270
20363
  tag: 'property',
20271
20364
  val: {
20272
20365
  t: variant15,
@@ -20294,125 +20387,164 @@ export function instantiate(getCoreModule, imports, instantiateCore = WebAssembl
20294
20387
  throw new TypeError('invalid variant discriminant for option');
20295
20388
  }
20296
20389
  }
20297
- variant78= {
20390
+ let variant22;
20391
+ switch (dataView(memory0).getUint8((base) + 76, true)) {
20392
+ case 0: {
20393
+ variant22 = undefined;
20394
+ break;
20395
+ }
20396
+ case 1: {
20397
+ let enum21;
20398
+ switch (dataView(memory0).getUint8((base) + 77, true)) {
20399
+ case 0: {
20400
+ enum21 = 'one';
20401
+ break;
20402
+ }
20403
+ case 1: {
20404
+ enum21 = 'many';
20405
+ break;
20406
+ }
20407
+ case 2: {
20408
+ enum21 = 'parent';
20409
+ break;
20410
+ }
20411
+ case 3: {
20412
+ enum21 = 'children';
20413
+ break;
20414
+ }
20415
+ default: {
20416
+ throw new TypeError('invalid discriminant specified for Cardinality');
20417
+ }
20418
+ }
20419
+ variant22 = enum21;
20420
+ break;
20421
+ }
20422
+ default: {
20423
+ throw new TypeError('invalid variant discriminant for option');
20424
+ }
20425
+ }
20426
+ variant80= {
20298
20427
  tag: 'relationship',
20299
- val: variant20
20428
+ val: {
20429
+ t: variant20,
20430
+ cardinality: variant22,
20431
+ }
20300
20432
  };
20301
20433
  break;
20302
20434
  }
20303
20435
  case 3: {
20304
- variant78= {
20436
+ variant80= {
20305
20437
  tag: 'foreign-key',
20306
20438
  };
20307
20439
  break;
20308
20440
  }
20309
20441
  case 4: {
20310
- variant78= {
20442
+ variant80= {
20311
20443
  tag: 'index',
20312
20444
  };
20313
20445
  break;
20314
20446
  }
20315
20447
  case 5: {
20316
- variant78= {
20448
+ variant80= {
20317
20449
  tag: 'projection',
20318
20450
  };
20319
20451
  break;
20320
20452
  }
20321
20453
  case 6: {
20322
- variant78= {
20454
+ variant80= {
20323
20455
  tag: 'trigger',
20324
20456
  };
20325
20457
  break;
20326
20458
  }
20327
20459
  case 7: {
20328
- variant78= {
20460
+ variant80= {
20329
20461
  tag: 'x-data',
20330
20462
  };
20331
20463
  break;
20332
20464
  }
20333
20465
  case 8: {
20334
- variant78= {
20466
+ variant80= {
20335
20467
  tag: 'storage',
20336
20468
  };
20337
20469
  break;
20338
20470
  }
20339
20471
  case 9: {
20340
- variant78= {
20472
+ variant80= {
20341
20473
  tag: 'query',
20342
20474
  };
20343
20475
  break;
20344
20476
  }
20345
20477
  case 10: {
20346
- var len28 = dataView(memory0).getUint32((base) + 68, true);
20347
- var base28 = dataView(memory0).getUint32((base) + 64, true) >>> 0;
20348
- if (base28 < 0 || len28 < 0 || len28 > 4793490 || base28 > memory0.buffer.byteLength || len28 > Math.floor((memory0.buffer.byteLength - base28) / 56)) throw new WebAssemblyRuntimeError('wasm trap: out of bounds memory access');
20349
- if (base28 % 4 !== 0) throw new TypeError(`list pointer [${base28}] is not aligned to 4`);
20350
- var result28 = [];
20351
- for (let i = 0; i < len28; i++) {
20352
- const base = base28 + i * 56;
20353
- let enum21;
20478
+ var len30 = dataView(memory0).getUint32((base) + 68, true);
20479
+ var base30 = dataView(memory0).getUint32((base) + 64, true) >>> 0;
20480
+ if (base30 < 0 || len30 < 0 || len30 > 4793490 || base30 > memory0.buffer.byteLength || len30 > Math.floor((memory0.buffer.byteLength - base30) / 56)) throw new WebAssemblyRuntimeError('wasm trap: out of bounds memory access');
20481
+ if (base30 % 4 !== 0) throw new TypeError(`list pointer [${base30}] is not aligned to 4`);
20482
+ var result30 = [];
20483
+ for (let i = 0; i < len30; i++) {
20484
+ const base = base30 + i * 56;
20485
+ let enum23;
20354
20486
  switch (dataView(memory0).getUint8((base) + 0, true)) {
20355
20487
  case 0: {
20356
- enum21 = 'default';
20488
+ enum23 = 'default';
20357
20489
  break;
20358
20490
  }
20359
20491
  case 1: {
20360
- enum21 = 'output';
20492
+ enum23 = 'output';
20361
20493
  break;
20362
20494
  }
20363
20495
  case 2: {
20364
- enum21 = 'by-ref';
20496
+ enum23 = 'by-ref';
20365
20497
  break;
20366
20498
  }
20367
20499
  default: {
20368
20500
  throw new TypeError('invalid discriminant specified for ArgMode');
20369
20501
  }
20370
20502
  }
20371
- var ptr22 = dataView(memory0).getUint32((base) + 4, true) >>> 0;
20372
- var len22 = dataView(memory0).getUint32((base) + 8, true);
20373
- var result22 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr22, len22));
20374
- let variant24;
20503
+ var ptr24 = dataView(memory0).getUint32((base) + 4, true) >>> 0;
20504
+ var len24 = dataView(memory0).getUint32((base) + 8, true);
20505
+ var result24 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr24, len24));
20506
+ let variant26;
20375
20507
  switch (dataView(memory0).getUint8((base) + 12, true)) {
20376
20508
  case 0: {
20377
- variant24 = undefined;
20509
+ variant26 = undefined;
20378
20510
  break;
20379
20511
  }
20380
20512
  case 1: {
20381
- var ptr23 = dataView(memory0).getUint32((base) + 16, true) >>> 0;
20382
- var len23 = dataView(memory0).getUint32((base) + 20, true);
20383
- var result23 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr23, len23));
20384
- variant24 = result23;
20513
+ var ptr25 = dataView(memory0).getUint32((base) + 16, true) >>> 0;
20514
+ var len25 = dataView(memory0).getUint32((base) + 20, true);
20515
+ var result25 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr25, len25));
20516
+ variant26 = result25;
20385
20517
  break;
20386
20518
  }
20387
20519
  default: {
20388
20520
  throw new TypeError('invalid variant discriminant for option');
20389
20521
  }
20390
20522
  }
20391
- let variant26;
20523
+ let variant28;
20392
20524
  switch (dataView(memory0).getUint8((base) + 24, true)) {
20393
20525
  case 0: {
20394
- variant26 = undefined;
20526
+ variant28 = undefined;
20395
20527
  break;
20396
20528
  }
20397
20529
  case 1: {
20398
- var ptr25 = dataView(memory0).getUint32((base) + 28, true) >>> 0;
20399
- var len25 = dataView(memory0).getUint32((base) + 32, true);
20400
- var result25 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr25, len25));
20401
- variant26 = result25;
20530
+ var ptr27 = dataView(memory0).getUint32((base) + 28, true) >>> 0;
20531
+ var len27 = dataView(memory0).getUint32((base) + 32, true);
20532
+ var result27 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr27, len27));
20533
+ variant28 = result27;
20402
20534
  break;
20403
20535
  }
20404
20536
  default: {
20405
20537
  throw new TypeError('invalid variant discriminant for option');
20406
20538
  }
20407
20539
  }
20408
- let variant27;
20540
+ let variant29;
20409
20541
  switch (dataView(memory0).getUint8((base) + 36, true)) {
20410
20542
  case 0: {
20411
- variant27 = undefined;
20543
+ variant29 = undefined;
20412
20544
  break;
20413
20545
  }
20414
20546
  case 1: {
20415
- variant27 = {
20547
+ variant29 = {
20416
20548
  start: {
20417
20549
  line: dataView(memory0).getInt32((base) + 40, true) >>> 0,
20418
20550
  character: dataView(memory0).getInt32((base) + 44, true) >>> 0,
@@ -20428,67 +20560,67 @@ export function instantiate(getCoreModule, imports, instantiateCore = WebAssembl
20428
20560
  throw new TypeError('invalid variant discriminant for option');
20429
20561
  }
20430
20562
  }
20431
- result28.push({
20432
- mode: enum21,
20433
- name: result22,
20434
- t: variant24,
20435
- default: variant26,
20436
- declaredAt: variant27,
20563
+ result30.push({
20564
+ mode: enum23,
20565
+ name: result24,
20566
+ t: variant26,
20567
+ default: variant28,
20568
+ declaredAt: variant29,
20437
20569
  });
20438
20570
  }
20439
- let variant34;
20571
+ let variant36;
20440
20572
  switch (dataView(memory0).getUint8((base) + 72, true)) {
20441
20573
  case 0: {
20442
- variant34 = undefined;
20574
+ variant36 = undefined;
20443
20575
  break;
20444
20576
  }
20445
20577
  case 1: {
20446
- let enum29;
20578
+ let enum31;
20447
20579
  switch (dataView(memory0).getUint8((base) + 76, true)) {
20448
20580
  case 0: {
20449
- enum29 = 'default';
20581
+ enum31 = 'default';
20450
20582
  break;
20451
20583
  }
20452
20584
  case 1: {
20453
- enum29 = 'output';
20585
+ enum31 = 'output';
20454
20586
  break;
20455
20587
  }
20456
20588
  case 2: {
20457
- enum29 = 'by-ref';
20589
+ enum31 = 'by-ref';
20458
20590
  break;
20459
20591
  }
20460
20592
  default: {
20461
20593
  throw new TypeError('invalid discriminant specified for ArgMode');
20462
20594
  }
20463
20595
  }
20464
- var ptr30 = dataView(memory0).getUint32((base) + 80, true) >>> 0;
20465
- var len30 = dataView(memory0).getUint32((base) + 84, true);
20466
- var result30 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr30, len30));
20467
- let variant32;
20596
+ var ptr32 = dataView(memory0).getUint32((base) + 80, true) >>> 0;
20597
+ var len32 = dataView(memory0).getUint32((base) + 84, true);
20598
+ var result32 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr32, len32));
20599
+ let variant34;
20468
20600
  switch (dataView(memory0).getUint8((base) + 88, true)) {
20469
20601
  case 0: {
20470
- variant32 = undefined;
20602
+ variant34 = undefined;
20471
20603
  break;
20472
20604
  }
20473
20605
  case 1: {
20474
- var ptr31 = dataView(memory0).getUint32((base) + 92, true) >>> 0;
20475
- var len31 = dataView(memory0).getUint32((base) + 96, true);
20476
- var result31 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr31, len31));
20477
- variant32 = result31;
20606
+ var ptr33 = dataView(memory0).getUint32((base) + 92, true) >>> 0;
20607
+ var len33 = dataView(memory0).getUint32((base) + 96, true);
20608
+ var result33 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr33, len33));
20609
+ variant34 = result33;
20478
20610
  break;
20479
20611
  }
20480
20612
  default: {
20481
20613
  throw new TypeError('invalid variant discriminant for option');
20482
20614
  }
20483
20615
  }
20484
- let variant33;
20616
+ let variant35;
20485
20617
  switch (dataView(memory0).getUint8((base) + 100, true)) {
20486
20618
  case 0: {
20487
- variant33 = undefined;
20619
+ variant35 = undefined;
20488
20620
  break;
20489
20621
  }
20490
20622
  case 1: {
20491
- variant33 = {
20623
+ variant35 = {
20492
20624
  start: {
20493
20625
  line: dataView(memory0).getInt32((base) + 104, true) >>> 0,
20494
20626
  character: dataView(memory0).getInt32((base) + 108, true) >>> 0,
@@ -20504,11 +20636,11 @@ export function instantiate(getCoreModule, imports, instantiateCore = WebAssembl
20504
20636
  throw new TypeError('invalid variant discriminant for option');
20505
20637
  }
20506
20638
  }
20507
- variant34 = {
20508
- mode: enum29,
20509
- name: result30,
20510
- t: variant32,
20511
- declaredAt: variant33,
20639
+ variant36 = {
20640
+ mode: enum31,
20641
+ name: result32,
20642
+ t: variant34,
20643
+ declaredAt: variant35,
20512
20644
  };
20513
20645
  break;
20514
20646
  }
@@ -20516,56 +20648,56 @@ export function instantiate(getCoreModule, imports, instantiateCore = WebAssembl
20516
20648
  throw new TypeError('invalid variant discriminant for option');
20517
20649
  }
20518
20650
  }
20519
- let variant36;
20651
+ let variant38;
20520
20652
  switch (dataView(memory0).getUint8((base) + 120, true)) {
20521
20653
  case 0: {
20522
- variant36 = undefined;
20654
+ variant38 = undefined;
20523
20655
  break;
20524
20656
  }
20525
20657
  case 1: {
20526
- var ptr35 = dataView(memory0).getUint32((base) + 124, true) >>> 0;
20527
- var len35 = dataView(memory0).getUint32((base) + 128, true);
20528
- var result35 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr35, len35));
20529
- variant36 = result35;
20658
+ var ptr37 = dataView(memory0).getUint32((base) + 124, true) >>> 0;
20659
+ var len37 = dataView(memory0).getUint32((base) + 128, true);
20660
+ var result37 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr37, len37));
20661
+ variant38 = result37;
20530
20662
  break;
20531
20663
  }
20532
20664
  default: {
20533
20665
  throw new TypeError('invalid variant discriminant for option');
20534
20666
  }
20535
20667
  }
20536
- let variant39;
20668
+ let variant41;
20537
20669
  switch (dataView(memory0).getUint8((base) + 132, true)) {
20538
20670
  case 0: {
20539
- variant39 = undefined;
20671
+ variant41 = undefined;
20540
20672
  break;
20541
20673
  }
20542
20674
  case 1: {
20543
- var len38 = dataView(memory0).getUint32((base) + 140, true);
20544
- var base38 = dataView(memory0).getUint32((base) + 136, true) >>> 0;
20545
- if (base38 < 0 || len38 < 0 || len38 > 33554431 || base38 > memory0.buffer.byteLength || len38 > Math.floor((memory0.buffer.byteLength - base38) / 8)) throw new WebAssemblyRuntimeError('wasm trap: out of bounds memory access');
20546
- if (base38 % 4 !== 0) throw new TypeError(`list pointer [${base38}] is not aligned to 4`);
20547
- var result38 = [];
20548
- for (let i = 0; i < len38; i++) {
20549
- const base = base38 + i * 8;
20550
- var ptr37 = dataView(memory0).getUint32((base) + 0, true) >>> 0;
20551
- var len37 = dataView(memory0).getUint32((base) + 4, true);
20552
- var result37 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr37, len37));
20553
- result38.push(result37);
20554
- }
20555
- variant39 = result38;
20675
+ var len40 = dataView(memory0).getUint32((base) + 140, true);
20676
+ var base40 = dataView(memory0).getUint32((base) + 136, true) >>> 0;
20677
+ if (base40 < 0 || len40 < 0 || len40 > 33554431 || base40 > memory0.buffer.byteLength || len40 > Math.floor((memory0.buffer.byteLength - base40) / 8)) throw new WebAssemblyRuntimeError('wasm trap: out of bounds memory access');
20678
+ if (base40 % 4 !== 0) throw new TypeError(`list pointer [${base40}] is not aligned to 4`);
20679
+ var result40 = [];
20680
+ for (let i = 0; i < len40; i++) {
20681
+ const base = base40 + i * 8;
20682
+ var ptr39 = dataView(memory0).getUint32((base) + 0, true) >>> 0;
20683
+ var len39 = dataView(memory0).getUint32((base) + 4, true);
20684
+ var result39 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr39, len39));
20685
+ result40.push(result39);
20686
+ }
20687
+ variant41 = result40;
20556
20688
  break;
20557
20689
  }
20558
20690
  default: {
20559
20691
  throw new TypeError('invalid variant discriminant for option');
20560
20692
  }
20561
20693
  }
20562
- variant78= {
20694
+ variant80= {
20563
20695
  tag: 'method',
20564
20696
  val: {
20565
- normal: result28,
20566
- variadic: variant34,
20567
- t: variant36,
20568
- procedureBlock: variant39,
20697
+ normal: result30,
20698
+ variadic: variant36,
20699
+ t: variant38,
20700
+ procedureBlock: variant41,
20569
20701
  body: {
20570
20702
  start: {
20571
20703
  line: dataView(memory0).getInt32((base) + 144, true) >>> 0,
@@ -20581,76 +20713,76 @@ export function instantiate(getCoreModule, imports, instantiateCore = WebAssembl
20581
20713
  break;
20582
20714
  }
20583
20715
  case 11: {
20584
- var len47 = dataView(memory0).getUint32((base) + 68, true);
20585
- var base47 = dataView(memory0).getUint32((base) + 64, true) >>> 0;
20586
- if (base47 < 0 || len47 < 0 || len47 > 4793490 || base47 > memory0.buffer.byteLength || len47 > Math.floor((memory0.buffer.byteLength - base47) / 56)) throw new WebAssemblyRuntimeError('wasm trap: out of bounds memory access');
20587
- if (base47 % 4 !== 0) throw new TypeError(`list pointer [${base47}] is not aligned to 4`);
20588
- var result47 = [];
20589
- for (let i = 0; i < len47; i++) {
20590
- const base = base47 + i * 56;
20591
- let enum40;
20716
+ var len49 = dataView(memory0).getUint32((base) + 68, true);
20717
+ var base49 = dataView(memory0).getUint32((base) + 64, true) >>> 0;
20718
+ if (base49 < 0 || len49 < 0 || len49 > 4793490 || base49 > memory0.buffer.byteLength || len49 > Math.floor((memory0.buffer.byteLength - base49) / 56)) throw new WebAssemblyRuntimeError('wasm trap: out of bounds memory access');
20719
+ if (base49 % 4 !== 0) throw new TypeError(`list pointer [${base49}] is not aligned to 4`);
20720
+ var result49 = [];
20721
+ for (let i = 0; i < len49; i++) {
20722
+ const base = base49 + i * 56;
20723
+ let enum42;
20592
20724
  switch (dataView(memory0).getUint8((base) + 0, true)) {
20593
20725
  case 0: {
20594
- enum40 = 'default';
20726
+ enum42 = 'default';
20595
20727
  break;
20596
20728
  }
20597
20729
  case 1: {
20598
- enum40 = 'output';
20730
+ enum42 = 'output';
20599
20731
  break;
20600
20732
  }
20601
20733
  case 2: {
20602
- enum40 = 'by-ref';
20734
+ enum42 = 'by-ref';
20603
20735
  break;
20604
20736
  }
20605
20737
  default: {
20606
20738
  throw new TypeError('invalid discriminant specified for ArgMode');
20607
20739
  }
20608
20740
  }
20609
- var ptr41 = dataView(memory0).getUint32((base) + 4, true) >>> 0;
20610
- var len41 = dataView(memory0).getUint32((base) + 8, true);
20611
- var result41 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr41, len41));
20612
- let variant43;
20741
+ var ptr43 = dataView(memory0).getUint32((base) + 4, true) >>> 0;
20742
+ var len43 = dataView(memory0).getUint32((base) + 8, true);
20743
+ var result43 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr43, len43));
20744
+ let variant45;
20613
20745
  switch (dataView(memory0).getUint8((base) + 12, true)) {
20614
20746
  case 0: {
20615
- variant43 = undefined;
20747
+ variant45 = undefined;
20616
20748
  break;
20617
20749
  }
20618
20750
  case 1: {
20619
- var ptr42 = dataView(memory0).getUint32((base) + 16, true) >>> 0;
20620
- var len42 = dataView(memory0).getUint32((base) + 20, true);
20621
- var result42 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr42, len42));
20622
- variant43 = result42;
20751
+ var ptr44 = dataView(memory0).getUint32((base) + 16, true) >>> 0;
20752
+ var len44 = dataView(memory0).getUint32((base) + 20, true);
20753
+ var result44 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr44, len44));
20754
+ variant45 = result44;
20623
20755
  break;
20624
20756
  }
20625
20757
  default: {
20626
20758
  throw new TypeError('invalid variant discriminant for option');
20627
20759
  }
20628
20760
  }
20629
- let variant45;
20761
+ let variant47;
20630
20762
  switch (dataView(memory0).getUint8((base) + 24, true)) {
20631
20763
  case 0: {
20632
- variant45 = undefined;
20764
+ variant47 = undefined;
20633
20765
  break;
20634
20766
  }
20635
20767
  case 1: {
20636
- var ptr44 = dataView(memory0).getUint32((base) + 28, true) >>> 0;
20637
- var len44 = dataView(memory0).getUint32((base) + 32, true);
20638
- var result44 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr44, len44));
20639
- variant45 = result44;
20768
+ var ptr46 = dataView(memory0).getUint32((base) + 28, true) >>> 0;
20769
+ var len46 = dataView(memory0).getUint32((base) + 32, true);
20770
+ var result46 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr46, len46));
20771
+ variant47 = result46;
20640
20772
  break;
20641
20773
  }
20642
20774
  default: {
20643
20775
  throw new TypeError('invalid variant discriminant for option');
20644
20776
  }
20645
20777
  }
20646
- let variant46;
20778
+ let variant48;
20647
20779
  switch (dataView(memory0).getUint8((base) + 36, true)) {
20648
20780
  case 0: {
20649
- variant46 = undefined;
20781
+ variant48 = undefined;
20650
20782
  break;
20651
20783
  }
20652
20784
  case 1: {
20653
- variant46 = {
20785
+ variant48 = {
20654
20786
  start: {
20655
20787
  line: dataView(memory0).getInt32((base) + 40, true) >>> 0,
20656
20788
  character: dataView(memory0).getInt32((base) + 44, true) >>> 0,
@@ -20666,67 +20798,67 @@ export function instantiate(getCoreModule, imports, instantiateCore = WebAssembl
20666
20798
  throw new TypeError('invalid variant discriminant for option');
20667
20799
  }
20668
20800
  }
20669
- result47.push({
20670
- mode: enum40,
20671
- name: result41,
20672
- t: variant43,
20673
- default: variant45,
20674
- declaredAt: variant46,
20801
+ result49.push({
20802
+ mode: enum42,
20803
+ name: result43,
20804
+ t: variant45,
20805
+ default: variant47,
20806
+ declaredAt: variant48,
20675
20807
  });
20676
20808
  }
20677
- let variant53;
20809
+ let variant55;
20678
20810
  switch (dataView(memory0).getUint8((base) + 72, true)) {
20679
20811
  case 0: {
20680
- variant53 = undefined;
20812
+ variant55 = undefined;
20681
20813
  break;
20682
20814
  }
20683
20815
  case 1: {
20684
- let enum48;
20816
+ let enum50;
20685
20817
  switch (dataView(memory0).getUint8((base) + 76, true)) {
20686
20818
  case 0: {
20687
- enum48 = 'default';
20819
+ enum50 = 'default';
20688
20820
  break;
20689
20821
  }
20690
20822
  case 1: {
20691
- enum48 = 'output';
20823
+ enum50 = 'output';
20692
20824
  break;
20693
20825
  }
20694
20826
  case 2: {
20695
- enum48 = 'by-ref';
20827
+ enum50 = 'by-ref';
20696
20828
  break;
20697
20829
  }
20698
20830
  default: {
20699
20831
  throw new TypeError('invalid discriminant specified for ArgMode');
20700
20832
  }
20701
20833
  }
20702
- var ptr49 = dataView(memory0).getUint32((base) + 80, true) >>> 0;
20703
- var len49 = dataView(memory0).getUint32((base) + 84, true);
20704
- var result49 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr49, len49));
20705
- let variant51;
20834
+ var ptr51 = dataView(memory0).getUint32((base) + 80, true) >>> 0;
20835
+ var len51 = dataView(memory0).getUint32((base) + 84, true);
20836
+ var result51 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr51, len51));
20837
+ let variant53;
20706
20838
  switch (dataView(memory0).getUint8((base) + 88, true)) {
20707
20839
  case 0: {
20708
- variant51 = undefined;
20840
+ variant53 = undefined;
20709
20841
  break;
20710
20842
  }
20711
20843
  case 1: {
20712
- var ptr50 = dataView(memory0).getUint32((base) + 92, true) >>> 0;
20713
- var len50 = dataView(memory0).getUint32((base) + 96, true);
20714
- var result50 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr50, len50));
20715
- variant51 = result50;
20844
+ var ptr52 = dataView(memory0).getUint32((base) + 92, true) >>> 0;
20845
+ var len52 = dataView(memory0).getUint32((base) + 96, true);
20846
+ var result52 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr52, len52));
20847
+ variant53 = result52;
20716
20848
  break;
20717
20849
  }
20718
20850
  default: {
20719
20851
  throw new TypeError('invalid variant discriminant for option');
20720
20852
  }
20721
20853
  }
20722
- let variant52;
20854
+ let variant54;
20723
20855
  switch (dataView(memory0).getUint8((base) + 100, true)) {
20724
20856
  case 0: {
20725
- variant52 = undefined;
20857
+ variant54 = undefined;
20726
20858
  break;
20727
20859
  }
20728
20860
  case 1: {
20729
- variant52 = {
20861
+ variant54 = {
20730
20862
  start: {
20731
20863
  line: dataView(memory0).getInt32((base) + 104, true) >>> 0,
20732
20864
  character: dataView(memory0).getInt32((base) + 108, true) >>> 0,
@@ -20742,11 +20874,11 @@ export function instantiate(getCoreModule, imports, instantiateCore = WebAssembl
20742
20874
  throw new TypeError('invalid variant discriminant for option');
20743
20875
  }
20744
20876
  }
20745
- variant53 = {
20746
- mode: enum48,
20747
- name: result49,
20748
- t: variant51,
20749
- declaredAt: variant52,
20877
+ variant55 = {
20878
+ mode: enum50,
20879
+ name: result51,
20880
+ t: variant53,
20881
+ declaredAt: variant54,
20750
20882
  };
20751
20883
  break;
20752
20884
  }
@@ -20754,56 +20886,56 @@ export function instantiate(getCoreModule, imports, instantiateCore = WebAssembl
20754
20886
  throw new TypeError('invalid variant discriminant for option');
20755
20887
  }
20756
20888
  }
20757
- let variant55;
20889
+ let variant57;
20758
20890
  switch (dataView(memory0).getUint8((base) + 120, true)) {
20759
20891
  case 0: {
20760
- variant55 = undefined;
20892
+ variant57 = undefined;
20761
20893
  break;
20762
20894
  }
20763
20895
  case 1: {
20764
- var ptr54 = dataView(memory0).getUint32((base) + 124, true) >>> 0;
20765
- var len54 = dataView(memory0).getUint32((base) + 128, true);
20766
- var result54 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr54, len54));
20767
- variant55 = result54;
20896
+ var ptr56 = dataView(memory0).getUint32((base) + 124, true) >>> 0;
20897
+ var len56 = dataView(memory0).getUint32((base) + 128, true);
20898
+ var result56 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr56, len56));
20899
+ variant57 = result56;
20768
20900
  break;
20769
20901
  }
20770
20902
  default: {
20771
20903
  throw new TypeError('invalid variant discriminant for option');
20772
20904
  }
20773
20905
  }
20774
- let variant58;
20906
+ let variant60;
20775
20907
  switch (dataView(memory0).getUint8((base) + 132, true)) {
20776
20908
  case 0: {
20777
- variant58 = undefined;
20909
+ variant60 = undefined;
20778
20910
  break;
20779
20911
  }
20780
20912
  case 1: {
20781
- var len57 = dataView(memory0).getUint32((base) + 140, true);
20782
- var base57 = dataView(memory0).getUint32((base) + 136, true) >>> 0;
20783
- if (base57 < 0 || len57 < 0 || len57 > 33554431 || base57 > memory0.buffer.byteLength || len57 > Math.floor((memory0.buffer.byteLength - base57) / 8)) throw new WebAssemblyRuntimeError('wasm trap: out of bounds memory access');
20784
- if (base57 % 4 !== 0) throw new TypeError(`list pointer [${base57}] is not aligned to 4`);
20785
- var result57 = [];
20786
- for (let i = 0; i < len57; i++) {
20787
- const base = base57 + i * 8;
20788
- var ptr56 = dataView(memory0).getUint32((base) + 0, true) >>> 0;
20789
- var len56 = dataView(memory0).getUint32((base) + 4, true);
20790
- var result56 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr56, len56));
20791
- result57.push(result56);
20792
- }
20793
- variant58 = result57;
20913
+ var len59 = dataView(memory0).getUint32((base) + 140, true);
20914
+ var base59 = dataView(memory0).getUint32((base) + 136, true) >>> 0;
20915
+ if (base59 < 0 || len59 < 0 || len59 > 33554431 || base59 > memory0.buffer.byteLength || len59 > Math.floor((memory0.buffer.byteLength - base59) / 8)) throw new WebAssemblyRuntimeError('wasm trap: out of bounds memory access');
20916
+ if (base59 % 4 !== 0) throw new TypeError(`list pointer [${base59}] is not aligned to 4`);
20917
+ var result59 = [];
20918
+ for (let i = 0; i < len59; i++) {
20919
+ const base = base59 + i * 8;
20920
+ var ptr58 = dataView(memory0).getUint32((base) + 0, true) >>> 0;
20921
+ var len58 = dataView(memory0).getUint32((base) + 4, true);
20922
+ var result58 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr58, len58));
20923
+ result59.push(result58);
20924
+ }
20925
+ variant60 = result59;
20794
20926
  break;
20795
20927
  }
20796
20928
  default: {
20797
20929
  throw new TypeError('invalid variant discriminant for option');
20798
20930
  }
20799
20931
  }
20800
- variant78= {
20932
+ variant80= {
20801
20933
  tag: 'class-method',
20802
20934
  val: {
20803
- normal: result47,
20804
- variadic: variant53,
20805
- t: variant55,
20806
- procedureBlock: variant58,
20935
+ normal: result49,
20936
+ variadic: variant55,
20937
+ t: variant57,
20938
+ procedureBlock: variant60,
20807
20939
  body: {
20808
20940
  start: {
20809
20941
  line: dataView(memory0).getInt32((base) + 144, true) >>> 0,
@@ -20819,76 +20951,76 @@ export function instantiate(getCoreModule, imports, instantiateCore = WebAssembl
20819
20951
  break;
20820
20952
  }
20821
20953
  case 12: {
20822
- var len66 = dataView(memory0).getUint32((base) + 68, true);
20823
- var base66 = dataView(memory0).getUint32((base) + 64, true) >>> 0;
20824
- if (base66 < 0 || len66 < 0 || len66 > 4793490 || base66 > memory0.buffer.byteLength || len66 > Math.floor((memory0.buffer.byteLength - base66) / 56)) throw new WebAssemblyRuntimeError('wasm trap: out of bounds memory access');
20825
- if (base66 % 4 !== 0) throw new TypeError(`list pointer [${base66}] is not aligned to 4`);
20826
- var result66 = [];
20827
- for (let i = 0; i < len66; i++) {
20828
- const base = base66 + i * 56;
20829
- let enum59;
20954
+ var len68 = dataView(memory0).getUint32((base) + 68, true);
20955
+ var base68 = dataView(memory0).getUint32((base) + 64, true) >>> 0;
20956
+ if (base68 < 0 || len68 < 0 || len68 > 4793490 || base68 > memory0.buffer.byteLength || len68 > Math.floor((memory0.buffer.byteLength - base68) / 56)) throw new WebAssemblyRuntimeError('wasm trap: out of bounds memory access');
20957
+ if (base68 % 4 !== 0) throw new TypeError(`list pointer [${base68}] is not aligned to 4`);
20958
+ var result68 = [];
20959
+ for (let i = 0; i < len68; i++) {
20960
+ const base = base68 + i * 56;
20961
+ let enum61;
20830
20962
  switch (dataView(memory0).getUint8((base) + 0, true)) {
20831
20963
  case 0: {
20832
- enum59 = 'default';
20964
+ enum61 = 'default';
20833
20965
  break;
20834
20966
  }
20835
20967
  case 1: {
20836
- enum59 = 'output';
20968
+ enum61 = 'output';
20837
20969
  break;
20838
20970
  }
20839
20971
  case 2: {
20840
- enum59 = 'by-ref';
20972
+ enum61 = 'by-ref';
20841
20973
  break;
20842
20974
  }
20843
20975
  default: {
20844
20976
  throw new TypeError('invalid discriminant specified for ArgMode');
20845
20977
  }
20846
20978
  }
20847
- var ptr60 = dataView(memory0).getUint32((base) + 4, true) >>> 0;
20848
- var len60 = dataView(memory0).getUint32((base) + 8, true);
20849
- var result60 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr60, len60));
20850
- let variant62;
20979
+ var ptr62 = dataView(memory0).getUint32((base) + 4, true) >>> 0;
20980
+ var len62 = dataView(memory0).getUint32((base) + 8, true);
20981
+ var result62 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr62, len62));
20982
+ let variant64;
20851
20983
  switch (dataView(memory0).getUint8((base) + 12, true)) {
20852
20984
  case 0: {
20853
- variant62 = undefined;
20985
+ variant64 = undefined;
20854
20986
  break;
20855
20987
  }
20856
20988
  case 1: {
20857
- var ptr61 = dataView(memory0).getUint32((base) + 16, true) >>> 0;
20858
- var len61 = dataView(memory0).getUint32((base) + 20, true);
20859
- var result61 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr61, len61));
20860
- variant62 = result61;
20989
+ var ptr63 = dataView(memory0).getUint32((base) + 16, true) >>> 0;
20990
+ var len63 = dataView(memory0).getUint32((base) + 20, true);
20991
+ var result63 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr63, len63));
20992
+ variant64 = result63;
20861
20993
  break;
20862
20994
  }
20863
20995
  default: {
20864
20996
  throw new TypeError('invalid variant discriminant for option');
20865
20997
  }
20866
20998
  }
20867
- let variant64;
20999
+ let variant66;
20868
21000
  switch (dataView(memory0).getUint8((base) + 24, true)) {
20869
21001
  case 0: {
20870
- variant64 = undefined;
21002
+ variant66 = undefined;
20871
21003
  break;
20872
21004
  }
20873
21005
  case 1: {
20874
- var ptr63 = dataView(memory0).getUint32((base) + 28, true) >>> 0;
20875
- var len63 = dataView(memory0).getUint32((base) + 32, true);
20876
- var result63 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr63, len63));
20877
- variant64 = result63;
21006
+ var ptr65 = dataView(memory0).getUint32((base) + 28, true) >>> 0;
21007
+ var len65 = dataView(memory0).getUint32((base) + 32, true);
21008
+ var result65 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr65, len65));
21009
+ variant66 = result65;
20878
21010
  break;
20879
21011
  }
20880
21012
  default: {
20881
21013
  throw new TypeError('invalid variant discriminant for option');
20882
21014
  }
20883
21015
  }
20884
- let variant65;
21016
+ let variant67;
20885
21017
  switch (dataView(memory0).getUint8((base) + 36, true)) {
20886
21018
  case 0: {
20887
- variant65 = undefined;
21019
+ variant67 = undefined;
20888
21020
  break;
20889
21021
  }
20890
21022
  case 1: {
20891
- variant65 = {
21023
+ variant67 = {
20892
21024
  start: {
20893
21025
  line: dataView(memory0).getInt32((base) + 40, true) >>> 0,
20894
21026
  character: dataView(memory0).getInt32((base) + 44, true) >>> 0,
@@ -20904,67 +21036,67 @@ export function instantiate(getCoreModule, imports, instantiateCore = WebAssembl
20904
21036
  throw new TypeError('invalid variant discriminant for option');
20905
21037
  }
20906
21038
  }
20907
- result66.push({
20908
- mode: enum59,
20909
- name: result60,
20910
- t: variant62,
20911
- default: variant64,
20912
- declaredAt: variant65,
21039
+ result68.push({
21040
+ mode: enum61,
21041
+ name: result62,
21042
+ t: variant64,
21043
+ default: variant66,
21044
+ declaredAt: variant67,
20913
21045
  });
20914
21046
  }
20915
- let variant72;
21047
+ let variant74;
20916
21048
  switch (dataView(memory0).getUint8((base) + 72, true)) {
20917
21049
  case 0: {
20918
- variant72 = undefined;
21050
+ variant74 = undefined;
20919
21051
  break;
20920
21052
  }
20921
21053
  case 1: {
20922
- let enum67;
21054
+ let enum69;
20923
21055
  switch (dataView(memory0).getUint8((base) + 76, true)) {
20924
21056
  case 0: {
20925
- enum67 = 'default';
21057
+ enum69 = 'default';
20926
21058
  break;
20927
21059
  }
20928
21060
  case 1: {
20929
- enum67 = 'output';
21061
+ enum69 = 'output';
20930
21062
  break;
20931
21063
  }
20932
21064
  case 2: {
20933
- enum67 = 'by-ref';
21065
+ enum69 = 'by-ref';
20934
21066
  break;
20935
21067
  }
20936
21068
  default: {
20937
21069
  throw new TypeError('invalid discriminant specified for ArgMode');
20938
21070
  }
20939
21071
  }
20940
- var ptr68 = dataView(memory0).getUint32((base) + 80, true) >>> 0;
20941
- var len68 = dataView(memory0).getUint32((base) + 84, true);
20942
- var result68 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr68, len68));
20943
- let variant70;
21072
+ var ptr70 = dataView(memory0).getUint32((base) + 80, true) >>> 0;
21073
+ var len70 = dataView(memory0).getUint32((base) + 84, true);
21074
+ var result70 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr70, len70));
21075
+ let variant72;
20944
21076
  switch (dataView(memory0).getUint8((base) + 88, true)) {
20945
21077
  case 0: {
20946
- variant70 = undefined;
21078
+ variant72 = undefined;
20947
21079
  break;
20948
21080
  }
20949
21081
  case 1: {
20950
- var ptr69 = dataView(memory0).getUint32((base) + 92, true) >>> 0;
20951
- var len69 = dataView(memory0).getUint32((base) + 96, true);
20952
- var result69 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr69, len69));
20953
- variant70 = result69;
21082
+ var ptr71 = dataView(memory0).getUint32((base) + 92, true) >>> 0;
21083
+ var len71 = dataView(memory0).getUint32((base) + 96, true);
21084
+ var result71 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr71, len71));
21085
+ variant72 = result71;
20954
21086
  break;
20955
21087
  }
20956
21088
  default: {
20957
21089
  throw new TypeError('invalid variant discriminant for option');
20958
21090
  }
20959
21091
  }
20960
- let variant71;
21092
+ let variant73;
20961
21093
  switch (dataView(memory0).getUint8((base) + 100, true)) {
20962
21094
  case 0: {
20963
- variant71 = undefined;
21095
+ variant73 = undefined;
20964
21096
  break;
20965
21097
  }
20966
21098
  case 1: {
20967
- variant71 = {
21099
+ variant73 = {
20968
21100
  start: {
20969
21101
  line: dataView(memory0).getInt32((base) + 104, true) >>> 0,
20970
21102
  character: dataView(memory0).getInt32((base) + 108, true) >>> 0,
@@ -20980,11 +21112,11 @@ export function instantiate(getCoreModule, imports, instantiateCore = WebAssembl
20980
21112
  throw new TypeError('invalid variant discriminant for option');
20981
21113
  }
20982
21114
  }
20983
- variant72 = {
20984
- mode: enum67,
20985
- name: result68,
20986
- t: variant70,
20987
- declaredAt: variant71,
21115
+ variant74 = {
21116
+ mode: enum69,
21117
+ name: result70,
21118
+ t: variant72,
21119
+ declaredAt: variant73,
20988
21120
  };
20989
21121
  break;
20990
21122
  }
@@ -20992,56 +21124,56 @@ export function instantiate(getCoreModule, imports, instantiateCore = WebAssembl
20992
21124
  throw new TypeError('invalid variant discriminant for option');
20993
21125
  }
20994
21126
  }
20995
- let variant74;
21127
+ let variant76;
20996
21128
  switch (dataView(memory0).getUint8((base) + 120, true)) {
20997
21129
  case 0: {
20998
- variant74 = undefined;
21130
+ variant76 = undefined;
20999
21131
  break;
21000
21132
  }
21001
21133
  case 1: {
21002
- var ptr73 = dataView(memory0).getUint32((base) + 124, true) >>> 0;
21003
- var len73 = dataView(memory0).getUint32((base) + 128, true);
21004
- var result73 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr73, len73));
21005
- variant74 = result73;
21134
+ var ptr75 = dataView(memory0).getUint32((base) + 124, true) >>> 0;
21135
+ var len75 = dataView(memory0).getUint32((base) + 128, true);
21136
+ var result75 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr75, len75));
21137
+ variant76 = result75;
21006
21138
  break;
21007
21139
  }
21008
21140
  default: {
21009
21141
  throw new TypeError('invalid variant discriminant for option');
21010
21142
  }
21011
21143
  }
21012
- let variant77;
21144
+ let variant79;
21013
21145
  switch (dataView(memory0).getUint8((base) + 132, true)) {
21014
21146
  case 0: {
21015
- variant77 = undefined;
21147
+ variant79 = undefined;
21016
21148
  break;
21017
21149
  }
21018
21150
  case 1: {
21019
- var len76 = dataView(memory0).getUint32((base) + 140, true);
21020
- var base76 = dataView(memory0).getUint32((base) + 136, true) >>> 0;
21021
- if (base76 < 0 || len76 < 0 || len76 > 33554431 || base76 > memory0.buffer.byteLength || len76 > Math.floor((memory0.buffer.byteLength - base76) / 8)) throw new WebAssemblyRuntimeError('wasm trap: out of bounds memory access');
21022
- if (base76 % 4 !== 0) throw new TypeError(`list pointer [${base76}] is not aligned to 4`);
21023
- var result76 = [];
21024
- for (let i = 0; i < len76; i++) {
21025
- const base = base76 + i * 8;
21026
- var ptr75 = dataView(memory0).getUint32((base) + 0, true) >>> 0;
21027
- var len75 = dataView(memory0).getUint32((base) + 4, true);
21028
- var result75 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr75, len75));
21029
- result76.push(result75);
21030
- }
21031
- variant77 = result76;
21151
+ var len78 = dataView(memory0).getUint32((base) + 140, true);
21152
+ var base78 = dataView(memory0).getUint32((base) + 136, true) >>> 0;
21153
+ if (base78 < 0 || len78 < 0 || len78 > 33554431 || base78 > memory0.buffer.byteLength || len78 > Math.floor((memory0.buffer.byteLength - base78) / 8)) throw new WebAssemblyRuntimeError('wasm trap: out of bounds memory access');
21154
+ if (base78 % 4 !== 0) throw new TypeError(`list pointer [${base78}] is not aligned to 4`);
21155
+ var result78 = [];
21156
+ for (let i = 0; i < len78; i++) {
21157
+ const base = base78 + i * 8;
21158
+ var ptr77 = dataView(memory0).getUint32((base) + 0, true) >>> 0;
21159
+ var len77 = dataView(memory0).getUint32((base) + 4, true);
21160
+ var result77 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr77, len77));
21161
+ result78.push(result77);
21162
+ }
21163
+ variant79 = result78;
21032
21164
  break;
21033
21165
  }
21034
21166
  default: {
21035
21167
  throw new TypeError('invalid variant discriminant for option');
21036
21168
  }
21037
21169
  }
21038
- variant78= {
21170
+ variant80= {
21039
21171
  tag: 'client-method',
21040
21172
  val: {
21041
- normal: result66,
21042
- variadic: variant72,
21043
- t: variant74,
21044
- procedureBlock: variant77,
21173
+ normal: result68,
21174
+ variadic: variant74,
21175
+ t: variant76,
21176
+ procedureBlock: variant79,
21045
21177
  body: {
21046
21178
  start: {
21047
21179
  line: dataView(memory0).getInt32((base) + 144, true) >>> 0,
@@ -21060,41 +21192,41 @@ export function instantiate(getCoreModule, imports, instantiateCore = WebAssembl
21060
21192
  throw new TypeError('invalid variant discriminant for MemberKind');
21061
21193
  }
21062
21194
  }
21063
- let variant80;
21195
+ let variant82;
21064
21196
  switch (dataView(memory0).getUint8((base) + 168, true)) {
21065
21197
  case 0: {
21066
- variant80 = undefined;
21198
+ variant82 = undefined;
21067
21199
  break;
21068
21200
  }
21069
21201
  case 1: {
21070
- var ptr79 = dataView(memory0).getUint32((base) + 172, true) >>> 0;
21071
- var len79 = dataView(memory0).getUint32((base) + 176, true);
21072
- var result79 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr79, len79));
21073
- variant80 = result79;
21202
+ var ptr81 = dataView(memory0).getUint32((base) + 172, true) >>> 0;
21203
+ var len81 = dataView(memory0).getUint32((base) + 176, true);
21204
+ var result81 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr81, len81));
21205
+ variant82 = result81;
21074
21206
  break;
21075
21207
  }
21076
21208
  default: {
21077
21209
  throw new TypeError('invalid variant discriminant for option');
21078
21210
  }
21079
21211
  }
21080
- let variant82;
21212
+ let variant84;
21081
21213
  switch (dataView(memory0).getUint8((base) + 180, true)) {
21082
21214
  case 0: {
21083
- variant82 = undefined;
21215
+ variant84 = undefined;
21084
21216
  break;
21085
21217
  }
21086
21218
  case 1: {
21087
- var ptr81 = dataView(memory0).getUint32((base) + 184, true) >>> 0;
21088
- var len81 = dataView(memory0).getUint32((base) + 188, true);
21089
- var result81 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr81, len81));
21090
- variant82 = result81;
21219
+ var ptr83 = dataView(memory0).getUint32((base) + 184, true) >>> 0;
21220
+ var len83 = dataView(memory0).getUint32((base) + 188, true);
21221
+ var result83 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr83, len83));
21222
+ variant84 = result83;
21091
21223
  break;
21092
21224
  }
21093
21225
  default: {
21094
21226
  throw new TypeError('invalid variant discriminant for option');
21095
21227
  }
21096
21228
  }
21097
- result83.push([result4, {
21229
+ result85.push([result4, {
21098
21230
  doc: result5,
21099
21231
  before: {
21100
21232
  line: dataView(memory0).getInt32((base) + 16, true) >>> 0,
@@ -21113,13 +21245,13 @@ export function instantiate(getCoreModule, imports, instantiateCore = WebAssembl
21113
21245
  },
21114
21246
  aliases: result8,
21115
21247
  deprecated: bool9 == 0 ? false : (bool9 == 1 ? true : throwInvalidBool()),
21116
- kind: variant78,
21248
+ kind: variant80,
21117
21249
  after: {
21118
21250
  line: dataView(memory0).getInt32((base) + 160, true) >>> 0,
21119
21251
  character: dataView(memory0).getInt32((base) + 164, true) >>> 0,
21120
21252
  },
21121
- uri: variant80,
21122
- origin: variant82,
21253
+ uri: variant82,
21254
+ origin: variant84,
21123
21255
  }]);
21124
21256
  }
21125
21257
  _debugLog('[iface="iris:ascot/exported", function="[method]workspace.query-mem"][Instruction::Return]', {
@@ -21128,8 +21260,8 @@ export function instantiate(getCoreModule, imports, instantiateCore = WebAssembl
21128
21260
  async: false,
21129
21261
  postReturn: true
21130
21262
  });
21131
- task.resolve([result83]);
21132
- const retCopy = result83;
21263
+ task.resolve([result85]);
21264
+ const retCopy = result85;
21133
21265
 
21134
21266
  let cstate = getOrCreateAsyncState(0);
21135
21267
  cstate.mayLeave = false;
@@ -21688,25 +21820,37 @@ export function instantiate(getCoreModule, imports, instantiateCore = WebAssembl
21688
21820
  _lowerFlatOption({
21689
21821
  caseMetas: [
21690
21822
  [ 'none', null, 0, 0, 0 ],
21691
- [ 'some', _lowerFlatRecord({ fieldMetas: [['text', _lowerFlatStringAny, 8, 4 ],['uri',
21823
+ [ 'some',
21692
21824
  _lowerFlatOption({
21693
21825
  caseMetas: [
21694
21826
  [ 'none', null, 0, 0, 0 ],
21695
- [ 'some', _lowerFlatStringAny, 8, 4, 2],
21827
+ [ 'some', _lowerFlatRecord({ fieldMetas: [['text', _lowerFlatStringAny, 8, 4 ],['uri',
21828
+ _lowerFlatOption({
21829
+ caseMetas: [
21830
+ [ 'none', null, 0, 0, 0 ],
21831
+ [ 'some', _lowerFlatStringAny, 8, 4, 2],
21832
+ ],
21833
+ variantSize32: 12,
21834
+ variantAlign32: 4,
21835
+ variantPayloadOffset32: 4,
21836
+ variantFlatCount: 3,
21837
+ payloadMaybeNull: false,
21838
+ })
21839
+ , 12, 4 ],], size32: 20, align32: 4 }), 20, 4, 5],
21696
21840
  ],
21697
- variantSize32: 12,
21841
+ variantSize32: 24,
21698
21842
  variantAlign32: 4,
21699
21843
  variantPayloadOffset32: 4,
21700
- variantFlatCount: 3,
21844
+ variantFlatCount: 6,
21701
21845
  payloadMaybeNull: false,
21702
21846
  })
21703
- , 12, 4 ],], size32: 20, align32: 4 }), 20, 4, 5],
21847
+ , 24, 4, 6],
21704
21848
  ],
21705
- variantSize32: 24,
21849
+ variantSize32: 28,
21706
21850
  variantAlign32: 4,
21707
21851
  variantPayloadOffset32: 4,
21708
- variantFlatCount: 6,
21709
- payloadMaybeNull: false,
21852
+ variantFlatCount: 7,
21853
+ payloadMaybeNull: true,
21710
21854
  })
21711
21855
  ],
21712
21856
  hasResultPointer: true,
@@ -21732,25 +21876,37 @@ export function instantiate(getCoreModule, imports, instantiateCore = WebAssembl
21732
21876
  _lowerFlatOption({
21733
21877
  caseMetas: [
21734
21878
  [ 'none', null, 0, 0, 0 ],
21735
- [ 'some', _lowerFlatRecord({ fieldMetas: [['text', _lowerFlatStringAny, 8, 4 ],['uri',
21879
+ [ 'some',
21736
21880
  _lowerFlatOption({
21737
21881
  caseMetas: [
21738
21882
  [ 'none', null, 0, 0, 0 ],
21739
- [ 'some', _lowerFlatStringAny, 8, 4, 2],
21883
+ [ 'some', _lowerFlatRecord({ fieldMetas: [['text', _lowerFlatStringAny, 8, 4 ],['uri',
21884
+ _lowerFlatOption({
21885
+ caseMetas: [
21886
+ [ 'none', null, 0, 0, 0 ],
21887
+ [ 'some', _lowerFlatStringAny, 8, 4, 2],
21888
+ ],
21889
+ variantSize32: 12,
21890
+ variantAlign32: 4,
21891
+ variantPayloadOffset32: 4,
21892
+ variantFlatCount: 3,
21893
+ payloadMaybeNull: false,
21894
+ })
21895
+ , 12, 4 ],], size32: 20, align32: 4 }), 20, 4, 5],
21740
21896
  ],
21741
- variantSize32: 12,
21897
+ variantSize32: 24,
21742
21898
  variantAlign32: 4,
21743
21899
  variantPayloadOffset32: 4,
21744
- variantFlatCount: 3,
21900
+ variantFlatCount: 6,
21745
21901
  payloadMaybeNull: false,
21746
21902
  })
21747
- , 12, 4 ],], size32: 20, align32: 4 }), 20, 4, 5],
21903
+ , 24, 4, 6],
21748
21904
  ],
21749
- variantSize32: 24,
21905
+ variantSize32: 28,
21750
21906
  variantAlign32: 4,
21751
21907
  variantPayloadOffset32: 4,
21752
- variantFlatCount: 6,
21753
- payloadMaybeNull: false,
21908
+ variantFlatCount: 7,
21909
+ payloadMaybeNull: true,
21754
21910
  })
21755
21911
  ],
21756
21912
  hasResultPointer: true,
@@ -21843,7 +21999,7 @@ export function instantiate(getCoreModule, imports, instantiateCore = WebAssembl
21843
21999
  variantFlatCount: 2,
21844
22000
  payloadMaybeNull: false,
21845
22001
  })
21846
- , 2, 1 ],['multidimensional', _lowerFlatBool, 1, 1 ],], size32: 16, align32: 4 }), 16, 4, 6 ],[ 'relationship',
22002
+ , 2, 1 ],['multidimensional', _lowerFlatBool, 1, 1 ],], size32: 16, align32: 4 }), 16, 4, 6 ],[ 'relationship', _lowerFlatRecord({ fieldMetas: [['t',
21847
22003
  _lowerFlatOption({
21848
22004
  caseMetas: [
21849
22005
  [ 'none', null, 0, 0, 0 ],
@@ -21855,7 +22011,27 @@ export function instantiate(getCoreModule, imports, instantiateCore = WebAssembl
21855
22011
  variantFlatCount: 3,
21856
22012
  payloadMaybeNull: false,
21857
22013
  })
21858
- , 12, 4, 3 ],[ 'foreign-key', null, 0, 0, 0 ],[ 'index', null, 0, 0, 0 ],[ 'projection', null, 0, 0, 0 ],[ 'trigger', null, 0, 0, 0 ],[ 'x-data', null, 0, 0, 0 ],[ 'storage', null, 0, 0, 0 ],[ 'query', null, 0, 0, 0 ],[ 'method', _lowerFlatRecord({ fieldMetas: [['normal', _lowerFlatList({
22014
+ , 12, 4 ],['cardinality',
22015
+ _lowerFlatOption({
22016
+ caseMetas: [
22017
+ [ 'none', null, 0, 0, 0 ],
22018
+ [ 'some',
22019
+ _lowerFlatEnum({
22020
+ caseMetas: [['one', null, 1, 1, 1],['many', null, 1, 1, 1],['parent', null, 1, 1, 1],['children', null, 1, 1, 1],],
22021
+ variantSize32: 1,
22022
+ variantAlign32: 1,
22023
+ variantPayloadOffset32: 1,
22024
+ variantFlatCount: 1,
22025
+ })
22026
+ , 1, 1, 1],
22027
+ ],
22028
+ variantSize32: 2,
22029
+ variantAlign32: 1,
22030
+ variantPayloadOffset32: 1,
22031
+ variantFlatCount: 2,
22032
+ payloadMaybeNull: false,
22033
+ })
22034
+ , 2, 1 ],], size32: 16, align32: 4 }), 16, 4, 5 ],[ 'foreign-key', null, 0, 0, 0 ],[ 'index', null, 0, 0, 0 ],[ 'projection', null, 0, 0, 0 ],[ 'trigger', null, 0, 0, 0 ],[ 'x-data', null, 0, 0, 0 ],[ 'storage', null, 0, 0, 0 ],[ 'query', null, 0, 0, 0 ],[ 'method', _lowerFlatRecord({ fieldMetas: [['normal', _lowerFlatList({
21859
22035
  elemLowerFn: _lowerFlatRecord({ fieldMetas: [['mode',
21860
22036
  _lowerFlatEnum({
21861
22037
  caseMetas: [['default', null, 1, 1, 1],['output', null, 1, 1, 1],['by-ref', null, 1, 1, 1],],
@@ -22377,7 +22553,7 @@ export function instantiate(getCoreModule, imports, instantiateCore = WebAssembl
22377
22553
  variantFlatCount: 2,
22378
22554
  payloadMaybeNull: false,
22379
22555
  })
22380
- , 2, 1 ],['multidimensional', _lowerFlatBool, 1, 1 ],], size32: 16, align32: 4 }), 16, 4, 6 ],[ 'relationship',
22556
+ , 2, 1 ],['multidimensional', _lowerFlatBool, 1, 1 ],], size32: 16, align32: 4 }), 16, 4, 6 ],[ 'relationship', _lowerFlatRecord({ fieldMetas: [['t',
22381
22557
  _lowerFlatOption({
22382
22558
  caseMetas: [
22383
22559
  [ 'none', null, 0, 0, 0 ],
@@ -22389,7 +22565,27 @@ export function instantiate(getCoreModule, imports, instantiateCore = WebAssembl
22389
22565
  variantFlatCount: 3,
22390
22566
  payloadMaybeNull: false,
22391
22567
  })
22392
- , 12, 4, 3 ],[ 'foreign-key', null, 0, 0, 0 ],[ 'index', null, 0, 0, 0 ],[ 'projection', null, 0, 0, 0 ],[ 'trigger', null, 0, 0, 0 ],[ 'x-data', null, 0, 0, 0 ],[ 'storage', null, 0, 0, 0 ],[ 'query', null, 0, 0, 0 ],[ 'method', _lowerFlatRecord({ fieldMetas: [['normal', _lowerFlatList({
22568
+ , 12, 4 ],['cardinality',
22569
+ _lowerFlatOption({
22570
+ caseMetas: [
22571
+ [ 'none', null, 0, 0, 0 ],
22572
+ [ 'some',
22573
+ _lowerFlatEnum({
22574
+ caseMetas: [['one', null, 1, 1, 1],['many', null, 1, 1, 1],['parent', null, 1, 1, 1],['children', null, 1, 1, 1],],
22575
+ variantSize32: 1,
22576
+ variantAlign32: 1,
22577
+ variantPayloadOffset32: 1,
22578
+ variantFlatCount: 1,
22579
+ })
22580
+ , 1, 1, 1],
22581
+ ],
22582
+ variantSize32: 2,
22583
+ variantAlign32: 1,
22584
+ variantPayloadOffset32: 1,
22585
+ variantFlatCount: 2,
22586
+ payloadMaybeNull: false,
22587
+ })
22588
+ , 2, 1 ],], size32: 16, align32: 4 }), 16, 4, 5 ],[ 'foreign-key', null, 0, 0, 0 ],[ 'index', null, 0, 0, 0 ],[ 'projection', null, 0, 0, 0 ],[ 'trigger', null, 0, 0, 0 ],[ 'x-data', null, 0, 0, 0 ],[ 'storage', null, 0, 0, 0 ],[ 'query', null, 0, 0, 0 ],[ 'method', _lowerFlatRecord({ fieldMetas: [['normal', _lowerFlatList({
22393
22589
  elemLowerFn: _lowerFlatRecord({ fieldMetas: [['mode',
22394
22590
  _lowerFlatEnum({
22395
22591
  caseMetas: [['default', null, 1, 1, 1],['output', null, 1, 1, 1],['by-ref', null, 1, 1, 1],],