@rootintf/protocol-subverseinfo 2.0.3-api.4 → 2.1.3-api.6

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 (7) hide show
  1. package/dist/subverseinfo.cjs.js +785 -202
  2. package/dist/subverseinfo.es.mjs +785 -202
  3. package/package.json +2 -2
  4. package/schema/schema_SubverseInfo.json +43 -9
  5. package/src/subverseinfo.ts +1 -4
  6. package/src/validate-esm.mjs +1 -1
  7. package/tests/subverseinfo.spec.mjs +50 -20
package/dist/subverseinfo.cjs.js CHANGED
@@ -87,8 +87,8 @@ function validate19(data, { instancePath = "", parentData, parentDataProperty, r
87
87
  if (valid0) {
88
88
  if (data.subverse_info !== undefined) {
89
89
  const _errs9 = errors;
90
- if ("4" !== data.subverse_info) {
91
- validate19.errors = [{ instancePath: instancePath + "/subverse_info", schemaPath: "definitions#/definitions/_v/const", keyword: "const", params: { allowedValue: "4" }, message: "must be equal to constant" }];
90
+ if ("6" !== data.subverse_info) {
91
+ validate19.errors = [{ instancePath: instancePath + "/subverse_info", schemaPath: "definitions#/definitions/_v/const", keyword: "const", params: { allowedValue: "6" }, message: "must be equal to constant" }];
92
92
  return false;
93
93
  }
94
94
  var valid0 = _errs9 === errors;
@@ -110,7 +110,7 @@ function validate21(data, { instancePath = "", parentData, parentDataProperty, r
110
110
  evaluated0.props = undefined;
111
111
  } if (evaluated0.dynamicItems) {
112
112
  evaluated0.items = undefined;
113
- } {
113
+ } const _errs2 = errors; if (errors === _errs2) {
114
114
  if (data && typeof data == "object" && !Array.isArray(data)) {
115
115
  let missing0;
116
116
  if (((data.uri === undefined) && (missing0 = "uri")) || ((data.name === undefined) && (missing0 = "name"))) {
@@ -148,7 +148,7 @@ function validate21(data, { instancePath = "", parentData, parentDataProperty, r
148
148
  validate21.errors = [{ instancePath, schemaPath: "definitions#/definitions/unique-id/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
149
149
  return false;
150
150
  }
151
- } {
151
+ } if (errors === 0) {
152
152
  if (data && typeof data == "object" && !Array.isArray(data)) {
153
153
  if (data.favicon !== undefined) {
154
154
  const _errs8 = errors;
@@ -165,45 +165,105 @@ function validate21(data, { instancePath = "", parentData, parentDataProperty, r
165
165
  if (data.hyperport !== undefined) {
166
166
  let data3 = data.hyperport;
167
167
  const _errs10 = errors;
168
- {
168
+ const _errs12 = errors;
169
+ let valid5 = false;
170
+ let passing0 = null;
171
+ const _errs13 = errors;
172
+ if (typeof data3 !== "string") {
173
+ const err0 = { instancePath: instancePath + "/hyperport", schemaPath: "definitions#/definitions/hyperport/oneOf/0/type", keyword: "type", params: { type: "string" }, message: "must be string" };
174
+ if (vErrors === null) {
175
+ vErrors = [err0];
176
+ }
177
+ else {
178
+ vErrors.push(err0);
179
+ }
180
+ errors++;
181
+ }
182
+ var _valid0 = _errs13 === errors;
183
+ if (_valid0) {
184
+ valid5 = true;
185
+ passing0 = 0;
186
+ }
187
+ const _errs15 = errors;
188
+ if (errors === _errs15) {
169
189
  if (data3 && typeof data3 == "object" && !Array.isArray(data3)) {
170
190
  let missing1;
171
191
  if (((data3.uri === undefined) && (missing1 = "uri")) || ((data3.port === undefined) && (missing1 = "port"))) {
172
- validate21.errors = [{ instancePath: instancePath + "/hyperport", schemaPath: "definitions#/definitions/hyperport/required", keyword: "required", params: { missingProperty: missing1 }, message: "must have required property '" + missing1 + "'" }];
173
- return false;
192
+ const err1 = { instancePath: instancePath + "/hyperport", schemaPath: "definitions#/definitions/hyperport/oneOf/1/required", keyword: "required", params: { missingProperty: missing1 }, message: "must have required property '" + missing1 + "'" };
193
+ if (vErrors === null) {
194
+ vErrors = [err1];
195
+ }
196
+ else {
197
+ vErrors.push(err1);
198
+ }
199
+ errors++;
174
200
  }
175
201
  else {
176
202
  if (data3.uri !== undefined) {
177
203
  if (typeof data3.uri !== "string") {
178
- validate21.errors = [{ instancePath: instancePath + "/hyperport/uri", schemaPath: "definitions#/definitions/hyperport/properties/uri/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
179
- return false;
204
+ const err2 = { instancePath: instancePath + "/hyperport/uri", schemaPath: "definitions#/definitions/hyperport/oneOf/1/properties/uri/type", keyword: "type", params: { type: "string" }, message: "must be string" };
205
+ if (vErrors === null) {
206
+ vErrors = [err2];
207
+ }
208
+ else {
209
+ vErrors.push(err2);
210
+ }
211
+ errors++;
180
212
  }
181
213
  }
182
214
  }
183
215
  }
184
216
  else {
185
- validate21.errors = [{ instancePath: instancePath + "/hyperport", schemaPath: "definitions#/definitions/hyperport/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
186
- return false;
217
+ const err3 = { instancePath: instancePath + "/hyperport", schemaPath: "definitions#/definitions/hyperport/oneOf/1/type", keyword: "type", params: { type: "object" }, message: "must be object" };
218
+ if (vErrors === null) {
219
+ vErrors = [err3];
220
+ }
221
+ else {
222
+ vErrors.push(err3);
223
+ }
224
+ errors++;
187
225
  }
188
226
  }
189
- var valid3 = _errs10 === errors;
190
- }
191
- else {
192
- var valid3 = true;
193
- }
194
- if (valid3) {
195
- if (data.info !== undefined) {
196
- let data5 = data.info;
197
- const _errs15 = errors;
198
- if (!(data5 && typeof data5 == "object" && !Array.isArray(data5))) {
199
- validate21.errors = [{ instancePath: instancePath + "/info", schemaPath: "definitions#/definitions/info/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
200
- return false;
227
+ var _valid0 = _errs15 === errors;
228
+ if (_valid0 && valid5) {
229
+ valid5 = false;
230
+ passing0 = [passing0, 1];
231
+ }
232
+ else {
233
+ if (_valid0) {
234
+ valid5 = true;
235
+ passing0 = 1;
236
+ var props0 = {};
237
+ props0.uri = true;
201
238
  }
202
- var valid3 = _errs15 === errors;
239
+ }
240
+ if (!valid5) {
241
+ const err4 = { instancePath: instancePath + "/hyperport", schemaPath: "definitions#/definitions/hyperport/oneOf", keyword: "oneOf", params: { passingSchemas: passing0 }, message: "must match exactly one schema in oneOf" };
242
+ if (vErrors === null) {
243
+ vErrors = [err4];
244
+ }
245
+ else {
246
+ vErrors.push(err4);
247
+ }
248
+ errors++;
249
+ validate21.errors = vErrors;
250
+ return false;
203
251
  }
204
252
  else {
205
- var valid3 = true;
253
+ errors = _errs12;
254
+ if (vErrors !== null) {
255
+ if (_errs12) {
256
+ vErrors.length = _errs12;
257
+ }
258
+ else {
259
+ vErrors = null;
260
+ }
261
+ }
206
262
  }
263
+ var valid3 = _errs10 === errors;
264
+ }
265
+ else {
266
+ var valid3 = true;
207
267
  }
208
268
  }
209
269
  }
@@ -212,12 +272,12 @@ function validate21(data, { instancePath = "", parentData, parentDataProperty, r
212
272
  return false;
213
273
  }
214
274
  } validate21.errors = vErrors; return errors === 0; }
215
- validate21.evaluated = { "props": { "favicon": true, "hyperport": true, "info": true, "uri": true, "name": true }, "dynamicProps": false, "dynamicItems": false };
275
+ validate21.evaluated = { "props": { "favicon": true, "hyperport": true, "uri": true, "name": true }, "dynamicProps": false, "dynamicItems": false };
216
276
  function validate24(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) { let vErrors = null; let errors = 0; const evaluated0 = validate24.evaluated; if (evaluated0.dynamicProps) {
217
277
  evaluated0.props = undefined;
218
278
  } if (evaluated0.dynamicItems) {
219
279
  evaluated0.items = undefined;
220
- } {
280
+ } const _errs2 = errors; if (errors === _errs2) {
221
281
  if (data && typeof data == "object" && !Array.isArray(data)) {
222
282
  let missing0;
223
283
  if (((data.uri === undefined) && (missing0 = "uri")) || ((data.name === undefined) && (missing0 = "name"))) {
@@ -255,7 +315,7 @@ function validate24(data, { instancePath = "", parentData, parentDataProperty, r
255
315
  validate24.errors = [{ instancePath, schemaPath: "definitions#/definitions/unique-id/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
256
316
  return false;
257
317
  }
258
- } {
318
+ } if (errors === 0) {
259
319
  if (data && typeof data == "object" && !Array.isArray(data)) {
260
320
  if (data.favicon !== undefined) {
261
321
  const _errs8 = errors;
@@ -272,45 +332,105 @@ function validate24(data, { instancePath = "", parentData, parentDataProperty, r
272
332
  if (data.hyperport !== undefined) {
273
333
  let data3 = data.hyperport;
274
334
  const _errs10 = errors;
275
- {
335
+ const _errs12 = errors;
336
+ let valid5 = false;
337
+ let passing0 = null;
338
+ const _errs13 = errors;
339
+ if (typeof data3 !== "string") {
340
+ const err0 = { instancePath: instancePath + "/hyperport", schemaPath: "definitions#/definitions/hyperport/oneOf/0/type", keyword: "type", params: { type: "string" }, message: "must be string" };
341
+ if (vErrors === null) {
342
+ vErrors = [err0];
343
+ }
344
+ else {
345
+ vErrors.push(err0);
346
+ }
347
+ errors++;
348
+ }
349
+ var _valid0 = _errs13 === errors;
350
+ if (_valid0) {
351
+ valid5 = true;
352
+ passing0 = 0;
353
+ }
354
+ const _errs15 = errors;
355
+ if (errors === _errs15) {
276
356
  if (data3 && typeof data3 == "object" && !Array.isArray(data3)) {
277
357
  let missing1;
278
358
  if (((data3.uri === undefined) && (missing1 = "uri")) || ((data3.port === undefined) && (missing1 = "port"))) {
279
- validate24.errors = [{ instancePath: instancePath + "/hyperport", schemaPath: "definitions#/definitions/hyperport/required", keyword: "required", params: { missingProperty: missing1 }, message: "must have required property '" + missing1 + "'" }];
280
- return false;
359
+ const err1 = { instancePath: instancePath + "/hyperport", schemaPath: "definitions#/definitions/hyperport/oneOf/1/required", keyword: "required", params: { missingProperty: missing1 }, message: "must have required property '" + missing1 + "'" };
360
+ if (vErrors === null) {
361
+ vErrors = [err1];
362
+ }
363
+ else {
364
+ vErrors.push(err1);
365
+ }
366
+ errors++;
281
367
  }
282
368
  else {
283
369
  if (data3.uri !== undefined) {
284
370
  if (typeof data3.uri !== "string") {
285
- validate24.errors = [{ instancePath: instancePath + "/hyperport/uri", schemaPath: "definitions#/definitions/hyperport/properties/uri/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
286
- return false;
371
+ const err2 = { instancePath: instancePath + "/hyperport/uri", schemaPath: "definitions#/definitions/hyperport/oneOf/1/properties/uri/type", keyword: "type", params: { type: "string" }, message: "must be string" };
372
+ if (vErrors === null) {
373
+ vErrors = [err2];
374
+ }
375
+ else {
376
+ vErrors.push(err2);
377
+ }
378
+ errors++;
287
379
  }
288
380
  }
289
381
  }
290
382
  }
291
383
  else {
292
- validate24.errors = [{ instancePath: instancePath + "/hyperport", schemaPath: "definitions#/definitions/hyperport/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
293
- return false;
384
+ const err3 = { instancePath: instancePath + "/hyperport", schemaPath: "definitions#/definitions/hyperport/oneOf/1/type", keyword: "type", params: { type: "object" }, message: "must be object" };
385
+ if (vErrors === null) {
386
+ vErrors = [err3];
387
+ }
388
+ else {
389
+ vErrors.push(err3);
390
+ }
391
+ errors++;
294
392
  }
295
393
  }
296
- var valid3 = _errs10 === errors;
297
- }
298
- else {
299
- var valid3 = true;
300
- }
301
- if (valid3) {
302
- if (data.info !== undefined) {
303
- let data5 = data.info;
304
- const _errs15 = errors;
305
- if (!(data5 && typeof data5 == "object" && !Array.isArray(data5))) {
306
- validate24.errors = [{ instancePath: instancePath + "/info", schemaPath: "definitions#/definitions/info/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
307
- return false;
394
+ var _valid0 = _errs15 === errors;
395
+ if (_valid0 && valid5) {
396
+ valid5 = false;
397
+ passing0 = [passing0, 1];
398
+ }
399
+ else {
400
+ if (_valid0) {
401
+ valid5 = true;
402
+ passing0 = 1;
403
+ var props0 = {};
404
+ props0.uri = true;
308
405
  }
309
- var valid3 = _errs15 === errors;
406
+ }
407
+ if (!valid5) {
408
+ const err4 = { instancePath: instancePath + "/hyperport", schemaPath: "definitions#/definitions/hyperport/oneOf", keyword: "oneOf", params: { passingSchemas: passing0 }, message: "must match exactly one schema in oneOf" };
409
+ if (vErrors === null) {
410
+ vErrors = [err4];
411
+ }
412
+ else {
413
+ vErrors.push(err4);
414
+ }
415
+ errors++;
416
+ validate24.errors = vErrors;
417
+ return false;
310
418
  }
311
419
  else {
312
- var valid3 = true;
420
+ errors = _errs12;
421
+ if (vErrors !== null) {
422
+ if (_errs12) {
423
+ vErrors.length = _errs12;
424
+ }
425
+ else {
426
+ vErrors = null;
427
+ }
428
+ }
313
429
  }
430
+ var valid3 = _errs10 === errors;
431
+ }
432
+ else {
433
+ var valid3 = true;
314
434
  }
315
435
  }
316
436
  }
@@ -319,7 +439,7 @@ function validate24(data, { instancePath = "", parentData, parentDataProperty, r
319
439
  return false;
320
440
  }
321
441
  } validate24.errors = vErrors; return errors === 0; }
322
- validate24.evaluated = { "props": { "favicon": true, "hyperport": true, "info": true, "uri": true, "name": true }, "dynamicProps": false, "dynamicItems": false };
442
+ validate24.evaluated = { "props": { "favicon": true, "hyperport": true, "uri": true, "name": true }, "dynamicProps": false, "dynamicItems": false };
323
443
  function validate23(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) { let vErrors = null; let errors = 0; const evaluated0 = validate23.evaluated; if (evaluated0.dynamicProps) {
324
444
  evaluated0.props = undefined;
325
445
  } if (evaluated0.dynamicItems) {
@@ -337,10 +457,165 @@ function validate23(data, { instancePath = "", parentData, parentDataProperty, r
337
457
  }
338
458
  if (errors === _errs1) {
339
459
  if (data0 && typeof data0 == "object" && !Array.isArray(data0)) {
340
- for (const key0 in data0) {
341
- if (((((key0 !== "favicon") && (key0 !== "hyperport")) && (key0 !== "info")) && (key0 !== "uri")) && (key0 !== "name")) {
342
- validate23.errors = [{ instancePath: instancePath + "/" + i0, schemaPath: "#/items/unevaluatedProperties", keyword: "unevaluatedProperties", params: { unevaluatedProperty: key0 }, message: "must NOT have unevaluated properties" }];
343
- return false;
460
+ if (data0.info !== undefined) {
461
+ let data1 = data0.info;
462
+ const _errs4 = errors;
463
+ const _errs5 = errors;
464
+ if (errors === _errs5) {
465
+ if (data1 && typeof data1 == "object" && !Array.isArray(data1)) {
466
+ if (data1["age-restrictions"] !== undefined) {
467
+ let data2 = data1["age-restrictions"];
468
+ const _errs7 = errors;
469
+ if (errors === _errs7) {
470
+ if (!(data2 && typeof data2 == "object" && !Array.isArray(data2))) {
471
+ validate23.errors = [{ instancePath: instancePath + "/" + i0 + "/info/age-restrictions", schemaPath: "definitions#/definitions/info/properties/age-restrictions/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
472
+ return false;
473
+ }
474
+ }
475
+ var valid4 = _errs7 === errors;
476
+ }
477
+ else {
478
+ var valid4 = true;
479
+ }
480
+ if (valid4) {
481
+ if (data1["users-count"] !== undefined) {
482
+ let data3 = data1["users-count"];
483
+ const _errs9 = errors;
484
+ if (errors === _errs9) {
485
+ if (data3 && typeof data3 == "object" && !Array.isArray(data3)) {
486
+ if (data3.active !== undefined) {
487
+ let data4 = data3.active;
488
+ const _errs11 = errors;
489
+ if (!(((typeof data4 == "number") && (!(data4 % 1) && !isNaN(data4))) && (isFinite(data4)))) {
490
+ validate23.errors = [{ instancePath: instancePath + "/" + i0 + "/info/users-count/active", schemaPath: "definitions#/definitions/info/properties/users-count/properties/active/type", keyword: "type", params: { type: "integer" }, message: "must be integer" }];
491
+ return false;
492
+ }
493
+ var valid5 = _errs11 === errors;
494
+ }
495
+ else {
496
+ var valid5 = true;
497
+ }
498
+ if (valid5) {
499
+ if (data3.DAU !== undefined) {
500
+ let data5 = data3.DAU;
501
+ const _errs13 = errors;
502
+ if (!(((typeof data5 == "number") && (!(data5 % 1) && !isNaN(data5))) && (isFinite(data5)))) {
503
+ validate23.errors = [{ instancePath: instancePath + "/" + i0 + "/info/users-count/DAU", schemaPath: "definitions#/definitions/info/properties/users-count/properties/DAU/type", keyword: "type", params: { type: "integer" }, message: "must be integer" }];
504
+ return false;
505
+ }
506
+ var valid5 = _errs13 === errors;
507
+ }
508
+ else {
509
+ var valid5 = true;
510
+ }
511
+ if (valid5) {
512
+ if (data3.MAU !== undefined) {
513
+ let data6 = data3.MAU;
514
+ const _errs15 = errors;
515
+ if (!(((typeof data6 == "number") && (!(data6 % 1) && !isNaN(data6))) && (isFinite(data6)))) {
516
+ validate23.errors = [{ instancePath: instancePath + "/" + i0 + "/info/users-count/MAU", schemaPath: "definitions#/definitions/info/properties/users-count/properties/MAU/type", keyword: "type", params: { type: "integer" }, message: "must be integer" }];
517
+ return false;
518
+ }
519
+ var valid5 = _errs15 === errors;
520
+ }
521
+ else {
522
+ var valid5 = true;
523
+ }
524
+ if (valid5) {
525
+ if (data3["concurrent-max"] !== undefined) {
526
+ let data7 = data3["concurrent-max"];
527
+ const _errs17 = errors;
528
+ if (!(((typeof data7 == "number") && (!(data7 % 1) && !isNaN(data7))) && (isFinite(data7)))) {
529
+ validate23.errors = [{ instancePath: instancePath + "/" + i0 + "/info/users-count/concurrent-max", schemaPath: "definitions#/definitions/info/properties/users-count/properties/concurrent-max/type", keyword: "type", params: { type: "integer" }, message: "must be integer" }];
530
+ return false;
531
+ }
532
+ var valid5 = _errs17 === errors;
533
+ }
534
+ else {
535
+ var valid5 = true;
536
+ }
537
+ }
538
+ }
539
+ }
540
+ }
541
+ else {
542
+ validate23.errors = [{ instancePath: instancePath + "/" + i0 + "/info/users-count", schemaPath: "definitions#/definitions/info/properties/users-count/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
543
+ return false;
544
+ }
545
+ }
546
+ var valid4 = _errs9 === errors;
547
+ }
548
+ else {
549
+ var valid4 = true;
550
+ }
551
+ if (valid4) {
552
+ if (data1.attributes !== undefined) {
553
+ let data8 = data1.attributes;
554
+ const _errs19 = errors;
555
+ if (errors === _errs19) {
556
+ if (Array.isArray(data8)) {
557
+ var valid6 = true;
558
+ const len1 = data8.length;
559
+ for (let i1 = 0; i1 < len1; i1++) {
560
+ const _errs21 = errors;
561
+ if (typeof data8[i1] !== "string") {
562
+ validate23.errors = [{ instancePath: instancePath + "/" + i0 + "/info/attributes/" + i1, schemaPath: "definitions#/definitions/info/properties/attributes/items/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
563
+ return false;
564
+ }
565
+ var valid6 = _errs21 === errors;
566
+ if (!valid6) {
567
+ break;
568
+ }
569
+ }
570
+ if (valid6) {
571
+ let i2 = data8.length;
572
+ let j0;
573
+ if (i2 > 1) {
574
+ const indices0 = {};
575
+ for (; i2--;) {
576
+ let item0 = data8[i2];
577
+ if (typeof item0 !== "string") {
578
+ continue;
579
+ }
580
+ if (typeof indices0[item0] == "number") {
581
+ j0 = indices0[item0];
582
+ validate23.errors = [{ instancePath: instancePath + "/" + i0 + "/info/attributes", schemaPath: "definitions#/definitions/info/properties/attributes/uniqueItems", keyword: "uniqueItems", params: { i: i2, j: j0 }, message: "must NOT have duplicate items (items ## " + j0 + " and " + i2 + " are identical)" }];
583
+ return false;
584
+ }
585
+ indices0[item0] = i2;
586
+ }
587
+ }
588
+ }
589
+ }
590
+ else {
591
+ validate23.errors = [{ instancePath: instancePath + "/" + i0 + "/info/attributes", schemaPath: "definitions#/definitions/info/properties/attributes/type", keyword: "type", params: { type: "array" }, message: "must be array" }];
592
+ return false;
593
+ }
594
+ }
595
+ var valid4 = _errs19 === errors;
596
+ }
597
+ else {
598
+ var valid4 = true;
599
+ }
600
+ }
601
+ }
602
+ }
603
+ else {
604
+ validate23.errors = [{ instancePath: instancePath + "/" + i0 + "/info", schemaPath: "definitions#/definitions/info/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
605
+ return false;
606
+ }
607
+ }
608
+ var valid2 = _errs4 === errors;
609
+ }
610
+ else {
611
+ var valid2 = true;
612
+ }
613
+ if (valid2) {
614
+ for (const key0 in data0) {
615
+ if (((((key0 !== "info") && (key0 !== "favicon")) && (key0 !== "hyperport")) && (key0 !== "uri")) && (key0 !== "name")) {
616
+ validate23.errors = [{ instancePath: instancePath + "/" + i0, schemaPath: "#/items/unevaluatedProperties", keyword: "unevaluatedProperties", params: { unevaluatedProperty: key0 }, message: "must NOT have unevaluated properties" }];
617
+ return false;
618
+ }
344
619
  }
345
620
  }
346
621
  }
@@ -448,7 +723,7 @@ function validate20(data, { instancePath = "", parentData, parentDataProperty, r
448
723
  }
449
724
  if (valid4) {
450
725
  for (const key0 in data1) {
451
- if (((((((key0 !== "map-uri") && (key0 !== "instances")) && (key0 !== "favicon")) && (key0 !== "hyperport")) && (key0 !== "info")) && (key0 !== "uri")) && (key0 !== "name")) {
726
+ if ((((((key0 !== "map-uri") && (key0 !== "instances")) && (key0 !== "favicon")) && (key0 !== "hyperport")) && (key0 !== "uri")) && (key0 !== "name")) {
452
727
  validate20.errors = [{ instancePath: instancePath + "/expanse/subverse", schemaPath: "#/properties/expanse/properties/subverse/unevaluatedProperties", keyword: "unevaluatedProperties", params: { unevaluatedProperty: key0 }, message: "must NOT have unevaluated properties" }];
453
728
  return false;
454
729
  }
@@ -467,113 +742,151 @@ function validate20(data, { instancePath = "", parentData, parentDataProperty, r
467
742
  var valid2 = true;
468
743
  }
469
744
  if (valid2) {
470
- if (data0.platforms !== undefined) {
471
- let data4 = data0.platforms;
745
+ if (data0.info !== undefined) {
746
+ let data4 = data0.info;
472
747
  const _errs12 = errors;
473
748
  const _errs13 = errors;
474
749
  if (errors === _errs13) {
475
- if (Array.isArray(data4)) {
476
- var valid6 = true;
477
- const len0 = data4.length;
478
- for (let i0 = 0; i0 < len0; i0++) {
479
- let data5 = data4[i0];
750
+ if (data4 && typeof data4 == "object" && !Array.isArray(data4)) {
751
+ if (data4["age-restrictions"] !== undefined) {
752
+ let data5 = data4["age-restrictions"];
480
753
  const _errs15 = errors;
481
754
  if (errors === _errs15) {
482
- if (data5 && typeof data5 == "object" && !Array.isArray(data5)) {
483
- let missing3;
484
- if ((data5.id === undefined) && (missing3 = "id")) {
485
- validate20.errors = [{ instancePath: instancePath + "/expanse/platforms/" + i0, schemaPath: "definitions#/definitions/platforms/items/required", keyword: "required", params: { missingProperty: missing3 }, message: "must have required property '" + missing3 + "'" }];
486
- return false;
487
- }
488
- else {
489
- if (data5.id !== undefined) {
490
- const _errs17 = errors;
491
- if (typeof data5.id !== "string") {
492
- validate20.errors = [{ instancePath: instancePath + "/expanse/platforms/" + i0 + "/id", schemaPath: "definitions#/definitions/platforms/items/properties/id/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
755
+ if (!(data5 && typeof data5 == "object" && !Array.isArray(data5))) {
756
+ validate20.errors = [{ instancePath: instancePath + "/expanse/info/age-restrictions", schemaPath: "definitions#/definitions/info/properties/age-restrictions/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
757
+ return false;
758
+ }
759
+ }
760
+ var valid6 = _errs15 === errors;
761
+ }
762
+ else {
763
+ var valid6 = true;
764
+ }
765
+ if (valid6) {
766
+ if (data4["users-count"] !== undefined) {
767
+ let data6 = data4["users-count"];
768
+ const _errs17 = errors;
769
+ if (errors === _errs17) {
770
+ if (data6 && typeof data6 == "object" && !Array.isArray(data6)) {
771
+ if (data6.active !== undefined) {
772
+ let data7 = data6.active;
773
+ const _errs19 = errors;
774
+ if (!(((typeof data7 == "number") && (!(data7 % 1) && !isNaN(data7))) && (isFinite(data7)))) {
775
+ validate20.errors = [{ instancePath: instancePath + "/expanse/info/users-count/active", schemaPath: "definitions#/definitions/info/properties/users-count/properties/active/type", keyword: "type", params: { type: "integer" }, message: "must be integer" }];
493
776
  return false;
494
777
  }
495
- var valid7 = _errs17 === errors;
778
+ var valid7 = _errs19 === errors;
496
779
  }
497
780
  else {
498
781
  var valid7 = true;
499
782
  }
500
783
  if (valid7) {
501
- if (data5.archs !== undefined) {
502
- let data7 = data5.archs;
503
- const _errs19 = errors;
504
- if (errors === _errs19) {
505
- if (Array.isArray(data7)) {
506
- var valid8 = true;
507
- const len1 = data7.length;
508
- for (let i1 = 0; i1 < len1; i1++) {
509
- const _errs21 = errors;
510
- if (typeof data7[i1] !== "string") {
511
- validate20.errors = [{ instancePath: instancePath + "/expanse/platforms/" + i0 + "/archs/" + i1, schemaPath: "definitions#/definitions/platforms/items/properties/archs/items/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
512
- return false;
513
- }
514
- var valid8 = _errs21 === errors;
515
- if (!valid8) {
516
- break;
517
- }
518
- }
519
- }
520
- else {
521
- validate20.errors = [{ instancePath: instancePath + "/expanse/platforms/" + i0 + "/archs", schemaPath: "definitions#/definitions/platforms/items/properties/archs/type", keyword: "type", params: { type: "array" }, message: "must be array" }];
522
- return false;
523
- }
784
+ if (data6.DAU !== undefined) {
785
+ let data8 = data6.DAU;
786
+ const _errs21 = errors;
787
+ if (!(((typeof data8 == "number") && (!(data8 % 1) && !isNaN(data8))) && (isFinite(data8)))) {
788
+ validate20.errors = [{ instancePath: instancePath + "/expanse/info/users-count/DAU", schemaPath: "definitions#/definitions/info/properties/users-count/properties/DAU/type", keyword: "type", params: { type: "integer" }, message: "must be integer" }];
789
+ return false;
524
790
  }
525
- var valid7 = _errs19 === errors;
791
+ var valid7 = _errs21 === errors;
526
792
  }
527
793
  else {
528
794
  var valid7 = true;
529
795
  }
530
796
  if (valid7) {
531
- if (data5.agents !== undefined) {
532
- let data9 = data5.agents;
797
+ if (data6.MAU !== undefined) {
798
+ let data9 = data6.MAU;
533
799
  const _errs23 = errors;
534
- if (errors === _errs23) {
535
- if (Array.isArray(data9)) {
536
- var valid9 = true;
537
- const len2 = data9.length;
538
- for (let i2 = 0; i2 < len2; i2++) {
539
- const _errs25 = errors;
540
- if (typeof data9[i2] !== "string") {
541
- validate20.errors = [{ instancePath: instancePath + "/expanse/platforms/" + i0 + "/agents/" + i2, schemaPath: "definitions#/definitions/platforms/items/properties/agents/items/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
542
- return false;
543
- }
544
- var valid9 = _errs25 === errors;
545
- if (!valid9) {
546
- break;
547
- }
548
- }
549
- }
550
- else {
551
- validate20.errors = [{ instancePath: instancePath + "/expanse/platforms/" + i0 + "/agents", schemaPath: "definitions#/definitions/platforms/items/properties/agents/type", keyword: "type", params: { type: "array" }, message: "must be array" }];
552
- return false;
553
- }
800
+ if (!(((typeof data9 == "number") && (!(data9 % 1) && !isNaN(data9))) && (isFinite(data9)))) {
801
+ validate20.errors = [{ instancePath: instancePath + "/expanse/info/users-count/MAU", schemaPath: "definitions#/definitions/info/properties/users-count/properties/MAU/type", keyword: "type", params: { type: "integer" }, message: "must be integer" }];
802
+ return false;
554
803
  }
555
804
  var valid7 = _errs23 === errors;
556
805
  }
557
806
  else {
558
807
  var valid7 = true;
559
808
  }
809
+ if (valid7) {
810
+ if (data6["concurrent-max"] !== undefined) {
811
+ let data10 = data6["concurrent-max"];
812
+ const _errs25 = errors;
813
+ if (!(((typeof data10 == "number") && (!(data10 % 1) && !isNaN(data10))) && (isFinite(data10)))) {
814
+ validate20.errors = [{ instancePath: instancePath + "/expanse/info/users-count/concurrent-max", schemaPath: "definitions#/definitions/info/properties/users-count/properties/concurrent-max/type", keyword: "type", params: { type: "integer" }, message: "must be integer" }];
815
+ return false;
816
+ }
817
+ var valid7 = _errs25 === errors;
818
+ }
819
+ else {
820
+ var valid7 = true;
821
+ }
822
+ }
560
823
  }
561
824
  }
562
825
  }
826
+ else {
827
+ validate20.errors = [{ instancePath: instancePath + "/expanse/info/users-count", schemaPath: "definitions#/definitions/info/properties/users-count/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
828
+ return false;
829
+ }
830
+ }
831
+ var valid6 = _errs17 === errors;
832
+ }
833
+ else {
834
+ var valid6 = true;
835
+ }
836
+ if (valid6) {
837
+ if (data4.attributes !== undefined) {
838
+ let data11 = data4.attributes;
839
+ const _errs27 = errors;
840
+ if (errors === _errs27) {
841
+ if (Array.isArray(data11)) {
842
+ var valid8 = true;
843
+ const len0 = data11.length;
844
+ for (let i0 = 0; i0 < len0; i0++) {
845
+ const _errs29 = errors;
846
+ if (typeof data11[i0] !== "string") {
847
+ validate20.errors = [{ instancePath: instancePath + "/expanse/info/attributes/" + i0, schemaPath: "definitions#/definitions/info/properties/attributes/items/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
848
+ return false;
849
+ }
850
+ var valid8 = _errs29 === errors;
851
+ if (!valid8) {
852
+ break;
853
+ }
854
+ }
855
+ if (valid8) {
856
+ let i1 = data11.length;
857
+ let j0;
858
+ if (i1 > 1) {
859
+ const indices0 = {};
860
+ for (; i1--;) {
861
+ let item0 = data11[i1];
862
+ if (typeof item0 !== "string") {
863
+ continue;
864
+ }
865
+ if (typeof indices0[item0] == "number") {
866
+ j0 = indices0[item0];
867
+ validate20.errors = [{ instancePath: instancePath + "/expanse/info/attributes", schemaPath: "definitions#/definitions/info/properties/attributes/uniqueItems", keyword: "uniqueItems", params: { i: i1, j: j0 }, message: "must NOT have duplicate items (items ## " + j0 + " and " + i1 + " are identical)" }];
868
+ return false;
869
+ }
870
+ indices0[item0] = i1;
871
+ }
872
+ }
873
+ }
874
+ }
875
+ else {
876
+ validate20.errors = [{ instancePath: instancePath + "/expanse/info/attributes", schemaPath: "definitions#/definitions/info/properties/attributes/type", keyword: "type", params: { type: "array" }, message: "must be array" }];
877
+ return false;
878
+ }
879
+ }
880
+ var valid6 = _errs27 === errors;
563
881
  }
564
882
  else {
565
- validate20.errors = [{ instancePath: instancePath + "/expanse/platforms/" + i0, schemaPath: "definitions#/definitions/platforms/items/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
566
- return false;
883
+ var valid6 = true;
567
884
  }
568
885
  }
569
- var valid6 = _errs15 === errors;
570
- if (!valid6) {
571
- break;
572
- }
573
886
  }
574
887
  }
575
888
  else {
576
- validate20.errors = [{ instancePath: instancePath + "/expanse/platforms", schemaPath: "definitions#/definitions/platforms/type", keyword: "type", params: { type: "array" }, message: "must be array" }];
889
+ validate20.errors = [{ instancePath: instancePath + "/expanse/info", schemaPath: "definitions#/definitions/info/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
577
890
  return false;
578
891
  }
579
892
  }
@@ -583,111 +896,228 @@ function validate20(data, { instancePath = "", parentData, parentDataProperty, r
583
896
  var valid2 = true;
584
897
  }
585
898
  if (valid2) {
586
- if (data0.protocols !== undefined) {
587
- let data11 = data0.protocols;
588
- const _errs27 = errors;
589
- const _errs28 = errors;
590
- if (errors === _errs28) {
591
- if (Array.isArray(data11)) {
899
+ if (data0.platforms !== undefined) {
900
+ let data13 = data0.platforms;
901
+ const _errs31 = errors;
902
+ const _errs32 = errors;
903
+ if (errors === _errs32) {
904
+ if (Array.isArray(data13)) {
592
905
  var valid11 = true;
593
- const len3 = data11.length;
594
- for (let i3 = 0; i3 < len3; i3++) {
595
- let data12 = data11[i3];
596
- const _errs30 = errors;
597
- if (errors === _errs30) {
598
- if (data12 && typeof data12 == "object" && !Array.isArray(data12)) {
599
- let missing4;
600
- if (((data12.id === undefined) && (missing4 = "id")) || ((data12.attr === undefined) && (missing4 = "attr"))) {
601
- validate20.errors = [{ instancePath: instancePath + "/expanse/protocols/" + i3, schemaPath: "definitions#/definitions/protocols/items/required", keyword: "required", params: { missingProperty: missing4 }, message: "must have required property '" + missing4 + "'" }];
906
+ const len1 = data13.length;
907
+ for (let i2 = 0; i2 < len1; i2++) {
908
+ let data14 = data13[i2];
909
+ const _errs34 = errors;
910
+ if (errors === _errs34) {
911
+ if (data14 && typeof data14 == "object" && !Array.isArray(data14)) {
912
+ let missing3;
913
+ if ((data14.id === undefined) && (missing3 = "id")) {
914
+ validate20.errors = [{ instancePath: instancePath + "/expanse/platforms/" + i2, schemaPath: "definitions#/definitions/platforms/items/required", keyword: "required", params: { missingProperty: missing3 }, message: "must have required property '" + missing3 + "'" }];
602
915
  return false;
603
916
  }
604
917
  else {
605
- if (data12.id !== undefined) {
606
- const _errs32 = errors;
607
- if (typeof data12.id !== "string") {
608
- validate20.errors = [{ instancePath: instancePath + "/expanse/protocols/" + i3 + "/id", schemaPath: "definitions#/definitions/protocols/items/properties/id/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
918
+ if (data14.id !== undefined) {
919
+ const _errs36 = errors;
920
+ if (typeof data14.id !== "string") {
921
+ validate20.errors = [{ instancePath: instancePath + "/expanse/platforms/" + i2 + "/id", schemaPath: "definitions#/definitions/platforms/items/properties/id/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
609
922
  return false;
610
923
  }
611
- var valid12 = _errs32 === errors;
924
+ var valid12 = _errs36 === errors;
612
925
  }
613
926
  else {
614
927
  var valid12 = true;
615
928
  }
616
929
  if (valid12) {
617
- if (data12.name !== undefined) {
618
- const _errs34 = errors;
619
- if (typeof data12.name !== "string") {
620
- validate20.errors = [{ instancePath: instancePath + "/expanse/protocols/" + i3 + "/name", schemaPath: "definitions#/definitions/protocols/items/properties/name/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
621
- return false;
930
+ if (data14.archs !== undefined) {
931
+ let data16 = data14.archs;
932
+ const _errs38 = errors;
933
+ if (errors === _errs38) {
934
+ if (Array.isArray(data16)) {
935
+ var valid13 = true;
936
+ const len2 = data16.length;
937
+ for (let i3 = 0; i3 < len2; i3++) {
938
+ const _errs40 = errors;
939
+ if (typeof data16[i3] !== "string") {
940
+ validate20.errors = [{ instancePath: instancePath + "/expanse/platforms/" + i2 + "/archs/" + i3, schemaPath: "definitions#/definitions/platforms/items/properties/archs/items/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
941
+ return false;
942
+ }
943
+ var valid13 = _errs40 === errors;
944
+ if (!valid13) {
945
+ break;
946
+ }
947
+ }
948
+ }
949
+ else {
950
+ validate20.errors = [{ instancePath: instancePath + "/expanse/platforms/" + i2 + "/archs", schemaPath: "definitions#/definitions/platforms/items/properties/archs/type", keyword: "type", params: { type: "array" }, message: "must be array" }];
951
+ return false;
952
+ }
622
953
  }
623
- var valid12 = _errs34 === errors;
954
+ var valid12 = _errs38 === errors;
624
955
  }
625
956
  else {
626
957
  var valid12 = true;
627
958
  }
628
959
  if (valid12) {
629
- if (data12.version !== undefined) {
630
- const _errs36 = errors;
631
- if (typeof data12.version !== "string") {
632
- validate20.errors = [{ instancePath: instancePath + "/expanse/protocols/" + i3 + "/version", schemaPath: "definitions#/definitions/protocols/items/properties/version/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
633
- return false;
634
- }
635
- var valid12 = _errs36 === errors;
636
- }
637
- else {
638
- var valid12 = true;
639
- }
640
- if (valid12) {
641
- if (data12.attr !== undefined) {
642
- const _errs38 = errors;
643
- if (typeof data12.attr !== "string") {
644
- validate20.errors = [{ instancePath: instancePath + "/expanse/protocols/" + i3 + "/attr", schemaPath: "definitions#/definitions/protocols/items/properties/attr/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
645
- return false;
646
- }
647
- var valid12 = _errs38 === errors;
648
- }
649
- else {
650
- var valid12 = true;
651
- }
652
- if (valid12) {
653
- if (data12.url !== undefined) {
654
- const _errs40 = errors;
655
- if (typeof data12.url !== "string") {
656
- validate20.errors = [{ instancePath: instancePath + "/expanse/protocols/" + i3 + "/url", schemaPath: "definitions#/definitions/protocols/items/properties/url/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
657
- return false;
960
+ if (data14.agents !== undefined) {
961
+ let data18 = data14.agents;
962
+ const _errs42 = errors;
963
+ if (errors === _errs42) {
964
+ if (Array.isArray(data18)) {
965
+ var valid14 = true;
966
+ const len3 = data18.length;
967
+ for (let i4 = 0; i4 < len3; i4++) {
968
+ const _errs44 = errors;
969
+ if (typeof data18[i4] !== "string") {
970
+ validate20.errors = [{ instancePath: instancePath + "/expanse/platforms/" + i2 + "/agents/" + i4, schemaPath: "definitions#/definitions/platforms/items/properties/agents/items/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
971
+ return false;
972
+ }
973
+ var valid14 = _errs44 === errors;
974
+ if (!valid14) {
975
+ break;
976
+ }
658
977
  }
659
- var valid12 = _errs40 === errors;
660
978
  }
661
979
  else {
662
- var valid12 = true;
980
+ validate20.errors = [{ instancePath: instancePath + "/expanse/platforms/" + i2 + "/agents", schemaPath: "definitions#/definitions/platforms/items/properties/agents/type", keyword: "type", params: { type: "array" }, message: "must be array" }];
981
+ return false;
663
982
  }
664
983
  }
984
+ var valid12 = _errs42 === errors;
985
+ }
986
+ else {
987
+ var valid12 = true;
665
988
  }
666
989
  }
667
990
  }
668
991
  }
669
992
  }
670
993
  else {
671
- validate20.errors = [{ instancePath: instancePath + "/expanse/protocols/" + i3, schemaPath: "definitions#/definitions/protocols/items/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
994
+ validate20.errors = [{ instancePath: instancePath + "/expanse/platforms/" + i2, schemaPath: "definitions#/definitions/platforms/items/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
672
995
  return false;
673
996
  }
674
997
  }
675
- var valid11 = _errs30 === errors;
998
+ var valid11 = _errs34 === errors;
676
999
  if (!valid11) {
677
1000
  break;
678
1001
  }
679
1002
  }
680
1003
  }
681
1004
  else {
682
- validate20.errors = [{ instancePath: instancePath + "/expanse/protocols", schemaPath: "definitions#/definitions/protocols/type", keyword: "type", params: { type: "array" }, message: "must be array" }];
1005
+ validate20.errors = [{ instancePath: instancePath + "/expanse/platforms", schemaPath: "definitions#/definitions/platforms/type", keyword: "type", params: { type: "array" }, message: "must be array" }];
683
1006
  return false;
684
1007
  }
685
1008
  }
686
- var valid2 = _errs27 === errors;
1009
+ var valid2 = _errs31 === errors;
687
1010
  }
688
1011
  else {
689
1012
  var valid2 = true;
690
1013
  }
1014
+ if (valid2) {
1015
+ if (data0.protocols !== undefined) {
1016
+ let data20 = data0.protocols;
1017
+ const _errs46 = errors;
1018
+ const _errs47 = errors;
1019
+ if (errors === _errs47) {
1020
+ if (Array.isArray(data20)) {
1021
+ var valid16 = true;
1022
+ const len4 = data20.length;
1023
+ for (let i5 = 0; i5 < len4; i5++) {
1024
+ let data21 = data20[i5];
1025
+ const _errs49 = errors;
1026
+ if (errors === _errs49) {
1027
+ if (data21 && typeof data21 == "object" && !Array.isArray(data21)) {
1028
+ let missing4;
1029
+ if (((data21.id === undefined) && (missing4 = "id")) || ((data21.attr === undefined) && (missing4 = "attr"))) {
1030
+ validate20.errors = [{ instancePath: instancePath + "/expanse/protocols/" + i5, schemaPath: "definitions#/definitions/protocols/items/required", keyword: "required", params: { missingProperty: missing4 }, message: "must have required property '" + missing4 + "'" }];
1031
+ return false;
1032
+ }
1033
+ else {
1034
+ if (data21.id !== undefined) {
1035
+ const _errs51 = errors;
1036
+ if (typeof data21.id !== "string") {
1037
+ validate20.errors = [{ instancePath: instancePath + "/expanse/protocols/" + i5 + "/id", schemaPath: "definitions#/definitions/protocols/items/properties/id/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
1038
+ return false;
1039
+ }
1040
+ var valid17 = _errs51 === errors;
1041
+ }
1042
+ else {
1043
+ var valid17 = true;
1044
+ }
1045
+ if (valid17) {
1046
+ if (data21.name !== undefined) {
1047
+ const _errs53 = errors;
1048
+ if (typeof data21.name !== "string") {
1049
+ validate20.errors = [{ instancePath: instancePath + "/expanse/protocols/" + i5 + "/name", schemaPath: "definitions#/definitions/protocols/items/properties/name/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
1050
+ return false;
1051
+ }
1052
+ var valid17 = _errs53 === errors;
1053
+ }
1054
+ else {
1055
+ var valid17 = true;
1056
+ }
1057
+ if (valid17) {
1058
+ if (data21.version !== undefined) {
1059
+ const _errs55 = errors;
1060
+ if (typeof data21.version !== "string") {
1061
+ validate20.errors = [{ instancePath: instancePath + "/expanse/protocols/" + i5 + "/version", schemaPath: "definitions#/definitions/protocols/items/properties/version/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
1062
+ return false;
1063
+ }
1064
+ var valid17 = _errs55 === errors;
1065
+ }
1066
+ else {
1067
+ var valid17 = true;
1068
+ }
1069
+ if (valid17) {
1070
+ if (data21.attr !== undefined) {
1071
+ const _errs57 = errors;
1072
+ if (typeof data21.attr !== "string") {
1073
+ validate20.errors = [{ instancePath: instancePath + "/expanse/protocols/" + i5 + "/attr", schemaPath: "definitions#/definitions/protocols/items/properties/attr/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
1074
+ return false;
1075
+ }
1076
+ var valid17 = _errs57 === errors;
1077
+ }
1078
+ else {
1079
+ var valid17 = true;
1080
+ }
1081
+ if (valid17) {
1082
+ if (data21.url !== undefined) {
1083
+ const _errs59 = errors;
1084
+ if (typeof data21.url !== "string") {
1085
+ validate20.errors = [{ instancePath: instancePath + "/expanse/protocols/" + i5 + "/url", schemaPath: "definitions#/definitions/protocols/items/properties/url/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
1086
+ return false;
1087
+ }
1088
+ var valid17 = _errs59 === errors;
1089
+ }
1090
+ else {
1091
+ var valid17 = true;
1092
+ }
1093
+ }
1094
+ }
1095
+ }
1096
+ }
1097
+ }
1098
+ }
1099
+ else {
1100
+ validate20.errors = [{ instancePath: instancePath + "/expanse/protocols/" + i5, schemaPath: "definitions#/definitions/protocols/items/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
1101
+ return false;
1102
+ }
1103
+ }
1104
+ var valid16 = _errs49 === errors;
1105
+ if (!valid16) {
1106
+ break;
1107
+ }
1108
+ }
1109
+ }
1110
+ else {
1111
+ validate20.errors = [{ instancePath: instancePath + "/expanse/protocols", schemaPath: "definitions#/definitions/protocols/type", keyword: "type", params: { type: "array" }, message: "must be array" }];
1112
+ return false;
1113
+ }
1114
+ }
1115
+ var valid2 = _errs46 === errors;
1116
+ }
1117
+ else {
1118
+ var valid2 = true;
1119
+ }
1120
+ }
691
1121
  }
692
1122
  }
693
1123
  }
@@ -704,12 +1134,12 @@ function validate20(data, { instancePath = "", parentData, parentDataProperty, r
704
1134
  }
705
1135
  if (valid0) {
706
1136
  if (data.subverse_info !== undefined) {
707
- const _errs42 = errors;
708
- if ("4" !== data.subverse_info) {
709
- validate20.errors = [{ instancePath: instancePath + "/subverse_info", schemaPath: "definitions#/definitions/_v/const", keyword: "const", params: { allowedValue: "4" }, message: "must be equal to constant" }];
1137
+ const _errs61 = errors;
1138
+ if ("6" !== data.subverse_info) {
1139
+ validate20.errors = [{ instancePath: instancePath + "/subverse_info", schemaPath: "definitions#/definitions/_v/const", keyword: "const", params: { allowedValue: "6" }, message: "must be equal to constant" }];
710
1140
  return false;
711
1141
  }
712
- var valid0 = _errs42 === errors;
1142
+ var valid0 = _errs61 === errors;
713
1143
  }
714
1144
  else {
715
1145
  var valid0 = true;
@@ -741,10 +1171,165 @@ function validate28(data, { instancePath = "", parentData, parentDataProperty, r
741
1171
  }
742
1172
  if (errors === _errs1) {
743
1173
  if (data0 && typeof data0 == "object" && !Array.isArray(data0)) {
744
- for (const key0 in data0) {
745
- if (((((key0 !== "favicon") && (key0 !== "hyperport")) && (key0 !== "info")) && (key0 !== "uri")) && (key0 !== "name")) {
746
- validate28.errors = [{ instancePath: instancePath + "/" + i0, schemaPath: "#/items/unevaluatedProperties", keyword: "unevaluatedProperties", params: { unevaluatedProperty: key0 }, message: "must NOT have unevaluated properties" }];
747
- return false;
1174
+ if (data0.info !== undefined) {
1175
+ let data1 = data0.info;
1176
+ const _errs4 = errors;
1177
+ const _errs5 = errors;
1178
+ if (errors === _errs5) {
1179
+ if (data1 && typeof data1 == "object" && !Array.isArray(data1)) {
1180
+ if (data1["age-restrictions"] !== undefined) {
1181
+ let data2 = data1["age-restrictions"];
1182
+ const _errs7 = errors;
1183
+ if (errors === _errs7) {
1184
+ if (!(data2 && typeof data2 == "object" && !Array.isArray(data2))) {
1185
+ validate28.errors = [{ instancePath: instancePath + "/" + i0 + "/info/age-restrictions", schemaPath: "definitions#/definitions/info/properties/age-restrictions/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
1186
+ return false;
1187
+ }
1188
+ }
1189
+ var valid4 = _errs7 === errors;
1190
+ }
1191
+ else {
1192
+ var valid4 = true;
1193
+ }
1194
+ if (valid4) {
1195
+ if (data1["users-count"] !== undefined) {
1196
+ let data3 = data1["users-count"];
1197
+ const _errs9 = errors;
1198
+ if (errors === _errs9) {
1199
+ if (data3 && typeof data3 == "object" && !Array.isArray(data3)) {
1200
+ if (data3.active !== undefined) {
1201
+ let data4 = data3.active;
1202
+ const _errs11 = errors;
1203
+ if (!(((typeof data4 == "number") && (!(data4 % 1) && !isNaN(data4))) && (isFinite(data4)))) {
1204
+ validate28.errors = [{ instancePath: instancePath + "/" + i0 + "/info/users-count/active", schemaPath: "definitions#/definitions/info/properties/users-count/properties/active/type", keyword: "type", params: { type: "integer" }, message: "must be integer" }];
1205
+ return false;
1206
+ }
1207
+ var valid5 = _errs11 === errors;
1208
+ }
1209
+ else {
1210
+ var valid5 = true;
1211
+ }
1212
+ if (valid5) {
1213
+ if (data3.DAU !== undefined) {
1214
+ let data5 = data3.DAU;
1215
+ const _errs13 = errors;
1216
+ if (!(((typeof data5 == "number") && (!(data5 % 1) && !isNaN(data5))) && (isFinite(data5)))) {
1217
+ validate28.errors = [{ instancePath: instancePath + "/" + i0 + "/info/users-count/DAU", schemaPath: "definitions#/definitions/info/properties/users-count/properties/DAU/type", keyword: "type", params: { type: "integer" }, message: "must be integer" }];
1218
+ return false;
1219
+ }
1220
+ var valid5 = _errs13 === errors;
1221
+ }
1222
+ else {
1223
+ var valid5 = true;
1224
+ }
1225
+ if (valid5) {
1226
+ if (data3.MAU !== undefined) {
1227
+ let data6 = data3.MAU;
1228
+ const _errs15 = errors;
1229
+ if (!(((typeof data6 == "number") && (!(data6 % 1) && !isNaN(data6))) && (isFinite(data6)))) {
1230
+ validate28.errors = [{ instancePath: instancePath + "/" + i0 + "/info/users-count/MAU", schemaPath: "definitions#/definitions/info/properties/users-count/properties/MAU/type", keyword: "type", params: { type: "integer" }, message: "must be integer" }];
1231
+ return false;
1232
+ }
1233
+ var valid5 = _errs15 === errors;
1234
+ }
1235
+ else {
1236
+ var valid5 = true;
1237
+ }
1238
+ if (valid5) {
1239
+ if (data3["concurrent-max"] !== undefined) {
1240
+ let data7 = data3["concurrent-max"];
1241
+ const _errs17 = errors;
1242
+ if (!(((typeof data7 == "number") && (!(data7 % 1) && !isNaN(data7))) && (isFinite(data7)))) {
1243
+ validate28.errors = [{ instancePath: instancePath + "/" + i0 + "/info/users-count/concurrent-max", schemaPath: "definitions#/definitions/info/properties/users-count/properties/concurrent-max/type", keyword: "type", params: { type: "integer" }, message: "must be integer" }];
1244
+ return false;
1245
+ }
1246
+ var valid5 = _errs17 === errors;
1247
+ }
1248
+ else {
1249
+ var valid5 = true;
1250
+ }
1251
+ }
1252
+ }
1253
+ }
1254
+ }
1255
+ else {
1256
+ validate28.errors = [{ instancePath: instancePath + "/" + i0 + "/info/users-count", schemaPath: "definitions#/definitions/info/properties/users-count/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
1257
+ return false;
1258
+ }
1259
+ }
1260
+ var valid4 = _errs9 === errors;
1261
+ }
1262
+ else {
1263
+ var valid4 = true;
1264
+ }
1265
+ if (valid4) {
1266
+ if (data1.attributes !== undefined) {
1267
+ let data8 = data1.attributes;
1268
+ const _errs19 = errors;
1269
+ if (errors === _errs19) {
1270
+ if (Array.isArray(data8)) {
1271
+ var valid6 = true;
1272
+ const len1 = data8.length;
1273
+ for (let i1 = 0; i1 < len1; i1++) {
1274
+ const _errs21 = errors;
1275
+ if (typeof data8[i1] !== "string") {
1276
+ validate28.errors = [{ instancePath: instancePath + "/" + i0 + "/info/attributes/" + i1, schemaPath: "definitions#/definitions/info/properties/attributes/items/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
1277
+ return false;
1278
+ }
1279
+ var valid6 = _errs21 === errors;
1280
+ if (!valid6) {
1281
+ break;
1282
+ }
1283
+ }
1284
+ if (valid6) {
1285
+ let i2 = data8.length;
1286
+ let j0;
1287
+ if (i2 > 1) {
1288
+ const indices0 = {};
1289
+ for (; i2--;) {
1290
+ let item0 = data8[i2];
1291
+ if (typeof item0 !== "string") {
1292
+ continue;
1293
+ }
1294
+ if (typeof indices0[item0] == "number") {
1295
+ j0 = indices0[item0];
1296
+ validate28.errors = [{ instancePath: instancePath + "/" + i0 + "/info/attributes", schemaPath: "definitions#/definitions/info/properties/attributes/uniqueItems", keyword: "uniqueItems", params: { i: i2, j: j0 }, message: "must NOT have duplicate items (items ## " + j0 + " and " + i2 + " are identical)" }];
1297
+ return false;
1298
+ }
1299
+ indices0[item0] = i2;
1300
+ }
1301
+ }
1302
+ }
1303
+ }
1304
+ else {
1305
+ validate28.errors = [{ instancePath: instancePath + "/" + i0 + "/info/attributes", schemaPath: "definitions#/definitions/info/properties/attributes/type", keyword: "type", params: { type: "array" }, message: "must be array" }];
1306
+ return false;
1307
+ }
1308
+ }
1309
+ var valid4 = _errs19 === errors;
1310
+ }
1311
+ else {
1312
+ var valid4 = true;
1313
+ }
1314
+ }
1315
+ }
1316
+ }
1317
+ else {
1318
+ validate28.errors = [{ instancePath: instancePath + "/" + i0 + "/info", schemaPath: "definitions#/definitions/info/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
1319
+ return false;
1320
+ }
1321
+ }
1322
+ var valid2 = _errs4 === errors;
1323
+ }
1324
+ else {
1325
+ var valid2 = true;
1326
+ }
1327
+ if (valid2) {
1328
+ for (const key0 in data0) {
1329
+ if (((((key0 !== "info") && (key0 !== "favicon")) && (key0 !== "hyperport")) && (key0 !== "uri")) && (key0 !== "name")) {
1330
+ validate28.errors = [{ instancePath: instancePath + "/" + i0, schemaPath: "#/items/unevaluatedProperties", keyword: "unevaluatedProperties", params: { unevaluatedProperty: key0 }, message: "must NOT have unevaluated properties" }];
1331
+ return false;
1332
+ }
748
1333
  }
749
1334
  }
750
1335
  }
@@ -1102,8 +1687,8 @@ function validate27(data, { instancePath = "", parentData, parentDataProperty, r
1102
1687
  if (valid0) {
1103
1688
  if (data.subverse_info !== undefined) {
1104
1689
  const _errs44 = errors;
1105
- if ("4" !== data.subverse_info) {
1106
- validate27.errors = [{ instancePath: instancePath + "/subverse_info", schemaPath: "definitions#/definitions/_v/const", keyword: "const", params: { allowedValue: "4" }, message: "must be equal to constant" }];
1690
+ if ("6" !== data.subverse_info) {
1691
+ validate27.errors = [{ instancePath: instancePath + "/subverse_info", schemaPath: "definitions#/definitions/_v/const", keyword: "const", params: { allowedValue: "6" }, message: "must be equal to constant" }];
1107
1692
  return false;
1108
1693
  }
1109
1694
  var valid0 = _errs44 === errors;
@@ -1693,7 +2278,7 @@ function requireJsonMsg_cjs () {
1693
2278
 
1694
2279
  //-------------------------------------------------------------------------------------------------
1695
2280
  const LOGR_ = bitlogr.LOGR.get_instance();
1696
- const logr_ = LOGR_.create({ labels: bitlogr.l_array(['VALIDATION', 'DROPS', 'HANDLERS']) });
2281
+ const logr_ = LOGR_.create({ labels: bitlogr.l_array(['VALIDATION']) });
1697
2282
  const l_ = logr_.l;
1698
2283
  // console.log('File location:', import.meta.url, '[Implementation]');
1699
2284
  //-------------------------------------------------------------------------------------------------
@@ -1775,12 +2360,10 @@ function requireJsonMsg_cjs () {
1775
2360
 
1776
2361
  var jsonMsg_cjsExports = requireJsonMsg_cjs();
1777
2362
 
1778
- const kstr_VERSION = "4";
2363
+ const kstr_VERSION = "6";
1779
2364
  // TODO: use RFC3339 "timestamp"? https://ajv.js.org/json-type-definition.html
1780
2365
  //-------------------------------------------------------------------------------------------------
1781
2366
  LOGR.get_instance();
1782
- const obj_labels_shift_ = l_LL_(jsonMsg_cjsExports.logr.lref.get(), 2); // VALIDATION : 4
1783
- jsonMsg_cjsExports.logr.lref.set(obj_labels_shift_);
1784
2367
  const l_ = jsonMsg_cjsExports.logr.l;
1785
2368
  //-------------------------------------------------------------------------------------------------
1786
2369
  // const regex_IOI= new RegExp('\\bquery\\s*\\{\\s*IOI\\s*\\(\\s*pkg\\s*:\\s*"([^"]*)"\\s*\\)\\s*\\{.*heartbeat\\s*\\}\\s*\\}');