json-as 1.1.15 → 1.1.16

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (8) hide show
  1. package/CHANGELOG.md +7 -2
  2. package/README.md +1 -10
  3. package/assembly/test.tmp.ts +245 -291
  4. package/assembly/test.ts +35 -26
  5. package/package.json +3 -2
  6. package/transform/lib/index.js +26 -29
  7. package/transform/lib/index.js.map +1 -1
  8. package/transform/src/index.ts +33 -26
package/assembly/test.tmp.ts CHANGED
@@ -1,38 +1,31 @@
1
1
  import { bs } from "../lib/as-bs";
2
2
  import { JSON } from ".";
3
3
 
4
-
5
4
  @json
6
- class Person {
7
- id: string | null = null;
8
- firstName: string = "";
9
- lastName: string = "";
5
+ class Vec3 {
6
+ x: f32 = 0;
7
+ y: f32 = 0;
8
+ z: f32 = 0;
10
9
  __SERIALIZE(ptr: usize): void {
11
- bs.proposeSize(64);
12
- store<u64>(bs.offset, 28147948644860027, 0);
13
- store<u32>(bs.offset, 3801122, 8);
14
- bs.offset += 12;
15
- JSON.__serialize<string | null>(load<string | null>(ptr, offsetof<this>("id")));
16
- store<u64>(bs.offset, 29555310643511340, 0);
17
- store<u64>(bs.offset, 21955546407174258, 8);
18
- store<u64>(bs.offset, 9570583007002721, 16);
19
- store<u16>(bs.offset, 58, 24);
20
- bs.offset += 26;
21
- JSON.__serialize<string>(load<string>(ptr, offsetof<this>("firstName")));
22
- store<u64>(bs.offset, 27303536599629868, 0);
23
- store<u64>(bs.offset, 27303407755985011, 8);
24
- store<u64>(bs.offset, 16325694684725357, 16);
25
- bs.offset += 24;
26
- JSON.__serialize<string>(load<string>(ptr, offsetof<this>("lastName")));
10
+ bs.proposeSize(32);
11
+ store<u64>(bs.offset, 9570664606466171, 0);
12
+ store<u16>(bs.offset, 58, 8);
13
+ bs.offset += 10;
14
+ JSON.__serialize<f32>(load<f32>(ptr, offsetof<this>("x")));
15
+ store<u64>(bs.offset, 9570668901433388, 0);
16
+ store<u16>(bs.offset, 58, 8);
17
+ bs.offset += 10;
18
+ JSON.__serialize<f32>(load<f32>(ptr, offsetof<this>("y")));
19
+ store<u64>(bs.offset, 9570673196400684, 0);
20
+ store<u16>(bs.offset, 58, 8);
21
+ bs.offset += 10;
22
+ JSON.__serialize<f32>(load<f32>(ptr, offsetof<this>("z")));
27
23
  store<u16>(bs.offset, 125, 0);
28
24
  bs.offset += 2;
29
25
  }
30
26
 
31
-
32
27
  @inline
33
28
  __INITIALIZE(): this {
34
- this.firstName = "";
35
- this.lastName = "";
36
29
  return this;
37
30
  }
38
31
  __DESERIALIZE<__JSON_T>(srcStart: usize, srcEnd: usize, out: __JSON_T): __JSON_T {
@@ -71,53 +64,45 @@ class Person {
71
64
  while (srcStart < srcEnd) {
72
65
  const code = load<u16>(srcStart);
73
66
  if (code == 34 && load<u16>(srcStart - 2) !== 92) {
67
+ srcStart += 4;
68
+ keyStart = 0;
69
+ break;
70
+ }
71
+ srcStart += 2;
72
+ }
73
+ } else if (code - 48 <= 9 || code == 45) {
74
+ lastIndex = srcStart;
75
+ srcStart += 2;
76
+ while (srcStart < srcEnd) {
77
+ const code = load<u16>(srcStart);
78
+ if (code == 44 || code == 125 || JSON.Util.isSpace(code)) {
74
79
  switch (<u32>keyEnd - <u32>keyStart) {
75
- case 4: {
76
- const code32 = load<u32>(keyStart);
77
- if (code32 == 6553705) {
78
- store<string | null>(changetype<usize>(out), JSON.__deserialize<string | null>(lastIndex, srcStart + 2), offsetof<this>("id"));
79
- srcStart += 4;
80
- keyStart = 0;
81
- break;
82
- } else {
83
- srcStart += 4;
84
- keyStart = 0;
85
- break;
86
- }
87
- }
88
-
89
- case 18: {
90
- const codeS8 = load<u64>(keyStart, 0);
91
- const codeS16 = load<u64>(keyStart, 8);
92
- if (codeS8 == 32370111954878566 && codeS16 == 30681189078401140) {
93
- store<string>(changetype<usize>(out), JSON.__deserialize<string>(lastIndex, srcStart + 2), offsetof<this>("firstName"));
94
- srcStart += 4;
80
+ case 2: {
81
+ const code16 = load<u16>(keyStart);
82
+ if (code16 == 120) {
83
+ store<f32>(changetype<usize>(out), JSON.__deserialize<f32>(lastIndex, srcStart), offsetof<this>("x"));
84
+ srcStart += 2;
95
85
  keyStart = 0;
96
86
  break;
97
- } else {
98
- srcStart += 4;
87
+ } else if (code16 == 121) {
88
+ store<f32>(changetype<usize>(out), JSON.__deserialize<f32>(lastIndex, srcStart), offsetof<this>("y"));
89
+ srcStart += 2;
99
90
  keyStart = 0;
100
91
  break;
101
- }
102
- }
103
-
104
- case 16: {
105
- const codeS8 = load<u64>(keyStart, 0);
106
- const codeS16 = load<u64>(keyStart, 8);
107
- if (codeS8 == 32651591226032236 && codeS16 == 28429440805568590) {
108
- store<string>(changetype<usize>(out), JSON.__deserialize<string>(lastIndex, srcStart + 2), offsetof<this>("lastName"));
109
- srcStart += 4;
92
+ } else if (code16 == 122) {
93
+ store<f32>(changetype<usize>(out), JSON.__deserialize<f32>(lastIndex, srcStart), offsetof<this>("z"));
94
+ srcStart += 2;
110
95
  keyStart = 0;
111
96
  break;
112
97
  } else {
113
- srcStart += 4;
98
+ srcStart += 2;
114
99
  keyStart = 0;
115
100
  break;
116
101
  }
117
102
  }
118
103
 
119
104
  default: {
120
- srcStart += 4;
105
+ srcStart += 2;
121
106
  keyStart = 0;
122
107
  break;
123
108
  }
@@ -126,18 +111,6 @@ class Person {
126
111
  }
127
112
  srcStart += 2;
128
113
  }
129
- } else if (code - 48 <= 9 || code == 45) {
130
- lastIndex = srcStart;
131
- srcStart += 2;
132
- while (srcStart < srcEnd) {
133
- const code = load<u16>(srcStart);
134
- if (code == 44 || code == 125 || JSON.Util.isSpace(code)) {
135
- srcStart += 2;
136
- keyStart = 0;
137
- break;
138
- }
139
- srcStart += 2;
140
- }
141
114
  } else if (code == 123) {
142
115
  lastIndex = srcStart;
143
116
  depth++;
@@ -150,7 +123,32 @@ class Person {
150
123
  } else if (code == 125) {
151
124
  if (--depth == 0) {
152
125
  srcStart += 2;
153
- keyStart = 0;
126
+ switch (<u32>keyEnd - <u32>keyStart) {
127
+ case 2: {
128
+ const code16 = load<u16>(keyStart);
129
+ if (code16 == 120) {
130
+ store<f32>(changetype<usize>(out), JSON.__deserialize<f32>(lastIndex, srcStart), offsetof<this>("x"));
131
+ keyStart = 0;
132
+ break;
133
+ } else if (code16 == 121) {
134
+ store<f32>(changetype<usize>(out), JSON.__deserialize<f32>(lastIndex, srcStart), offsetof<this>("y"));
135
+ keyStart = 0;
136
+ break;
137
+ } else if (code16 == 122) {
138
+ store<f32>(changetype<usize>(out), JSON.__deserialize<f32>(lastIndex, srcStart), offsetof<this>("z"));
139
+ keyStart = 0;
140
+ break;
141
+ } else {
142
+ keyStart = 0;
143
+ break;
144
+ }
145
+ }
146
+
147
+ default: {
148
+ keyStart = 0;
149
+ break;
150
+ }
151
+ }
154
152
  break;
155
153
  }
156
154
  } else if (code == 123) depth++;
@@ -193,26 +191,8 @@ class Person {
193
191
  } else if (code == 110) {
194
192
  if (load<u64>(srcStart) == 30399761348886638) {
195
193
  srcStart += 8;
196
- switch (<u32>keyEnd - <u32>keyStart) {
197
- case 4: {
198
- const code32 = load<u32>(keyStart);
199
- if (code32 == 6553705) {
200
- store<usize>(changetype<usize>(out), 0, offsetof<this>("id"));
201
- srcStart += 2;
202
- keyStart = 0;
203
- break;
204
- } else {
205
- srcStart += 2;
206
- keyStart = 0;
207
- break;
208
- }
209
- }
210
-
211
- default: {
212
- srcStart += 2;
213
- keyStart = 0;
214
- }
215
- }
194
+ srcStart += 2;
195
+ keyStart = 0;
216
196
  }
217
197
  } else {
218
198
  srcStart += 2;
@@ -224,25 +204,72 @@ class Person {
224
204
  }
225
205
  }
226
206
 
227
-
228
207
  @json
229
- class PeopleData {
230
- people: Array<Person> = [];
208
+ class Player {
209
+
210
+ @alias("first name")
211
+ firstName!: string | null;
212
+ lastName!: string;
213
+ lastActive!: Array<i32>;
214
+
215
+ @omitif((self: this): boolean => self.age < 18)
216
+ age!: i32;
217
+
218
+ @omitnull()
219
+ pos!: Vec3 | null;
220
+ isVerified!: boolean;
231
221
  __SERIALIZE(ptr: usize): void {
232
- bs.proposeSize(22);
233
- store<u64>(bs.offset, 28429453686341755, 0);
234
- store<u64>(bs.offset, 28429436511584367, 8);
235
- store<u32>(bs.offset, 3801122, 16);
236
- bs.offset += 20;
237
- JSON.__serialize<Array<Person>>(load<Array<Person>>(ptr, offsetof<this>("people")));
222
+ bs.proposeSize(160);
223
+ let block: usize = 0;
224
+ store<u16>(bs.offset, 123, 0);
225
+ bs.offset += 2;
226
+ if (!((self: this): boolean => self.age < 18)(this)) {
227
+ store<u64>(bs.offset, 28429415035764770, 0);
228
+ store<u32>(bs.offset, 3801122, 8);
229
+ bs.offset += 12;
230
+ JSON.__serialize<i32>(load<i32>(ptr, offsetof<this>("age")));
231
+ store<u16>(bs.offset, 44, 0);
232
+ bs.offset += 2;
233
+ }
234
+ if ((block = load<usize>(ptr, offsetof<this>("pos"))) !== 0) {
235
+ store<u64>(bs.offset, 32370099070435362, 0);
236
+ store<u32>(bs.offset, 3801122, 8);
237
+ bs.offset += 12;
238
+ JSON.__serialize<Vec3 | null>(load<Vec3 | null>(ptr, offsetof<this>("pos")));
239
+ store<u16>(bs.offset, 44, 0);
240
+ bs.offset += 2;
241
+ }
242
+ store<u64>(bs.offset, 32088598323265570, 0);
243
+ store<u64>(bs.offset, 30962384884727923, 8);
244
+ store<u64>(bs.offset, 9570583007002721, 16);
245
+ store<u16>(bs.offset, 58, 24);
246
+ bs.offset += 26;
247
+ JSON.__serialize<string | null>(load<string | null>(ptr, offsetof<this>("firstName")));
248
+ store<u64>(bs.offset, 27303536599629868, 0);
249
+ store<u64>(bs.offset, 27303407755985011, 8);
250
+ store<u64>(bs.offset, 16325694684725357, 16);
251
+ bs.offset += 24;
252
+ JSON.__serialize<string>(load<string>(ptr, offsetof<this>("lastName")));
253
+ store<u64>(bs.offset, 27303536599629868, 0);
254
+ store<u64>(bs.offset, 27866301874831475, 8);
255
+ store<u64>(bs.offset, 28429479460798580, 16);
256
+ store<u32>(bs.offset, 3801122, 24);
257
+ bs.offset += 28;
258
+ JSON.__serialize<Array<i32>>(load<Array<i32>>(ptr, offsetof<this>("lastActive")));
259
+ store<u64>(bs.offset, 32370073295519788, 0);
260
+ store<u64>(bs.offset, 29555362187509846, 8);
261
+ store<u64>(bs.offset, 28147931469643878, 16);
262
+ store<u32>(bs.offset, 3801122, 24);
263
+ bs.offset += 28;
264
+ JSON.__serialize<boolean>(load<boolean>(ptr, offsetof<this>("isVerified")));
238
265
  store<u16>(bs.offset, 125, 0);
239
266
  bs.offset += 2;
240
267
  }
241
268
 
242
-
243
269
  @inline
244
270
  __INITIALIZE(): this {
245
- this.people = [];
271
+ store<string>(changetype<usize>(this), "", offsetof<this>("lastName"));
272
+ store<Array<i32>>(changetype<usize>(this), [], offsetof<this>("lastActive"));
246
273
  return this;
247
274
  }
248
275
  __DESERIALIZE<__JSON_T>(srcStart: usize, srcEnd: usize, out: __JSON_T): __JSON_T {
@@ -281,174 +308,28 @@ class PeopleData {
281
308
  while (srcStart < srcEnd) {
282
309
  const code = load<u16>(srcStart);
283
310
  if (code == 34 && load<u16>(srcStart - 2) !== 92) {
284
- srcStart += 4;
285
- keyStart = 0;
286
- break;
287
- }
288
- srcStart += 2;
289
- }
290
- } else if (code - 48 <= 9 || code == 45) {
291
- lastIndex = srcStart;
292
- srcStart += 2;
293
- while (srcStart < srcEnd) {
294
- const code = load<u16>(srcStart);
295
- if (code == 44 || code == 125 || JSON.Util.isSpace(code)) {
296
- srcStart += 2;
297
- keyStart = 0;
298
- break;
299
- }
300
- srcStart += 2;
301
- }
302
- } else if (code == 123) {
303
- lastIndex = srcStart;
304
- depth++;
305
- srcStart += 2;
306
- while (srcStart < srcEnd) {
307
- const code = load<u16>(srcStart);
308
- if (code == 34) {
309
- srcStart += 2;
310
- while (!(load<u16>(srcStart) == 34 && load<u16>(srcStart - 2) != 92)) srcStart += 2;
311
- } else if (code == 125) {
312
- if (--depth == 0) {
313
- srcStart += 2;
314
- keyStart = 0;
315
- break;
316
- }
317
- } else if (code == 123) depth++;
318
- srcStart += 2;
319
- }
320
- } else if (code == 91) {
321
- lastIndex = srcStart;
322
- depth++;
323
- srcStart += 2;
324
- while (srcStart < srcEnd) {
325
- const code = load<u16>(srcStart);
326
- if (code == 34) {
327
- srcStart += 2;
328
- while (!(load<u16>(srcStart) == 34 && load<u16>(srcStart - 2) != 92)) srcStart += 2;
329
- } else if (code == 93) {
330
- if (--depth == 0) {
331
- srcStart += 2;
332
- switch (<u32>keyEnd - <u32>keyStart) {
333
- case 12: {
334
- const codeS8 = load<u64>(keyStart, 0);
335
- const codeS12 = load<u32>(keyStart, 8);
336
- if (codeS8 == 31525674139582576 && codeS12 == 6619244) {
337
- store<Array<Person>>(changetype<usize>(out), JSON.__deserialize<Array<Person>>(lastIndex, srcStart), offsetof<this>("people"));
338
- keyStart = 0;
339
- break;
340
- } else {
341
- keyStart = 0;
342
- break;
343
- }
344
- }
345
-
346
- default: {
311
+ switch (<u32>keyEnd - <u32>keyStart) {
312
+ case 20: {
313
+ const codeS8 = load<u64>(keyStart, 0);
314
+ const codeS16 = load<u64>(keyStart, 8);
315
+ const codeS20 = load<u32>(keyStart, 16);
316
+ if (codeS8 == 32370111954878566 && codeS16 == 27303545189433460 && codeS20 == 6619245) {
317
+ store<string | null>(changetype<usize>(out), JSON.__deserialize<string | null>(lastIndex, srcStart + 2), offsetof<this>("firstName"));
318
+ srcStart += 4;
319
+ keyStart = 0;
320
+ break;
321
+ } else {
322
+ srcStart += 4;
347
323
  keyStart = 0;
348
324
  break;
349
325
  }
350
326
  }
351
- break;
352
- }
353
- } else if (code == 91) depth++;
354
- srcStart += 2;
355
- }
356
- } else if (code == 116) {
357
- if (load<u64>(srcStart) == 28429475166421108) {
358
- srcStart += 8;
359
- srcStart += 2;
360
- keyStart = 0;
361
- } else {
362
- throw new Error("Expected to find 'true' but found '" + JSON.Util.ptrToStr(lastIndex, srcStart) + "' instead at position " + (srcEnd - srcStart).toString());
363
- }
364
- } else if (code == 102) {
365
- if (load<u64>(srcStart, 2) == 28429466576093281) {
366
- srcStart += 10;
367
- srcStart += 2;
368
- keyStart = 0;
369
- } else {
370
- throw new Error("Expected to find 'false' but found '" + JSON.Util.ptrToStr(lastIndex, srcStart) + "' instead at position " + (srcEnd - srcStart).toString());
371
- }
372
- } else if (code == 110) {
373
- if (load<u64>(srcStart) == 30399761348886638) {
374
- srcStart += 8;
375
- srcStart += 2;
376
- keyStart = 0;
377
- }
378
- } else {
379
- srcStart += 2;
380
- keyStart = 0;
381
- }
382
- }
383
- }
384
- return out;
385
- }
386
- }
387
-
388
327
 
389
- @json
390
- export class Response<T> {
391
- data: T | null = null;
392
- __SERIALIZE(ptr: usize): void {
393
- bs.proposeSize(18);
394
- store<u64>(bs.offset, 27303502239891579, 0);
395
- store<u64>(bs.offset, 16325694684463220, 8);
396
- bs.offset += 16;
397
- JSON.__serialize<T | null>(load<T | null>(ptr, offsetof<this>("data")));
398
- store<u16>(bs.offset, 125, 0);
399
- bs.offset += 2;
400
- }
401
-
402
-
403
- @inline
404
- __INITIALIZE(): this {
405
- if (isManaged<nonnull<T | null>>() || isReference<nonnull<T | null>>()) {
406
- this.data = changetype<nonnull<T | null>>(__new(offsetof<nonnull<T | null>>(), idof<nonnull<T | null>>()));
407
- if (isDefined(this.data.__INITIALIZE)) changetype<nonnull<T | null>>(this.data).__INITIALIZE();
408
- }
409
- return this;
410
- }
411
- __DESERIALIZE<__JSON_T>(srcStart: usize, srcEnd: usize, out: __JSON_T): __JSON_T {
412
- let keyStart: usize = 0;
413
- let keyEnd: usize = 0;
414
- let isKey = false;
415
- let depth: i32 = 0;
416
- let lastIndex: usize = 0;
417
- while (srcStart < srcEnd && JSON.Util.isSpace(load<u16>(srcStart))) srcStart += 2;
418
- while (srcEnd > srcStart && JSON.Util.isSpace(load<u16>(srcEnd - 2))) srcEnd -= 2;
419
- if (srcStart - srcEnd == 0) throw new Error("Input string had zero length or was all whitespace");
420
- if (load<u16>(srcStart) != 123) throw new Error("Expected '{' at start of object at position " + (srcEnd - srcStart).toString());
421
- if (load<u16>(srcEnd - 2) != 125) throw new Error("Expected '}' at end of object at position " + (srcEnd - srcStart).toString());
422
- srcStart += 2;
423
- while (srcStart < srcEnd) {
424
- let code = load<u16>(srcStart);
425
- while (JSON.Util.isSpace(code)) code = load<u16>((srcStart += 2));
426
- if (keyStart == 0) {
427
- if (code == 34 && load<u16>(srcStart - 2) !== 92) {
428
- if (isKey) {
429
- keyStart = lastIndex;
430
- keyEnd = srcStart;
431
- while (JSON.Util.isSpace((code = load<u16>((srcStart += 2))))) {}
432
- if (code !== 58) throw new Error("Expected ':' after key at position " + (srcEnd - srcStart).toString());
433
- isKey = false;
434
- } else {
435
- isKey = true;
436
- lastIndex = srcStart + 2;
437
- }
438
- }
439
- srcStart += 2;
440
- } else {
441
- if (code == 34) {
442
- lastIndex = srcStart;
443
- srcStart += 2;
444
- while (srcStart < srcEnd) {
445
- const code = load<u16>(srcStart);
446
- if (code == 34 && load<u16>(srcStart - 2) !== 92) {
447
- switch (<u32>keyEnd - <u32>keyStart) {
448
- case 8: {
449
- const code64 = load<u64>(keyStart);
450
- if (isString<T | null>() && code64 == 27303570963497060) {
451
- store<T | null>(changetype<usize>(out), JSON.__deserialize<T | null>(lastIndex, srcStart + 2), offsetof<this>("data"));
328
+ case 16: {
329
+ const codeS8 = load<u64>(keyStart, 0);
330
+ const codeS16 = load<u64>(keyStart, 8);
331
+ if (codeS8 == 32651591226032236 && codeS16 == 28429440805568590) {
332
+ store<string>(changetype<usize>(out), JSON.__deserialize<string>(lastIndex, srcStart + 2), offsetof<this>("lastName"));
452
333
  srcStart += 4;
453
334
  keyStart = 0;
454
335
  break;
@@ -476,10 +357,10 @@ export class Response<T> {
476
357
  const code = load<u16>(srcStart);
477
358
  if (code == 44 || code == 125 || JSON.Util.isSpace(code)) {
478
359
  switch (<u32>keyEnd - <u32>keyStart) {
479
- case 8: {
480
- const code64 = load<u64>(keyStart);
481
- if ((isInteger<T | null>() || isFloat<T | null>()) && code64 == 27303570963497060) {
482
- store<T | null>(changetype<usize>(out), JSON.__deserialize<T | null>(lastIndex, srcStart), offsetof<this>("data"));
360
+ case 6: {
361
+ const code48 = load<u64>(keyStart) & 281474976710655;
362
+ if (code48 == 433798447201) {
363
+ store<i32>(changetype<usize>(out), JSON.__deserialize<i32>(lastIndex, srcStart), offsetof<this>("age"));
483
364
  srcStart += 2;
484
365
  keyStart = 0;
485
366
  break;
@@ -513,10 +394,49 @@ export class Response<T> {
513
394
  if (--depth == 0) {
514
395
  srcStart += 2;
515
396
  switch (<u32>keyEnd - <u32>keyStart) {
516
- case 8: {
517
- const code64 = load<u64>(keyStart);
518
- if (isDefined(out.__DESERIALIZE) && code64 == 27303570963497060) {
519
- store<T | null>(changetype<usize>(out), JSON.__deserialize<T | null>(lastIndex, srcStart), offsetof<this>("data"));
397
+ case 20: {
398
+ const codeS8 = load<u64>(keyStart, 0);
399
+ const codeS16 = load<u64>(keyStart, 8);
400
+ const codeS20 = load<u32>(keyStart, 16);
401
+ if (codeS8 == 32370111954878566 && codeS16 == 27303545189433460 && codeS20 == 6619245) {
402
+ store<string | null>(changetype<usize>(out), JSON.__deserialize<string | null>(lastIndex, srcStart), offsetof<this>("firstName"));
403
+ keyStart = 0;
404
+ break;
405
+ } else if (codeS8 == 32651591226032236 && codeS16 == 29555370777313345 && codeS20 == 6619254) {
406
+ store<Array<i32>>(changetype<usize>(out), JSON.__deserialize<Array<i32>>(lastIndex, srcStart), offsetof<this>("lastActive"));
407
+ keyStart = 0;
408
+ break;
409
+ } else if (codeS8 == 28429342022500457 && codeS16 == 29555310648164466 && codeS20 == 6553701) {
410
+ store<boolean>(changetype<usize>(out), JSON.__deserialize<boolean>(lastIndex, srcStart), offsetof<this>("isVerified"));
411
+ keyStart = 0;
412
+ break;
413
+ } else {
414
+ keyStart = 0;
415
+ break;
416
+ }
417
+ }
418
+
419
+ case 6: {
420
+ const code48 = load<u64>(keyStart) & 281474976710655;
421
+ if (code48 == 433798447201) {
422
+ store<i32>(changetype<usize>(out), JSON.__deserialize<i32>(lastIndex, srcStart), offsetof<this>("age"));
423
+ keyStart = 0;
424
+ break;
425
+ } else if (code48 == 493928513648) {
426
+ store<Vec3 | null>(changetype<usize>(out), JSON.__deserialize<Vec3 | null>(lastIndex, srcStart), offsetof<this>("pos"));
427
+ keyStart = 0;
428
+ break;
429
+ } else {
430
+ keyStart = 0;
431
+ break;
432
+ }
433
+ }
434
+
435
+ case 16: {
436
+ const codeS8 = load<u64>(keyStart, 0);
437
+ const codeS16 = load<u64>(keyStart, 8);
438
+ if (codeS8 == 32651591226032236 && codeS16 == 28429440805568590) {
439
+ store<string>(changetype<usize>(out), JSON.__deserialize<string>(lastIndex, srcStart), offsetof<this>("lastName"));
520
440
  keyStart = 0;
521
441
  break;
522
442
  } else {
@@ -548,10 +468,12 @@ export class Response<T> {
548
468
  if (--depth == 0) {
549
469
  srcStart += 2;
550
470
  switch (<u32>keyEnd - <u32>keyStart) {
551
- case 8: {
552
- const code64 = load<u64>(keyStart);
553
- if (isArray<T | null>() && code64 == 27303570963497060) {
554
- store<T | null>(changetype<usize>(out), JSON.__deserialize<T | null>(lastIndex, srcStart), offsetof<this>("data"));
471
+ case 20: {
472
+ const codeS8 = load<u64>(keyStart, 0);
473
+ const codeS16 = load<u64>(keyStart, 8);
474
+ const codeS20 = load<u32>(keyStart, 16);
475
+ if (codeS8 == 32651591226032236 && codeS16 == 29555370777313345 && codeS20 == 6619254) {
476
+ store<Array<i32>>(changetype<usize>(out), JSON.__deserialize<Array<i32>>(lastIndex, srcStart), offsetof<this>("lastActive"));
555
477
  keyStart = 0;
556
478
  break;
557
479
  } else {
@@ -574,10 +496,12 @@ export class Response<T> {
574
496
  if (load<u64>(srcStart) == 28429475166421108) {
575
497
  srcStart += 8;
576
498
  switch (<u32>keyEnd - <u32>keyStart) {
577
- case 8: {
578
- const code64 = load<u64>(keyStart);
579
- if (isBoolean<T | null>() && code64 == 27303570963497060) {
580
- store<boolean>(changetype<usize>(out), true, offsetof<this>("data"));
499
+ case 20: {
500
+ const codeS8 = load<u64>(keyStart, 0);
501
+ const codeS16 = load<u64>(keyStart, 8);
502
+ const codeS20 = load<u32>(keyStart, 16);
503
+ if (codeS8 == 28429342022500457 && codeS16 == 29555310648164466 && codeS20 == 6553701) {
504
+ store<boolean>(changetype<usize>(out), true, offsetof<this>("isVerified"));
581
505
  srcStart += 2;
582
506
  keyStart = 0;
583
507
  break;
@@ -600,10 +524,12 @@ export class Response<T> {
600
524
  if (load<u64>(srcStart, 2) == 28429466576093281) {
601
525
  srcStart += 10;
602
526
  switch (<u32>keyEnd - <u32>keyStart) {
603
- case 8: {
604
- const code64 = load<u64>(keyStart);
605
- if (isBoolean<T | null>() && code64 == 27303570963497060) {
606
- store<boolean>(changetype<usize>(out), false, offsetof<this>("data"));
527
+ case 20: {
528
+ const codeS8 = load<u64>(keyStart, 0);
529
+ const codeS16 = load<u64>(keyStart, 8);
530
+ const codeS20 = load<u32>(keyStart, 16);
531
+ if (codeS8 == 28429342022500457 && codeS16 == 29555310648164466 && codeS20 == 6553701) {
532
+ store<boolean>(changetype<usize>(out), false, offsetof<this>("isVerified"));
607
533
  srcStart += 2;
608
534
  keyStart = 0;
609
535
  break;
@@ -626,10 +552,26 @@ export class Response<T> {
626
552
  if (load<u64>(srcStart) == 30399761348886638) {
627
553
  srcStart += 8;
628
554
  switch (<u32>keyEnd - <u32>keyStart) {
629
- case 8: {
630
- const code64 = load<u64>(keyStart);
631
- if (isNullable<T | null>() && code64 == 27303570963497060) {
632
- store<usize>(changetype<usize>(out), 0, offsetof<this>("data"));
555
+ case 6: {
556
+ const code48 = load<u64>(keyStart) & 281474976710655;
557
+ if (code48 == 493928513648) {
558
+ store<usize>(changetype<usize>(out), 0, offsetof<this>("pos"));
559
+ srcStart += 2;
560
+ keyStart = 0;
561
+ break;
562
+ } else {
563
+ srcStart += 2;
564
+ keyStart = 0;
565
+ break;
566
+ }
567
+ }
568
+
569
+ case 20: {
570
+ const codeS8 = load<u64>(keyStart, 0);
571
+ const codeS16 = load<u64>(keyStart, 8);
572
+ const codeS20 = load<u32>(keyStart, 16);
573
+ if (codeS8 == 32370111954878566 && codeS16 == 27303545189433460 && codeS20 == 6619245) {
574
+ store<usize>(changetype<usize>(out), 0, offsetof<this>("firstName"));
633
575
  srcStart += 2;
634
576
  keyStart = 0;
635
577
  break;
@@ -655,6 +597,18 @@ export class Response<T> {
655
597
  return out;
656
598
  }
657
599
  }
658
- console.log((isManaged<PeopleData>() || isReference<PeopleData>()).toString());
659
- let deserialized = JSON.parse<Response<PeopleData>>('{"data":{"people":[]}}');
660
- console.log("Deserialized Node: " + JSON.stringify(deserialized));
600
+ const player: Player = {
601
+ lastName: "Tanaka",
602
+ lastActive: [3, 9, 2025],
603
+ age: 18,
604
+ pos: {
605
+ x: 3.4,
606
+ y: 1.2,
607
+ z: 8.3,
608
+ },
609
+ isVerified: true,
610
+ };
611
+ const serialized = JSON.stringify<Player>(player);
612
+ const deserialized = JSON.parse<Player>(serialized);
613
+ console.log("Serialized " + serialized);
614
+ console.log("Deserialized " + JSON.stringify(deserialized));