@m1kad0/hannah-proto 3.7.1 → 3.7.2

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 (25) hide show
  1. package/dist/activity_log.js +216 -166
  2. package/dist/agent.js +1330 -1050
  3. package/dist/automation.js +142 -92
  4. package/dist/car_state.js +245 -195
  5. package/dist/compat_versions.js +1 -1
  6. package/dist/control.js +1675 -1255
  7. package/dist/descriptor.binpb +0 -0
  8. package/dist/device_control_menu.js +302 -222
  9. package/dist/event_stream.js +236 -166
  10. package/dist/google/protobuf/descriptor.js +1721 -1381
  11. package/dist/hannah.js +1 -1
  12. package/dist/messages.js +198 -148
  13. package/dist/options.js +1 -1
  14. package/dist/satellite.js +314 -244
  15. package/dist/satellite_provisioning.js +38 -28
  16. package/dist/satellite_proxy.d.ts +5 -2
  17. package/dist/satellite_proxy.js +278 -208
  18. package/dist/shared.js +111 -71
  19. package/dist/speaker_enrollment.js +38 -28
  20. package/dist/timer_admin.js +131 -91
  21. package/dist/timer_service.js +467 -327
  22. package/dist/user_registry.js +724 -534
  23. package/dist/wakeword_capture.js +295 -195
  24. package/dist/weather.js +172 -142
  25. package/package.json +2 -2
package/dist/google/protobuf/descriptor.js CHANGED
@@ -1,7 +1,7 @@
1
1
  "use strict";
2
2
  // Code generated by protoc-gen-ts_proto. DO NOT EDIT.
3
3
  // versions:
4
- // protoc-gen-ts_proto v2.12.0
4
+ // protoc-gen-ts_proto v2.12.1
5
5
  // protoc unknown
6
6
  // source: google/protobuf/descriptor.proto
7
7
  Object.defineProperty(exports, "__esModule", { value: true });
@@ -305,25 +305,35 @@ exports.FileDescriptorSet = {
305
305
  },
306
306
  decode(input, length) {
307
307
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
308
- const end = length === undefined ? reader.len : reader.pos + length;
309
- const message = createBaseFileDescriptorSet();
310
- while (reader.pos < end) {
311
- const tag = reader.uint32();
312
- switch (tag >>> 3) {
313
- case 1: {
314
- if (tag !== 10) {
315
- break;
308
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
309
+ if (previousRecursionDepth >= 100) {
310
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
311
+ }
312
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
313
+ try {
314
+ const end = length === undefined ? reader.len : reader.pos + length;
315
+ const message = createBaseFileDescriptorSet();
316
+ while (reader.pos < end) {
317
+ const tag = reader.uint32();
318
+ switch (tag >>> 3) {
319
+ case 1: {
320
+ if (tag !== 10) {
321
+ break;
322
+ }
323
+ message.file.push(exports.FileDescriptorProto.decode(reader, reader.uint32()));
324
+ continue;
316
325
  }
317
- message.file.push(exports.FileDescriptorProto.decode(reader, reader.uint32()));
318
- continue;
319
326
  }
327
+ if ((tag & 7) === 4 || tag === 0) {
328
+ break;
329
+ }
330
+ reader.skip(tag & 7);
320
331
  }
321
- if ((tag & 7) === 4 || tag === 0) {
322
- break;
323
- }
324
- reader.skip(tag & 7);
332
+ return message;
333
+ }
334
+ finally {
335
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
325
336
  }
326
- return message;
327
337
  },
328
338
  create(base) {
329
339
  return exports.FileDescriptorSet.fromPartial(base ?? {});
@@ -400,130 +410,140 @@ exports.FileDescriptorProto = {
400
410
  },
401
411
  decode(input, length) {
402
412
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
403
- const end = length === undefined ? reader.len : reader.pos + length;
404
- const message = createBaseFileDescriptorProto();
405
- while (reader.pos < end) {
406
- const tag = reader.uint32();
407
- switch (tag >>> 3) {
408
- case 1: {
409
- if (tag !== 10) {
410
- break;
413
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
414
+ if (previousRecursionDepth >= 100) {
415
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
416
+ }
417
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
418
+ try {
419
+ const end = length === undefined ? reader.len : reader.pos + length;
420
+ const message = createBaseFileDescriptorProto();
421
+ while (reader.pos < end) {
422
+ const tag = reader.uint32();
423
+ switch (tag >>> 3) {
424
+ case 1: {
425
+ if (tag !== 10) {
426
+ break;
427
+ }
428
+ message.name = reader.string();
429
+ continue;
411
430
  }
412
- message.name = reader.string();
413
- continue;
414
- }
415
- case 2: {
416
- if (tag !== 18) {
431
+ case 2: {
432
+ if (tag !== 18) {
433
+ break;
434
+ }
435
+ message.package = reader.string();
436
+ continue;
437
+ }
438
+ case 3: {
439
+ if (tag !== 26) {
440
+ break;
441
+ }
442
+ message.dependency.push(reader.string());
443
+ continue;
444
+ }
445
+ case 10: {
446
+ if (tag === 80) {
447
+ message.publicDependency.push(reader.int32());
448
+ continue;
449
+ }
450
+ if (tag === 82) {
451
+ const end2 = reader.uint32() + reader.pos;
452
+ while (reader.pos < end2) {
453
+ message.publicDependency.push(reader.int32());
454
+ }
455
+ continue;
456
+ }
417
457
  break;
418
458
  }
419
- message.package = reader.string();
420
- continue;
421
- }
422
- case 3: {
423
- if (tag !== 26) {
459
+ case 11: {
460
+ if (tag === 88) {
461
+ message.weakDependency.push(reader.int32());
462
+ continue;
463
+ }
464
+ if (tag === 90) {
465
+ const end2 = reader.uint32() + reader.pos;
466
+ while (reader.pos < end2) {
467
+ message.weakDependency.push(reader.int32());
468
+ }
469
+ continue;
470
+ }
424
471
  break;
425
472
  }
426
- message.dependency.push(reader.string());
427
- continue;
428
- }
429
- case 10: {
430
- if (tag === 80) {
431
- message.publicDependency.push(reader.int32());
473
+ case 15: {
474
+ if (tag !== 122) {
475
+ break;
476
+ }
477
+ message.optionDependency.push(reader.string());
432
478
  continue;
433
479
  }
434
- if (tag === 82) {
435
- const end2 = reader.uint32() + reader.pos;
436
- while (reader.pos < end2) {
437
- message.publicDependency.push(reader.int32());
480
+ case 4: {
481
+ if (tag !== 34) {
482
+ break;
438
483
  }
484
+ message.messageType.push(exports.DescriptorProto.decode(reader, reader.uint32()));
439
485
  continue;
440
486
  }
441
- break;
442
- }
443
- case 11: {
444
- if (tag === 88) {
445
- message.weakDependency.push(reader.int32());
487
+ case 5: {
488
+ if (tag !== 42) {
489
+ break;
490
+ }
491
+ message.enumType.push(exports.EnumDescriptorProto.decode(reader, reader.uint32()));
446
492
  continue;
447
493
  }
448
- if (tag === 90) {
449
- const end2 = reader.uint32() + reader.pos;
450
- while (reader.pos < end2) {
451
- message.weakDependency.push(reader.int32());
494
+ case 6: {
495
+ if (tag !== 50) {
496
+ break;
452
497
  }
498
+ message.service.push(exports.ServiceDescriptorProto.decode(reader, reader.uint32()));
453
499
  continue;
454
500
  }
455
- break;
456
- }
457
- case 15: {
458
- if (tag !== 122) {
459
- break;
460
- }
461
- message.optionDependency.push(reader.string());
462
- continue;
463
- }
464
- case 4: {
465
- if (tag !== 34) {
466
- break;
467
- }
468
- message.messageType.push(exports.DescriptorProto.decode(reader, reader.uint32()));
469
- continue;
470
- }
471
- case 5: {
472
- if (tag !== 42) {
473
- break;
474
- }
475
- message.enumType.push(exports.EnumDescriptorProto.decode(reader, reader.uint32()));
476
- continue;
477
- }
478
- case 6: {
479
- if (tag !== 50) {
480
- break;
501
+ case 7: {
502
+ if (tag !== 58) {
503
+ break;
504
+ }
505
+ message.extension.push(exports.FieldDescriptorProto.decode(reader, reader.uint32()));
506
+ continue;
481
507
  }
482
- message.service.push(exports.ServiceDescriptorProto.decode(reader, reader.uint32()));
483
- continue;
484
- }
485
- case 7: {
486
- if (tag !== 58) {
487
- break;
508
+ case 8: {
509
+ if (tag !== 66) {
510
+ break;
511
+ }
512
+ message.options = exports.FileOptions.decode(reader, reader.uint32());
513
+ continue;
488
514
  }
489
- message.extension.push(exports.FieldDescriptorProto.decode(reader, reader.uint32()));
490
- continue;
491
- }
492
- case 8: {
493
- if (tag !== 66) {
494
- break;
515
+ case 9: {
516
+ if (tag !== 74) {
517
+ break;
518
+ }
519
+ message.sourceCodeInfo = exports.SourceCodeInfo.decode(reader, reader.uint32());
520
+ continue;
495
521
  }
496
- message.options = exports.FileOptions.decode(reader, reader.uint32());
497
- continue;
498
- }
499
- case 9: {
500
- if (tag !== 74) {
501
- break;
522
+ case 12: {
523
+ if (tag !== 98) {
524
+ break;
525
+ }
526
+ message.syntax = reader.string();
527
+ continue;
502
528
  }
503
- message.sourceCodeInfo = exports.SourceCodeInfo.decode(reader, reader.uint32());
504
- continue;
505
- }
506
- case 12: {
507
- if (tag !== 98) {
508
- break;
529
+ case 14: {
530
+ if (tag !== 112) {
531
+ break;
532
+ }
533
+ message.edition = reader.int32();
534
+ continue;
509
535
  }
510
- message.syntax = reader.string();
511
- continue;
512
536
  }
513
- case 14: {
514
- if (tag !== 112) {
515
- break;
516
- }
517
- message.edition = reader.int32();
518
- continue;
537
+ if ((tag & 7) === 4 || tag === 0) {
538
+ break;
519
539
  }
540
+ reader.skip(tag & 7);
520
541
  }
521
- if ((tag & 7) === 4 || tag === 0) {
522
- break;
523
- }
524
- reader.skip(tag & 7);
542
+ return message;
543
+ }
544
+ finally {
545
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
525
546
  }
526
- return message;
527
547
  },
528
548
  create(base) {
529
549
  return exports.FileDescriptorProto.fromPartial(base ?? {});
@@ -605,95 +625,105 @@ exports.DescriptorProto = {
605
625
  },
606
626
  decode(input, length) {
607
627
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
608
- const end = length === undefined ? reader.len : reader.pos + length;
609
- const message = createBaseDescriptorProto();
610
- while (reader.pos < end) {
611
- const tag = reader.uint32();
612
- switch (tag >>> 3) {
613
- case 1: {
614
- if (tag !== 10) {
615
- break;
628
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
629
+ if (previousRecursionDepth >= 100) {
630
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
631
+ }
632
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
633
+ try {
634
+ const end = length === undefined ? reader.len : reader.pos + length;
635
+ const message = createBaseDescriptorProto();
636
+ while (reader.pos < end) {
637
+ const tag = reader.uint32();
638
+ switch (tag >>> 3) {
639
+ case 1: {
640
+ if (tag !== 10) {
641
+ break;
642
+ }
643
+ message.name = reader.string();
644
+ continue;
616
645
  }
617
- message.name = reader.string();
618
- continue;
619
- }
620
- case 2: {
621
- if (tag !== 18) {
622
- break;
646
+ case 2: {
647
+ if (tag !== 18) {
648
+ break;
649
+ }
650
+ message.field.push(exports.FieldDescriptorProto.decode(reader, reader.uint32()));
651
+ continue;
623
652
  }
624
- message.field.push(exports.FieldDescriptorProto.decode(reader, reader.uint32()));
625
- continue;
626
- }
627
- case 6: {
628
- if (tag !== 50) {
629
- break;
653
+ case 6: {
654
+ if (tag !== 50) {
655
+ break;
656
+ }
657
+ message.extension.push(exports.FieldDescriptorProto.decode(reader, reader.uint32()));
658
+ continue;
630
659
  }
631
- message.extension.push(exports.FieldDescriptorProto.decode(reader, reader.uint32()));
632
- continue;
633
- }
634
- case 3: {
635
- if (tag !== 26) {
636
- break;
660
+ case 3: {
661
+ if (tag !== 26) {
662
+ break;
663
+ }
664
+ message.nestedType.push(exports.DescriptorProto.decode(reader, reader.uint32()));
665
+ continue;
637
666
  }
638
- message.nestedType.push(exports.DescriptorProto.decode(reader, reader.uint32()));
639
- continue;
640
- }
641
- case 4: {
642
- if (tag !== 34) {
643
- break;
667
+ case 4: {
668
+ if (tag !== 34) {
669
+ break;
670
+ }
671
+ message.enumType.push(exports.EnumDescriptorProto.decode(reader, reader.uint32()));
672
+ continue;
644
673
  }
645
- message.enumType.push(exports.EnumDescriptorProto.decode(reader, reader.uint32()));
646
- continue;
647
- }
648
- case 5: {
649
- if (tag !== 42) {
650
- break;
674
+ case 5: {
675
+ if (tag !== 42) {
676
+ break;
677
+ }
678
+ message.extensionRange.push(exports.DescriptorProto_ExtensionRange.decode(reader, reader.uint32()));
679
+ continue;
651
680
  }
652
- message.extensionRange.push(exports.DescriptorProto_ExtensionRange.decode(reader, reader.uint32()));
653
- continue;
654
- }
655
- case 8: {
656
- if (tag !== 66) {
657
- break;
681
+ case 8: {
682
+ if (tag !== 66) {
683
+ break;
684
+ }
685
+ message.oneofDecl.push(exports.OneofDescriptorProto.decode(reader, reader.uint32()));
686
+ continue;
658
687
  }
659
- message.oneofDecl.push(exports.OneofDescriptorProto.decode(reader, reader.uint32()));
660
- continue;
661
- }
662
- case 7: {
663
- if (tag !== 58) {
664
- break;
688
+ case 7: {
689
+ if (tag !== 58) {
690
+ break;
691
+ }
692
+ message.options = exports.MessageOptions.decode(reader, reader.uint32());
693
+ continue;
665
694
  }
666
- message.options = exports.MessageOptions.decode(reader, reader.uint32());
667
- continue;
668
- }
669
- case 9: {
670
- if (tag !== 74) {
671
- break;
695
+ case 9: {
696
+ if (tag !== 74) {
697
+ break;
698
+ }
699
+ message.reservedRange.push(exports.DescriptorProto_ReservedRange.decode(reader, reader.uint32()));
700
+ continue;
672
701
  }
673
- message.reservedRange.push(exports.DescriptorProto_ReservedRange.decode(reader, reader.uint32()));
674
- continue;
675
- }
676
- case 10: {
677
- if (tag !== 82) {
678
- break;
702
+ case 10: {
703
+ if (tag !== 82) {
704
+ break;
705
+ }
706
+ message.reservedName.push(reader.string());
707
+ continue;
679
708
  }
680
- message.reservedName.push(reader.string());
681
- continue;
682
- }
683
- case 11: {
684
- if (tag !== 88) {
685
- break;
709
+ case 11: {
710
+ if (tag !== 88) {
711
+ break;
712
+ }
713
+ message.visibility = reader.int32();
714
+ continue;
686
715
  }
687
- message.visibility = reader.int32();
688
- continue;
689
716
  }
717
+ if ((tag & 7) === 4 || tag === 0) {
718
+ break;
719
+ }
720
+ reader.skip(tag & 7);
690
721
  }
691
- if ((tag & 7) === 4 || tag === 0) {
692
- break;
693
- }
694
- reader.skip(tag & 7);
722
+ return message;
723
+ }
724
+ finally {
725
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
695
726
  }
696
- return message;
697
727
  },
698
728
  create(base) {
699
729
  return exports.DescriptorProto.fromPartial(base ?? {});
@@ -734,39 +764,49 @@ exports.DescriptorProto_ExtensionRange = {
734
764
  },
735
765
  decode(input, length) {
736
766
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
737
- const end = length === undefined ? reader.len : reader.pos + length;
738
- const message = createBaseDescriptorProto_ExtensionRange();
739
- while (reader.pos < end) {
740
- const tag = reader.uint32();
741
- switch (tag >>> 3) {
742
- case 1: {
743
- if (tag !== 8) {
744
- break;
767
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
768
+ if (previousRecursionDepth >= 100) {
769
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
770
+ }
771
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
772
+ try {
773
+ const end = length === undefined ? reader.len : reader.pos + length;
774
+ const message = createBaseDescriptorProto_ExtensionRange();
775
+ while (reader.pos < end) {
776
+ const tag = reader.uint32();
777
+ switch (tag >>> 3) {
778
+ case 1: {
779
+ if (tag !== 8) {
780
+ break;
781
+ }
782
+ message.start = reader.int32();
783
+ continue;
745
784
  }
746
- message.start = reader.int32();
747
- continue;
748
- }
749
- case 2: {
750
- if (tag !== 16) {
751
- break;
785
+ case 2: {
786
+ if (tag !== 16) {
787
+ break;
788
+ }
789
+ message.end = reader.int32();
790
+ continue;
752
791
  }
753
- message.end = reader.int32();
754
- continue;
755
- }
756
- case 3: {
757
- if (tag !== 26) {
758
- break;
792
+ case 3: {
793
+ if (tag !== 26) {
794
+ break;
795
+ }
796
+ message.options = exports.ExtensionRangeOptions.decode(reader, reader.uint32());
797
+ continue;
759
798
  }
760
- message.options = exports.ExtensionRangeOptions.decode(reader, reader.uint32());
761
- continue;
762
799
  }
800
+ if ((tag & 7) === 4 || tag === 0) {
801
+ break;
802
+ }
803
+ reader.skip(tag & 7);
763
804
  }
764
- if ((tag & 7) === 4 || tag === 0) {
765
- break;
766
- }
767
- reader.skip(tag & 7);
805
+ return message;
806
+ }
807
+ finally {
808
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
768
809
  }
769
- return message;
770
810
  },
771
811
  create(base) {
772
812
  return exports.DescriptorProto_ExtensionRange.fromPartial(base ?? {});
@@ -796,32 +836,42 @@ exports.DescriptorProto_ReservedRange = {
796
836
  },
797
837
  decode(input, length) {
798
838
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
799
- const end = length === undefined ? reader.len : reader.pos + length;
800
- const message = createBaseDescriptorProto_ReservedRange();
801
- while (reader.pos < end) {
802
- const tag = reader.uint32();
803
- switch (tag >>> 3) {
804
- case 1: {
805
- if (tag !== 8) {
806
- break;
839
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
840
+ if (previousRecursionDepth >= 100) {
841
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
842
+ }
843
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
844
+ try {
845
+ const end = length === undefined ? reader.len : reader.pos + length;
846
+ const message = createBaseDescriptorProto_ReservedRange();
847
+ while (reader.pos < end) {
848
+ const tag = reader.uint32();
849
+ switch (tag >>> 3) {
850
+ case 1: {
851
+ if (tag !== 8) {
852
+ break;
853
+ }
854
+ message.start = reader.int32();
855
+ continue;
807
856
  }
808
- message.start = reader.int32();
809
- continue;
810
- }
811
- case 2: {
812
- if (tag !== 16) {
813
- break;
857
+ case 2: {
858
+ if (tag !== 16) {
859
+ break;
860
+ }
861
+ message.end = reader.int32();
862
+ continue;
814
863
  }
815
- message.end = reader.int32();
816
- continue;
817
864
  }
865
+ if ((tag & 7) === 4 || tag === 0) {
866
+ break;
867
+ }
868
+ reader.skip(tag & 7);
818
869
  }
819
- if ((tag & 7) === 4 || tag === 0) {
820
- break;
821
- }
822
- reader.skip(tag & 7);
870
+ return message;
871
+ }
872
+ finally {
873
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
823
874
  }
824
- return message;
825
875
  },
826
876
  create(base) {
827
877
  return exports.DescriptorProto_ReservedRange.fromPartial(base ?? {});
@@ -854,46 +904,56 @@ exports.ExtensionRangeOptions = {
854
904
  },
855
905
  decode(input, length) {
856
906
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
857
- const end = length === undefined ? reader.len : reader.pos + length;
858
- const message = createBaseExtensionRangeOptions();
859
- while (reader.pos < end) {
860
- const tag = reader.uint32();
861
- switch (tag >>> 3) {
862
- case 999: {
863
- if (tag !== 7994) {
864
- break;
907
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
908
+ if (previousRecursionDepth >= 100) {
909
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
910
+ }
911
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
912
+ try {
913
+ const end = length === undefined ? reader.len : reader.pos + length;
914
+ const message = createBaseExtensionRangeOptions();
915
+ while (reader.pos < end) {
916
+ const tag = reader.uint32();
917
+ switch (tag >>> 3) {
918
+ case 999: {
919
+ if (tag !== 7994) {
920
+ break;
921
+ }
922
+ message.uninterpretedOption.push(exports.UninterpretedOption.decode(reader, reader.uint32()));
923
+ continue;
865
924
  }
866
- message.uninterpretedOption.push(exports.UninterpretedOption.decode(reader, reader.uint32()));
867
- continue;
868
- }
869
- case 2: {
870
- if (tag !== 18) {
871
- break;
925
+ case 2: {
926
+ if (tag !== 18) {
927
+ break;
928
+ }
929
+ message.declaration.push(exports.ExtensionRangeOptions_Declaration.decode(reader, reader.uint32()));
930
+ continue;
872
931
  }
873
- message.declaration.push(exports.ExtensionRangeOptions_Declaration.decode(reader, reader.uint32()));
874
- continue;
875
- }
876
- case 50: {
877
- if (tag !== 402) {
878
- break;
932
+ case 50: {
933
+ if (tag !== 402) {
934
+ break;
935
+ }
936
+ message.features = exports.FeatureSet.decode(reader, reader.uint32());
937
+ continue;
879
938
  }
880
- message.features = exports.FeatureSet.decode(reader, reader.uint32());
881
- continue;
882
- }
883
- case 3: {
884
- if (tag !== 24) {
885
- break;
939
+ case 3: {
940
+ if (tag !== 24) {
941
+ break;
942
+ }
943
+ message.verification = reader.int32();
944
+ continue;
886
945
  }
887
- message.verification = reader.int32();
888
- continue;
889
946
  }
947
+ if ((tag & 7) === 4 || tag === 0) {
948
+ break;
949
+ }
950
+ reader.skip(tag & 7);
890
951
  }
891
- if ((tag & 7) === 4 || tag === 0) {
892
- break;
893
- }
894
- reader.skip(tag & 7);
952
+ return message;
953
+ }
954
+ finally {
955
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
895
956
  }
896
- return message;
897
957
  },
898
958
  create(base) {
899
959
  return exports.ExtensionRangeOptions.fromPartial(base ?? {});
@@ -933,53 +993,63 @@ exports.ExtensionRangeOptions_Declaration = {
933
993
  },
934
994
  decode(input, length) {
935
995
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
936
- const end = length === undefined ? reader.len : reader.pos + length;
937
- const message = createBaseExtensionRangeOptions_Declaration();
938
- while (reader.pos < end) {
939
- const tag = reader.uint32();
940
- switch (tag >>> 3) {
941
- case 1: {
942
- if (tag !== 8) {
943
- break;
996
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
997
+ if (previousRecursionDepth >= 100) {
998
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
999
+ }
1000
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
1001
+ try {
1002
+ const end = length === undefined ? reader.len : reader.pos + length;
1003
+ const message = createBaseExtensionRangeOptions_Declaration();
1004
+ while (reader.pos < end) {
1005
+ const tag = reader.uint32();
1006
+ switch (tag >>> 3) {
1007
+ case 1: {
1008
+ if (tag !== 8) {
1009
+ break;
1010
+ }
1011
+ message.number = reader.int32();
1012
+ continue;
944
1013
  }
945
- message.number = reader.int32();
946
- continue;
947
- }
948
- case 2: {
949
- if (tag !== 18) {
950
- break;
1014
+ case 2: {
1015
+ if (tag !== 18) {
1016
+ break;
1017
+ }
1018
+ message.fullName = reader.string();
1019
+ continue;
951
1020
  }
952
- message.fullName = reader.string();
953
- continue;
954
- }
955
- case 3: {
956
- if (tag !== 26) {
957
- break;
1021
+ case 3: {
1022
+ if (tag !== 26) {
1023
+ break;
1024
+ }
1025
+ message.type = reader.string();
1026
+ continue;
958
1027
  }
959
- message.type = reader.string();
960
- continue;
961
- }
962
- case 5: {
963
- if (tag !== 40) {
964
- break;
1028
+ case 5: {
1029
+ if (tag !== 40) {
1030
+ break;
1031
+ }
1032
+ message.reserved = reader.bool();
1033
+ continue;
965
1034
  }
966
- message.reserved = reader.bool();
967
- continue;
968
- }
969
- case 6: {
970
- if (tag !== 48) {
971
- break;
1035
+ case 6: {
1036
+ if (tag !== 48) {
1037
+ break;
1038
+ }
1039
+ message.repeated = reader.bool();
1040
+ continue;
972
1041
  }
973
- message.repeated = reader.bool();
974
- continue;
975
1042
  }
1043
+ if ((tag & 7) === 4 || tag === 0) {
1044
+ break;
1045
+ }
1046
+ reader.skip(tag & 7);
976
1047
  }
977
- if ((tag & 7) === 4 || tag === 0) {
978
- break;
979
- }
980
- reader.skip(tag & 7);
1048
+ return message;
1049
+ }
1050
+ finally {
1051
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
981
1052
  }
982
- return message;
983
1053
  },
984
1054
  create(base) {
985
1055
  return exports.ExtensionRangeOptions_Declaration.fromPartial(base ?? {});
@@ -1048,95 +1118,105 @@ exports.FieldDescriptorProto = {
1048
1118
  },
1049
1119
  decode(input, length) {
1050
1120
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
1051
- const end = length === undefined ? reader.len : reader.pos + length;
1052
- const message = createBaseFieldDescriptorProto();
1053
- while (reader.pos < end) {
1054
- const tag = reader.uint32();
1055
- switch (tag >>> 3) {
1056
- case 1: {
1057
- if (tag !== 10) {
1058
- break;
1121
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
1122
+ if (previousRecursionDepth >= 100) {
1123
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
1124
+ }
1125
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
1126
+ try {
1127
+ const end = length === undefined ? reader.len : reader.pos + length;
1128
+ const message = createBaseFieldDescriptorProto();
1129
+ while (reader.pos < end) {
1130
+ const tag = reader.uint32();
1131
+ switch (tag >>> 3) {
1132
+ case 1: {
1133
+ if (tag !== 10) {
1134
+ break;
1135
+ }
1136
+ message.name = reader.string();
1137
+ continue;
1059
1138
  }
1060
- message.name = reader.string();
1061
- continue;
1062
- }
1063
- case 3: {
1064
- if (tag !== 24) {
1065
- break;
1139
+ case 3: {
1140
+ if (tag !== 24) {
1141
+ break;
1142
+ }
1143
+ message.number = reader.int32();
1144
+ continue;
1066
1145
  }
1067
- message.number = reader.int32();
1068
- continue;
1069
- }
1070
- case 4: {
1071
- if (tag !== 32) {
1072
- break;
1146
+ case 4: {
1147
+ if (tag !== 32) {
1148
+ break;
1149
+ }
1150
+ message.label = reader.int32();
1151
+ continue;
1073
1152
  }
1074
- message.label = reader.int32();
1075
- continue;
1076
- }
1077
- case 5: {
1078
- if (tag !== 40) {
1079
- break;
1153
+ case 5: {
1154
+ if (tag !== 40) {
1155
+ break;
1156
+ }
1157
+ message.type = reader.int32();
1158
+ continue;
1080
1159
  }
1081
- message.type = reader.int32();
1082
- continue;
1083
- }
1084
- case 6: {
1085
- if (tag !== 50) {
1086
- break;
1160
+ case 6: {
1161
+ if (tag !== 50) {
1162
+ break;
1163
+ }
1164
+ message.typeName = reader.string();
1165
+ continue;
1087
1166
  }
1088
- message.typeName = reader.string();
1089
- continue;
1090
- }
1091
- case 2: {
1092
- if (tag !== 18) {
1093
- break;
1167
+ case 2: {
1168
+ if (tag !== 18) {
1169
+ break;
1170
+ }
1171
+ message.extendee = reader.string();
1172
+ continue;
1094
1173
  }
1095
- message.extendee = reader.string();
1096
- continue;
1097
- }
1098
- case 7: {
1099
- if (tag !== 58) {
1100
- break;
1174
+ case 7: {
1175
+ if (tag !== 58) {
1176
+ break;
1177
+ }
1178
+ message.defaultValue = reader.string();
1179
+ continue;
1101
1180
  }
1102
- message.defaultValue = reader.string();
1103
- continue;
1104
- }
1105
- case 9: {
1106
- if (tag !== 72) {
1107
- break;
1181
+ case 9: {
1182
+ if (tag !== 72) {
1183
+ break;
1184
+ }
1185
+ message.oneofIndex = reader.int32();
1186
+ continue;
1108
1187
  }
1109
- message.oneofIndex = reader.int32();
1110
- continue;
1111
- }
1112
- case 10: {
1113
- if (tag !== 82) {
1114
- break;
1188
+ case 10: {
1189
+ if (tag !== 82) {
1190
+ break;
1191
+ }
1192
+ message.jsonName = reader.string();
1193
+ continue;
1115
1194
  }
1116
- message.jsonName = reader.string();
1117
- continue;
1118
- }
1119
- case 8: {
1120
- if (tag !== 66) {
1121
- break;
1195
+ case 8: {
1196
+ if (tag !== 66) {
1197
+ break;
1198
+ }
1199
+ message.options = exports.FieldOptions.decode(reader, reader.uint32());
1200
+ continue;
1122
1201
  }
1123
- message.options = exports.FieldOptions.decode(reader, reader.uint32());
1124
- continue;
1125
- }
1126
- case 17: {
1127
- if (tag !== 136) {
1128
- break;
1202
+ case 17: {
1203
+ if (tag !== 136) {
1204
+ break;
1205
+ }
1206
+ message.proto3Optional = reader.bool();
1207
+ continue;
1129
1208
  }
1130
- message.proto3Optional = reader.bool();
1131
- continue;
1132
1209
  }
1210
+ if ((tag & 7) === 4 || tag === 0) {
1211
+ break;
1212
+ }
1213
+ reader.skip(tag & 7);
1133
1214
  }
1134
- if ((tag & 7) === 4 || tag === 0) {
1135
- break;
1136
- }
1137
- reader.skip(tag & 7);
1215
+ return message;
1216
+ }
1217
+ finally {
1218
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
1138
1219
  }
1139
- return message;
1140
1220
  },
1141
1221
  create(base) {
1142
1222
  return exports.FieldDescriptorProto.fromPartial(base ?? {});
@@ -1174,32 +1254,42 @@ exports.OneofDescriptorProto = {
1174
1254
  },
1175
1255
  decode(input, length) {
1176
1256
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
1177
- const end = length === undefined ? reader.len : reader.pos + length;
1178
- const message = createBaseOneofDescriptorProto();
1179
- while (reader.pos < end) {
1180
- const tag = reader.uint32();
1181
- switch (tag >>> 3) {
1182
- case 1: {
1183
- if (tag !== 10) {
1184
- break;
1257
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
1258
+ if (previousRecursionDepth >= 100) {
1259
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
1260
+ }
1261
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
1262
+ try {
1263
+ const end = length === undefined ? reader.len : reader.pos + length;
1264
+ const message = createBaseOneofDescriptorProto();
1265
+ while (reader.pos < end) {
1266
+ const tag = reader.uint32();
1267
+ switch (tag >>> 3) {
1268
+ case 1: {
1269
+ if (tag !== 10) {
1270
+ break;
1271
+ }
1272
+ message.name = reader.string();
1273
+ continue;
1185
1274
  }
1186
- message.name = reader.string();
1187
- continue;
1188
- }
1189
- case 2: {
1190
- if (tag !== 18) {
1191
- break;
1275
+ case 2: {
1276
+ if (tag !== 18) {
1277
+ break;
1278
+ }
1279
+ message.options = exports.OneofOptions.decode(reader, reader.uint32());
1280
+ continue;
1192
1281
  }
1193
- message.options = exports.OneofOptions.decode(reader, reader.uint32());
1194
- continue;
1195
1282
  }
1283
+ if ((tag & 7) === 4 || tag === 0) {
1284
+ break;
1285
+ }
1286
+ reader.skip(tag & 7);
1196
1287
  }
1197
- if ((tag & 7) === 4 || tag === 0) {
1198
- break;
1199
- }
1200
- reader.skip(tag & 7);
1288
+ return message;
1289
+ }
1290
+ finally {
1291
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
1201
1292
  }
1202
- return message;
1203
1293
  },
1204
1294
  create(base) {
1205
1295
  return exports.OneofDescriptorProto.fromPartial(base ?? {});
@@ -1240,60 +1330,70 @@ exports.EnumDescriptorProto = {
1240
1330
  },
1241
1331
  decode(input, length) {
1242
1332
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
1243
- const end = length === undefined ? reader.len : reader.pos + length;
1244
- const message = createBaseEnumDescriptorProto();
1245
- while (reader.pos < end) {
1246
- const tag = reader.uint32();
1247
- switch (tag >>> 3) {
1248
- case 1: {
1249
- if (tag !== 10) {
1250
- break;
1333
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
1334
+ if (previousRecursionDepth >= 100) {
1335
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
1336
+ }
1337
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
1338
+ try {
1339
+ const end = length === undefined ? reader.len : reader.pos + length;
1340
+ const message = createBaseEnumDescriptorProto();
1341
+ while (reader.pos < end) {
1342
+ const tag = reader.uint32();
1343
+ switch (tag >>> 3) {
1344
+ case 1: {
1345
+ if (tag !== 10) {
1346
+ break;
1347
+ }
1348
+ message.name = reader.string();
1349
+ continue;
1251
1350
  }
1252
- message.name = reader.string();
1253
- continue;
1254
- }
1255
- case 2: {
1256
- if (tag !== 18) {
1257
- break;
1351
+ case 2: {
1352
+ if (tag !== 18) {
1353
+ break;
1354
+ }
1355
+ message.value.push(exports.EnumValueDescriptorProto.decode(reader, reader.uint32()));
1356
+ continue;
1258
1357
  }
1259
- message.value.push(exports.EnumValueDescriptorProto.decode(reader, reader.uint32()));
1260
- continue;
1261
- }
1262
- case 3: {
1263
- if (tag !== 26) {
1264
- break;
1358
+ case 3: {
1359
+ if (tag !== 26) {
1360
+ break;
1361
+ }
1362
+ message.options = exports.EnumOptions.decode(reader, reader.uint32());
1363
+ continue;
1265
1364
  }
1266
- message.options = exports.EnumOptions.decode(reader, reader.uint32());
1267
- continue;
1268
- }
1269
- case 4: {
1270
- if (tag !== 34) {
1271
- break;
1365
+ case 4: {
1366
+ if (tag !== 34) {
1367
+ break;
1368
+ }
1369
+ message.reservedRange.push(exports.EnumDescriptorProto_EnumReservedRange.decode(reader, reader.uint32()));
1370
+ continue;
1272
1371
  }
1273
- message.reservedRange.push(exports.EnumDescriptorProto_EnumReservedRange.decode(reader, reader.uint32()));
1274
- continue;
1275
- }
1276
- case 5: {
1277
- if (tag !== 42) {
1278
- break;
1372
+ case 5: {
1373
+ if (tag !== 42) {
1374
+ break;
1375
+ }
1376
+ message.reservedName.push(reader.string());
1377
+ continue;
1279
1378
  }
1280
- message.reservedName.push(reader.string());
1281
- continue;
1282
- }
1283
- case 6: {
1284
- if (tag !== 48) {
1285
- break;
1379
+ case 6: {
1380
+ if (tag !== 48) {
1381
+ break;
1382
+ }
1383
+ message.visibility = reader.int32();
1384
+ continue;
1286
1385
  }
1287
- message.visibility = reader.int32();
1288
- continue;
1289
1386
  }
1387
+ if ((tag & 7) === 4 || tag === 0) {
1388
+ break;
1389
+ }
1390
+ reader.skip(tag & 7);
1290
1391
  }
1291
- if ((tag & 7) === 4 || tag === 0) {
1292
- break;
1293
- }
1294
- reader.skip(tag & 7);
1392
+ return message;
1393
+ }
1394
+ finally {
1395
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
1295
1396
  }
1296
- return message;
1297
1397
  },
1298
1398
  create(base) {
1299
1399
  return exports.EnumDescriptorProto.fromPartial(base ?? {});
@@ -1327,32 +1427,42 @@ exports.EnumDescriptorProto_EnumReservedRange = {
1327
1427
  },
1328
1428
  decode(input, length) {
1329
1429
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
1330
- const end = length === undefined ? reader.len : reader.pos + length;
1331
- const message = createBaseEnumDescriptorProto_EnumReservedRange();
1332
- while (reader.pos < end) {
1333
- const tag = reader.uint32();
1334
- switch (tag >>> 3) {
1335
- case 1: {
1336
- if (tag !== 8) {
1337
- break;
1430
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
1431
+ if (previousRecursionDepth >= 100) {
1432
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
1433
+ }
1434
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
1435
+ try {
1436
+ const end = length === undefined ? reader.len : reader.pos + length;
1437
+ const message = createBaseEnumDescriptorProto_EnumReservedRange();
1438
+ while (reader.pos < end) {
1439
+ const tag = reader.uint32();
1440
+ switch (tag >>> 3) {
1441
+ case 1: {
1442
+ if (tag !== 8) {
1443
+ break;
1444
+ }
1445
+ message.start = reader.int32();
1446
+ continue;
1338
1447
  }
1339
- message.start = reader.int32();
1340
- continue;
1341
- }
1342
- case 2: {
1343
- if (tag !== 16) {
1344
- break;
1448
+ case 2: {
1449
+ if (tag !== 16) {
1450
+ break;
1451
+ }
1452
+ message.end = reader.int32();
1453
+ continue;
1345
1454
  }
1346
- message.end = reader.int32();
1347
- continue;
1348
1455
  }
1456
+ if ((tag & 7) === 4 || tag === 0) {
1457
+ break;
1458
+ }
1459
+ reader.skip(tag & 7);
1349
1460
  }
1350
- if ((tag & 7) === 4 || tag === 0) {
1351
- break;
1352
- }
1353
- reader.skip(tag & 7);
1461
+ return message;
1462
+ }
1463
+ finally {
1464
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
1354
1465
  }
1355
- return message;
1356
1466
  },
1357
1467
  create(base) {
1358
1468
  return exports.EnumDescriptorProto_EnumReservedRange.fromPartial(base ?? {});
@@ -1382,39 +1492,49 @@ exports.EnumValueDescriptorProto = {
1382
1492
  },
1383
1493
  decode(input, length) {
1384
1494
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
1385
- const end = length === undefined ? reader.len : reader.pos + length;
1386
- const message = createBaseEnumValueDescriptorProto();
1387
- while (reader.pos < end) {
1388
- const tag = reader.uint32();
1389
- switch (tag >>> 3) {
1390
- case 1: {
1391
- if (tag !== 10) {
1392
- break;
1495
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
1496
+ if (previousRecursionDepth >= 100) {
1497
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
1498
+ }
1499
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
1500
+ try {
1501
+ const end = length === undefined ? reader.len : reader.pos + length;
1502
+ const message = createBaseEnumValueDescriptorProto();
1503
+ while (reader.pos < end) {
1504
+ const tag = reader.uint32();
1505
+ switch (tag >>> 3) {
1506
+ case 1: {
1507
+ if (tag !== 10) {
1508
+ break;
1509
+ }
1510
+ message.name = reader.string();
1511
+ continue;
1393
1512
  }
1394
- message.name = reader.string();
1395
- continue;
1396
- }
1397
- case 2: {
1398
- if (tag !== 16) {
1399
- break;
1513
+ case 2: {
1514
+ if (tag !== 16) {
1515
+ break;
1516
+ }
1517
+ message.number = reader.int32();
1518
+ continue;
1400
1519
  }
1401
- message.number = reader.int32();
1402
- continue;
1403
- }
1404
- case 3: {
1405
- if (tag !== 26) {
1406
- break;
1520
+ case 3: {
1521
+ if (tag !== 26) {
1522
+ break;
1523
+ }
1524
+ message.options = exports.EnumValueOptions.decode(reader, reader.uint32());
1525
+ continue;
1407
1526
  }
1408
- message.options = exports.EnumValueOptions.decode(reader, reader.uint32());
1409
- continue;
1410
1527
  }
1528
+ if ((tag & 7) === 4 || tag === 0) {
1529
+ break;
1530
+ }
1531
+ reader.skip(tag & 7);
1411
1532
  }
1412
- if ((tag & 7) === 4 || tag === 0) {
1413
- break;
1414
- }
1415
- reader.skip(tag & 7);
1533
+ return message;
1534
+ }
1535
+ finally {
1536
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
1416
1537
  }
1417
- return message;
1418
1538
  },
1419
1539
  create(base) {
1420
1540
  return exports.EnumValueDescriptorProto.fromPartial(base ?? {});
@@ -1447,39 +1567,49 @@ exports.ServiceDescriptorProto = {
1447
1567
  },
1448
1568
  decode(input, length) {
1449
1569
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
1450
- const end = length === undefined ? reader.len : reader.pos + length;
1451
- const message = createBaseServiceDescriptorProto();
1452
- while (reader.pos < end) {
1453
- const tag = reader.uint32();
1454
- switch (tag >>> 3) {
1455
- case 1: {
1456
- if (tag !== 10) {
1457
- break;
1570
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
1571
+ if (previousRecursionDepth >= 100) {
1572
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
1573
+ }
1574
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
1575
+ try {
1576
+ const end = length === undefined ? reader.len : reader.pos + length;
1577
+ const message = createBaseServiceDescriptorProto();
1578
+ while (reader.pos < end) {
1579
+ const tag = reader.uint32();
1580
+ switch (tag >>> 3) {
1581
+ case 1: {
1582
+ if (tag !== 10) {
1583
+ break;
1584
+ }
1585
+ message.name = reader.string();
1586
+ continue;
1458
1587
  }
1459
- message.name = reader.string();
1460
- continue;
1461
- }
1462
- case 2: {
1463
- if (tag !== 18) {
1464
- break;
1588
+ case 2: {
1589
+ if (tag !== 18) {
1590
+ break;
1591
+ }
1592
+ message.method.push(exports.MethodDescriptorProto.decode(reader, reader.uint32()));
1593
+ continue;
1465
1594
  }
1466
- message.method.push(exports.MethodDescriptorProto.decode(reader, reader.uint32()));
1467
- continue;
1468
- }
1469
- case 3: {
1470
- if (tag !== 26) {
1471
- break;
1595
+ case 3: {
1596
+ if (tag !== 26) {
1597
+ break;
1598
+ }
1599
+ message.options = exports.ServiceOptions.decode(reader, reader.uint32());
1600
+ continue;
1472
1601
  }
1473
- message.options = exports.ServiceOptions.decode(reader, reader.uint32());
1474
- continue;
1475
1602
  }
1603
+ if ((tag & 7) === 4 || tag === 0) {
1604
+ break;
1605
+ }
1606
+ reader.skip(tag & 7);
1476
1607
  }
1477
- if ((tag & 7) === 4 || tag === 0) {
1478
- break;
1479
- }
1480
- reader.skip(tag & 7);
1608
+ return message;
1609
+ }
1610
+ finally {
1611
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
1481
1612
  }
1482
- return message;
1483
1613
  },
1484
1614
  create(base) {
1485
1615
  return exports.ServiceDescriptorProto.fromPartial(base ?? {});
@@ -1528,60 +1658,70 @@ exports.MethodDescriptorProto = {
1528
1658
  },
1529
1659
  decode(input, length) {
1530
1660
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
1531
- const end = length === undefined ? reader.len : reader.pos + length;
1532
- const message = createBaseMethodDescriptorProto();
1533
- while (reader.pos < end) {
1534
- const tag = reader.uint32();
1535
- switch (tag >>> 3) {
1536
- case 1: {
1537
- if (tag !== 10) {
1538
- break;
1661
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
1662
+ if (previousRecursionDepth >= 100) {
1663
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
1664
+ }
1665
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
1666
+ try {
1667
+ const end = length === undefined ? reader.len : reader.pos + length;
1668
+ const message = createBaseMethodDescriptorProto();
1669
+ while (reader.pos < end) {
1670
+ const tag = reader.uint32();
1671
+ switch (tag >>> 3) {
1672
+ case 1: {
1673
+ if (tag !== 10) {
1674
+ break;
1675
+ }
1676
+ message.name = reader.string();
1677
+ continue;
1539
1678
  }
1540
- message.name = reader.string();
1541
- continue;
1542
- }
1543
- case 2: {
1544
- if (tag !== 18) {
1545
- break;
1679
+ case 2: {
1680
+ if (tag !== 18) {
1681
+ break;
1682
+ }
1683
+ message.inputType = reader.string();
1684
+ continue;
1546
1685
  }
1547
- message.inputType = reader.string();
1548
- continue;
1549
- }
1550
- case 3: {
1551
- if (tag !== 26) {
1552
- break;
1686
+ case 3: {
1687
+ if (tag !== 26) {
1688
+ break;
1689
+ }
1690
+ message.outputType = reader.string();
1691
+ continue;
1553
1692
  }
1554
- message.outputType = reader.string();
1555
- continue;
1556
- }
1557
- case 4: {
1558
- if (tag !== 34) {
1559
- break;
1693
+ case 4: {
1694
+ if (tag !== 34) {
1695
+ break;
1696
+ }
1697
+ message.options = exports.MethodOptions.decode(reader, reader.uint32());
1698
+ continue;
1560
1699
  }
1561
- message.options = exports.MethodOptions.decode(reader, reader.uint32());
1562
- continue;
1563
- }
1564
- case 5: {
1565
- if (tag !== 40) {
1566
- break;
1700
+ case 5: {
1701
+ if (tag !== 40) {
1702
+ break;
1703
+ }
1704
+ message.clientStreaming = reader.bool();
1705
+ continue;
1567
1706
  }
1568
- message.clientStreaming = reader.bool();
1569
- continue;
1570
- }
1571
- case 6: {
1572
- if (tag !== 48) {
1573
- break;
1707
+ case 6: {
1708
+ if (tag !== 48) {
1709
+ break;
1710
+ }
1711
+ message.serverStreaming = reader.bool();
1712
+ continue;
1574
1713
  }
1575
- message.serverStreaming = reader.bool();
1576
- continue;
1577
1714
  }
1715
+ if ((tag & 7) === 4 || tag === 0) {
1716
+ break;
1717
+ }
1718
+ reader.skip(tag & 7);
1578
1719
  }
1579
- if ((tag & 7) === 4 || tag === 0) {
1580
- break;
1581
- }
1582
- reader.skip(tag & 7);
1720
+ return message;
1721
+ }
1722
+ finally {
1723
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
1583
1724
  }
1584
- return message;
1585
1725
  },
1586
1726
  create(base) {
1587
1727
  return exports.MethodDescriptorProto.fromPartial(base ?? {});
@@ -1693,165 +1833,175 @@ exports.FileOptions = {
1693
1833
  },
1694
1834
  decode(input, length) {
1695
1835
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
1696
- const end = length === undefined ? reader.len : reader.pos + length;
1697
- const message = createBaseFileOptions();
1698
- while (reader.pos < end) {
1699
- const tag = reader.uint32();
1700
- switch (tag >>> 3) {
1701
- case 1: {
1702
- if (tag !== 10) {
1703
- break;
1836
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
1837
+ if (previousRecursionDepth >= 100) {
1838
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
1839
+ }
1840
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
1841
+ try {
1842
+ const end = length === undefined ? reader.len : reader.pos + length;
1843
+ const message = createBaseFileOptions();
1844
+ while (reader.pos < end) {
1845
+ const tag = reader.uint32();
1846
+ switch (tag >>> 3) {
1847
+ case 1: {
1848
+ if (tag !== 10) {
1849
+ break;
1850
+ }
1851
+ message.javaPackage = reader.string();
1852
+ continue;
1704
1853
  }
1705
- message.javaPackage = reader.string();
1706
- continue;
1707
- }
1708
- case 8: {
1709
- if (tag !== 66) {
1710
- break;
1854
+ case 8: {
1855
+ if (tag !== 66) {
1856
+ break;
1857
+ }
1858
+ message.javaOuterClassname = reader.string();
1859
+ continue;
1711
1860
  }
1712
- message.javaOuterClassname = reader.string();
1713
- continue;
1714
- }
1715
- case 10: {
1716
- if (tag !== 80) {
1717
- break;
1861
+ case 10: {
1862
+ if (tag !== 80) {
1863
+ break;
1864
+ }
1865
+ message.javaMultipleFiles = reader.bool();
1866
+ continue;
1718
1867
  }
1719
- message.javaMultipleFiles = reader.bool();
1720
- continue;
1721
- }
1722
- case 20: {
1723
- if (tag !== 160) {
1724
- break;
1868
+ case 20: {
1869
+ if (tag !== 160) {
1870
+ break;
1871
+ }
1872
+ message.javaGenerateEqualsAndHash = reader.bool();
1873
+ continue;
1725
1874
  }
1726
- message.javaGenerateEqualsAndHash = reader.bool();
1727
- continue;
1728
- }
1729
- case 27: {
1730
- if (tag !== 216) {
1731
- break;
1875
+ case 27: {
1876
+ if (tag !== 216) {
1877
+ break;
1878
+ }
1879
+ message.javaStringCheckUtf8 = reader.bool();
1880
+ continue;
1732
1881
  }
1733
- message.javaStringCheckUtf8 = reader.bool();
1734
- continue;
1735
- }
1736
- case 9: {
1737
- if (tag !== 72) {
1738
- break;
1882
+ case 9: {
1883
+ if (tag !== 72) {
1884
+ break;
1885
+ }
1886
+ message.optimizeFor = reader.int32();
1887
+ continue;
1739
1888
  }
1740
- message.optimizeFor = reader.int32();
1741
- continue;
1742
- }
1743
- case 11: {
1744
- if (tag !== 90) {
1745
- break;
1889
+ case 11: {
1890
+ if (tag !== 90) {
1891
+ break;
1892
+ }
1893
+ message.goPackage = reader.string();
1894
+ continue;
1746
1895
  }
1747
- message.goPackage = reader.string();
1748
- continue;
1749
- }
1750
- case 16: {
1751
- if (tag !== 128) {
1752
- break;
1896
+ case 16: {
1897
+ if (tag !== 128) {
1898
+ break;
1899
+ }
1900
+ message.ccGenericServices = reader.bool();
1901
+ continue;
1753
1902
  }
1754
- message.ccGenericServices = reader.bool();
1755
- continue;
1756
- }
1757
- case 17: {
1758
- if (tag !== 136) {
1759
- break;
1903
+ case 17: {
1904
+ if (tag !== 136) {
1905
+ break;
1906
+ }
1907
+ message.javaGenericServices = reader.bool();
1908
+ continue;
1760
1909
  }
1761
- message.javaGenericServices = reader.bool();
1762
- continue;
1763
- }
1764
- case 18: {
1765
- if (tag !== 144) {
1766
- break;
1910
+ case 18: {
1911
+ if (tag !== 144) {
1912
+ break;
1913
+ }
1914
+ message.pyGenericServices = reader.bool();
1915
+ continue;
1767
1916
  }
1768
- message.pyGenericServices = reader.bool();
1769
- continue;
1770
- }
1771
- case 23: {
1772
- if (tag !== 184) {
1773
- break;
1917
+ case 23: {
1918
+ if (tag !== 184) {
1919
+ break;
1920
+ }
1921
+ message.deprecated = reader.bool();
1922
+ continue;
1774
1923
  }
1775
- message.deprecated = reader.bool();
1776
- continue;
1777
- }
1778
- case 31: {
1779
- if (tag !== 248) {
1780
- break;
1924
+ case 31: {
1925
+ if (tag !== 248) {
1926
+ break;
1927
+ }
1928
+ message.ccEnableArenas = reader.bool();
1929
+ continue;
1781
1930
  }
1782
- message.ccEnableArenas = reader.bool();
1783
- continue;
1784
- }
1785
- case 36: {
1786
- if (tag !== 290) {
1787
- break;
1931
+ case 36: {
1932
+ if (tag !== 290) {
1933
+ break;
1934
+ }
1935
+ message.objcClassPrefix = reader.string();
1936
+ continue;
1788
1937
  }
1789
- message.objcClassPrefix = reader.string();
1790
- continue;
1791
- }
1792
- case 37: {
1793
- if (tag !== 298) {
1794
- break;
1938
+ case 37: {
1939
+ if (tag !== 298) {
1940
+ break;
1941
+ }
1942
+ message.csharpNamespace = reader.string();
1943
+ continue;
1795
1944
  }
1796
- message.csharpNamespace = reader.string();
1797
- continue;
1798
- }
1799
- case 39: {
1800
- if (tag !== 314) {
1801
- break;
1945
+ case 39: {
1946
+ if (tag !== 314) {
1947
+ break;
1948
+ }
1949
+ message.swiftPrefix = reader.string();
1950
+ continue;
1802
1951
  }
1803
- message.swiftPrefix = reader.string();
1804
- continue;
1805
- }
1806
- case 40: {
1807
- if (tag !== 322) {
1808
- break;
1952
+ case 40: {
1953
+ if (tag !== 322) {
1954
+ break;
1955
+ }
1956
+ message.phpClassPrefix = reader.string();
1957
+ continue;
1809
1958
  }
1810
- message.phpClassPrefix = reader.string();
1811
- continue;
1812
- }
1813
- case 41: {
1814
- if (tag !== 330) {
1815
- break;
1959
+ case 41: {
1960
+ if (tag !== 330) {
1961
+ break;
1962
+ }
1963
+ message.phpNamespace = reader.string();
1964
+ continue;
1816
1965
  }
1817
- message.phpNamespace = reader.string();
1818
- continue;
1819
- }
1820
- case 44: {
1821
- if (tag !== 354) {
1822
- break;
1966
+ case 44: {
1967
+ if (tag !== 354) {
1968
+ break;
1969
+ }
1970
+ message.phpMetadataNamespace = reader.string();
1971
+ continue;
1823
1972
  }
1824
- message.phpMetadataNamespace = reader.string();
1825
- continue;
1826
- }
1827
- case 45: {
1828
- if (tag !== 362) {
1829
- break;
1973
+ case 45: {
1974
+ if (tag !== 362) {
1975
+ break;
1976
+ }
1977
+ message.rubyPackage = reader.string();
1978
+ continue;
1830
1979
  }
1831
- message.rubyPackage = reader.string();
1832
- continue;
1833
- }
1834
- case 50: {
1835
- if (tag !== 402) {
1836
- break;
1980
+ case 50: {
1981
+ if (tag !== 402) {
1982
+ break;
1983
+ }
1984
+ message.features = exports.FeatureSet.decode(reader, reader.uint32());
1985
+ continue;
1837
1986
  }
1838
- message.features = exports.FeatureSet.decode(reader, reader.uint32());
1839
- continue;
1840
- }
1841
- case 999: {
1842
- if (tag !== 7994) {
1843
- break;
1987
+ case 999: {
1988
+ if (tag !== 7994) {
1989
+ break;
1990
+ }
1991
+ message.uninterpretedOption.push(exports.UninterpretedOption.decode(reader, reader.uint32()));
1992
+ continue;
1844
1993
  }
1845
- message.uninterpretedOption.push(exports.UninterpretedOption.decode(reader, reader.uint32()));
1846
- continue;
1847
1994
  }
1995
+ if ((tag & 7) === 4 || tag === 0) {
1996
+ break;
1997
+ }
1998
+ reader.skip(tag & 7);
1848
1999
  }
1849
- if ((tag & 7) === 4 || tag === 0) {
1850
- break;
1851
- }
1852
- reader.skip(tag & 7);
2000
+ return message;
2001
+ }
2002
+ finally {
2003
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
1853
2004
  }
1854
- return message;
1855
2005
  },
1856
2006
  create(base) {
1857
2007
  return exports.FileOptions.fromPartial(base ?? {});
@@ -1922,67 +2072,77 @@ exports.MessageOptions = {
1922
2072
  },
1923
2073
  decode(input, length) {
1924
2074
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
1925
- const end = length === undefined ? reader.len : reader.pos + length;
1926
- const message = createBaseMessageOptions();
1927
- while (reader.pos < end) {
1928
- const tag = reader.uint32();
1929
- switch (tag >>> 3) {
1930
- case 1: {
1931
- if (tag !== 8) {
1932
- break;
2075
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
2076
+ if (previousRecursionDepth >= 100) {
2077
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
2078
+ }
2079
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
2080
+ try {
2081
+ const end = length === undefined ? reader.len : reader.pos + length;
2082
+ const message = createBaseMessageOptions();
2083
+ while (reader.pos < end) {
2084
+ const tag = reader.uint32();
2085
+ switch (tag >>> 3) {
2086
+ case 1: {
2087
+ if (tag !== 8) {
2088
+ break;
2089
+ }
2090
+ message.messageSetWireFormat = reader.bool();
2091
+ continue;
1933
2092
  }
1934
- message.messageSetWireFormat = reader.bool();
1935
- continue;
1936
- }
1937
- case 2: {
1938
- if (tag !== 16) {
1939
- break;
2093
+ case 2: {
2094
+ if (tag !== 16) {
2095
+ break;
2096
+ }
2097
+ message.noStandardDescriptorAccessor = reader.bool();
2098
+ continue;
1940
2099
  }
1941
- message.noStandardDescriptorAccessor = reader.bool();
1942
- continue;
1943
- }
1944
- case 3: {
1945
- if (tag !== 24) {
1946
- break;
2100
+ case 3: {
2101
+ if (tag !== 24) {
2102
+ break;
2103
+ }
2104
+ message.deprecated = reader.bool();
2105
+ continue;
1947
2106
  }
1948
- message.deprecated = reader.bool();
1949
- continue;
1950
- }
1951
- case 7: {
1952
- if (tag !== 56) {
1953
- break;
2107
+ case 7: {
2108
+ if (tag !== 56) {
2109
+ break;
2110
+ }
2111
+ message.mapEntry = reader.bool();
2112
+ continue;
1954
2113
  }
1955
- message.mapEntry = reader.bool();
1956
- continue;
1957
- }
1958
- case 11: {
1959
- if (tag !== 88) {
1960
- break;
2114
+ case 11: {
2115
+ if (tag !== 88) {
2116
+ break;
2117
+ }
2118
+ message.deprecatedLegacyJsonFieldConflicts = reader.bool();
2119
+ continue;
1961
2120
  }
1962
- message.deprecatedLegacyJsonFieldConflicts = reader.bool();
1963
- continue;
1964
- }
1965
- case 12: {
1966
- if (tag !== 98) {
1967
- break;
2121
+ case 12: {
2122
+ if (tag !== 98) {
2123
+ break;
2124
+ }
2125
+ message.features = exports.FeatureSet.decode(reader, reader.uint32());
2126
+ continue;
1968
2127
  }
1969
- message.features = exports.FeatureSet.decode(reader, reader.uint32());
1970
- continue;
1971
- }
1972
- case 999: {
1973
- if (tag !== 7994) {
1974
- break;
2128
+ case 999: {
2129
+ if (tag !== 7994) {
2130
+ break;
2131
+ }
2132
+ message.uninterpretedOption.push(exports.UninterpretedOption.decode(reader, reader.uint32()));
2133
+ continue;
1975
2134
  }
1976
- message.uninterpretedOption.push(exports.UninterpretedOption.decode(reader, reader.uint32()));
1977
- continue;
1978
2135
  }
2136
+ if ((tag & 7) === 4 || tag === 0) {
2137
+ break;
2138
+ }
2139
+ reader.skip(tag & 7);
1979
2140
  }
1980
- if ((tag & 7) === 4 || tag === 0) {
1981
- break;
1982
- }
1983
- reader.skip(tag & 7);
2141
+ return message;
2142
+ }
2143
+ finally {
2144
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
1984
2145
  }
1985
- return message;
1986
2146
  },
1987
2147
  create(base) {
1988
2148
  return exports.MessageOptions.fromPartial(base ?? {});
@@ -2067,123 +2227,133 @@ exports.FieldOptions = {
2067
2227
  },
2068
2228
  decode(input, length) {
2069
2229
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
2070
- const end = length === undefined ? reader.len : reader.pos + length;
2071
- const message = createBaseFieldOptions();
2072
- while (reader.pos < end) {
2073
- const tag = reader.uint32();
2074
- switch (tag >>> 3) {
2075
- case 1: {
2076
- if (tag !== 8) {
2077
- break;
2078
- }
2079
- message.ctype = reader.int32();
2080
- continue;
2081
- }
2082
- case 2: {
2083
- if (tag !== 16) {
2084
- break;
2230
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
2231
+ if (previousRecursionDepth >= 100) {
2232
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
2233
+ }
2234
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
2235
+ try {
2236
+ const end = length === undefined ? reader.len : reader.pos + length;
2237
+ const message = createBaseFieldOptions();
2238
+ while (reader.pos < end) {
2239
+ const tag = reader.uint32();
2240
+ switch (tag >>> 3) {
2241
+ case 1: {
2242
+ if (tag !== 8) {
2243
+ break;
2244
+ }
2245
+ message.ctype = reader.int32();
2246
+ continue;
2085
2247
  }
2086
- message.packed = reader.bool();
2087
- continue;
2088
- }
2089
- case 6: {
2090
- if (tag !== 48) {
2091
- break;
2248
+ case 2: {
2249
+ if (tag !== 16) {
2250
+ break;
2251
+ }
2252
+ message.packed = reader.bool();
2253
+ continue;
2092
2254
  }
2093
- message.jstype = reader.int32();
2094
- continue;
2095
- }
2096
- case 5: {
2097
- if (tag !== 40) {
2098
- break;
2255
+ case 6: {
2256
+ if (tag !== 48) {
2257
+ break;
2258
+ }
2259
+ message.jstype = reader.int32();
2260
+ continue;
2099
2261
  }
2100
- message.lazy = reader.bool();
2101
- continue;
2102
- }
2103
- case 15: {
2104
- if (tag !== 120) {
2105
- break;
2262
+ case 5: {
2263
+ if (tag !== 40) {
2264
+ break;
2265
+ }
2266
+ message.lazy = reader.bool();
2267
+ continue;
2106
2268
  }
2107
- message.unverifiedLazy = reader.bool();
2108
- continue;
2109
- }
2110
- case 3: {
2111
- if (tag !== 24) {
2112
- break;
2269
+ case 15: {
2270
+ if (tag !== 120) {
2271
+ break;
2272
+ }
2273
+ message.unverifiedLazy = reader.bool();
2274
+ continue;
2113
2275
  }
2114
- message.deprecated = reader.bool();
2115
- continue;
2116
- }
2117
- case 10: {
2118
- if (tag !== 80) {
2119
- break;
2276
+ case 3: {
2277
+ if (tag !== 24) {
2278
+ break;
2279
+ }
2280
+ message.deprecated = reader.bool();
2281
+ continue;
2120
2282
  }
2121
- message.weak = reader.bool();
2122
- continue;
2123
- }
2124
- case 16: {
2125
- if (tag !== 128) {
2126
- break;
2283
+ case 10: {
2284
+ if (tag !== 80) {
2285
+ break;
2286
+ }
2287
+ message.weak = reader.bool();
2288
+ continue;
2127
2289
  }
2128
- message.debugRedact = reader.bool();
2129
- continue;
2130
- }
2131
- case 17: {
2132
- if (tag !== 136) {
2133
- break;
2290
+ case 16: {
2291
+ if (tag !== 128) {
2292
+ break;
2293
+ }
2294
+ message.debugRedact = reader.bool();
2295
+ continue;
2134
2296
  }
2135
- message.retention = reader.int32();
2136
- continue;
2137
- }
2138
- case 19: {
2139
- if (tag === 152) {
2140
- message.targets.push(reader.int32());
2297
+ case 17: {
2298
+ if (tag !== 136) {
2299
+ break;
2300
+ }
2301
+ message.retention = reader.int32();
2141
2302
  continue;
2142
2303
  }
2143
- if (tag === 154) {
2144
- const end2 = reader.uint32() + reader.pos;
2145
- while (reader.pos < end2) {
2304
+ case 19: {
2305
+ if (tag === 152) {
2146
2306
  message.targets.push(reader.int32());
2307
+ continue;
2147
2308
  }
2309
+ if (tag === 154) {
2310
+ const end2 = reader.uint32() + reader.pos;
2311
+ while (reader.pos < end2) {
2312
+ message.targets.push(reader.int32());
2313
+ }
2314
+ continue;
2315
+ }
2316
+ break;
2317
+ }
2318
+ case 20: {
2319
+ if (tag !== 162) {
2320
+ break;
2321
+ }
2322
+ message.editionDefaults.push(exports.FieldOptions_EditionDefault.decode(reader, reader.uint32()));
2148
2323
  continue;
2149
2324
  }
2150
- break;
2151
- }
2152
- case 20: {
2153
- if (tag !== 162) {
2154
- break;
2325
+ case 21: {
2326
+ if (tag !== 170) {
2327
+ break;
2328
+ }
2329
+ message.features = exports.FeatureSet.decode(reader, reader.uint32());
2330
+ continue;
2155
2331
  }
2156
- message.editionDefaults.push(exports.FieldOptions_EditionDefault.decode(reader, reader.uint32()));
2157
- continue;
2158
- }
2159
- case 21: {
2160
- if (tag !== 170) {
2161
- break;
2332
+ case 22: {
2333
+ if (tag !== 178) {
2334
+ break;
2335
+ }
2336
+ message.featureSupport = exports.FieldOptions_FeatureSupport.decode(reader, reader.uint32());
2337
+ continue;
2162
2338
  }
2163
- message.features = exports.FeatureSet.decode(reader, reader.uint32());
2164
- continue;
2165
- }
2166
- case 22: {
2167
- if (tag !== 178) {
2168
- break;
2339
+ case 999: {
2340
+ if (tag !== 7994) {
2341
+ break;
2342
+ }
2343
+ message.uninterpretedOption.push(exports.UninterpretedOption.decode(reader, reader.uint32()));
2344
+ continue;
2169
2345
  }
2170
- message.featureSupport = exports.FieldOptions_FeatureSupport.decode(reader, reader.uint32());
2171
- continue;
2172
2346
  }
2173
- case 999: {
2174
- if (tag !== 7994) {
2175
- break;
2176
- }
2177
- message.uninterpretedOption.push(exports.UninterpretedOption.decode(reader, reader.uint32()));
2178
- continue;
2347
+ if ((tag & 7) === 4 || tag === 0) {
2348
+ break;
2179
2349
  }
2350
+ reader.skip(tag & 7);
2180
2351
  }
2181
- if ((tag & 7) === 4 || tag === 0) {
2182
- break;
2183
- }
2184
- reader.skip(tag & 7);
2352
+ return message;
2353
+ }
2354
+ finally {
2355
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
2185
2356
  }
2186
- return message;
2187
2357
  },
2188
2358
  create(base) {
2189
2359
  return exports.FieldOptions.fromPartial(base ?? {});
@@ -2226,32 +2396,42 @@ exports.FieldOptions_EditionDefault = {
2226
2396
  },
2227
2397
  decode(input, length) {
2228
2398
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
2229
- const end = length === undefined ? reader.len : reader.pos + length;
2230
- const message = createBaseFieldOptions_EditionDefault();
2231
- while (reader.pos < end) {
2232
- const tag = reader.uint32();
2233
- switch (tag >>> 3) {
2234
- case 3: {
2235
- if (tag !== 24) {
2236
- break;
2399
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
2400
+ if (previousRecursionDepth >= 100) {
2401
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
2402
+ }
2403
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
2404
+ try {
2405
+ const end = length === undefined ? reader.len : reader.pos + length;
2406
+ const message = createBaseFieldOptions_EditionDefault();
2407
+ while (reader.pos < end) {
2408
+ const tag = reader.uint32();
2409
+ switch (tag >>> 3) {
2410
+ case 3: {
2411
+ if (tag !== 24) {
2412
+ break;
2413
+ }
2414
+ message.edition = reader.int32();
2415
+ continue;
2237
2416
  }
2238
- message.edition = reader.int32();
2239
- continue;
2240
- }
2241
- case 2: {
2242
- if (tag !== 18) {
2243
- break;
2417
+ case 2: {
2418
+ if (tag !== 18) {
2419
+ break;
2420
+ }
2421
+ message.value = reader.string();
2422
+ continue;
2244
2423
  }
2245
- message.value = reader.string();
2246
- continue;
2247
2424
  }
2425
+ if ((tag & 7) === 4 || tag === 0) {
2426
+ break;
2427
+ }
2428
+ reader.skip(tag & 7);
2248
2429
  }
2249
- if ((tag & 7) === 4 || tag === 0) {
2250
- break;
2251
- }
2252
- reader.skip(tag & 7);
2430
+ return message;
2431
+ }
2432
+ finally {
2433
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
2253
2434
  }
2254
- return message;
2255
2435
  },
2256
2436
  create(base) {
2257
2437
  return exports.FieldOptions_EditionDefault.fromPartial(base ?? {});
@@ -2284,46 +2464,56 @@ exports.FieldOptions_FeatureSupport = {
2284
2464
  },
2285
2465
  decode(input, length) {
2286
2466
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
2287
- const end = length === undefined ? reader.len : reader.pos + length;
2288
- const message = createBaseFieldOptions_FeatureSupport();
2289
- while (reader.pos < end) {
2290
- const tag = reader.uint32();
2291
- switch (tag >>> 3) {
2292
- case 1: {
2293
- if (tag !== 8) {
2294
- break;
2467
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
2468
+ if (previousRecursionDepth >= 100) {
2469
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
2470
+ }
2471
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
2472
+ try {
2473
+ const end = length === undefined ? reader.len : reader.pos + length;
2474
+ const message = createBaseFieldOptions_FeatureSupport();
2475
+ while (reader.pos < end) {
2476
+ const tag = reader.uint32();
2477
+ switch (tag >>> 3) {
2478
+ case 1: {
2479
+ if (tag !== 8) {
2480
+ break;
2481
+ }
2482
+ message.editionIntroduced = reader.int32();
2483
+ continue;
2295
2484
  }
2296
- message.editionIntroduced = reader.int32();
2297
- continue;
2298
- }
2299
- case 2: {
2300
- if (tag !== 16) {
2301
- break;
2485
+ case 2: {
2486
+ if (tag !== 16) {
2487
+ break;
2488
+ }
2489
+ message.editionDeprecated = reader.int32();
2490
+ continue;
2302
2491
  }
2303
- message.editionDeprecated = reader.int32();
2304
- continue;
2305
- }
2306
- case 3: {
2307
- if (tag !== 26) {
2308
- break;
2492
+ case 3: {
2493
+ if (tag !== 26) {
2494
+ break;
2495
+ }
2496
+ message.deprecationWarning = reader.string();
2497
+ continue;
2309
2498
  }
2310
- message.deprecationWarning = reader.string();
2311
- continue;
2312
- }
2313
- case 4: {
2314
- if (tag !== 32) {
2315
- break;
2499
+ case 4: {
2500
+ if (tag !== 32) {
2501
+ break;
2502
+ }
2503
+ message.editionRemoved = reader.int32();
2504
+ continue;
2316
2505
  }
2317
- message.editionRemoved = reader.int32();
2318
- continue;
2319
2506
  }
2507
+ if ((tag & 7) === 4 || tag === 0) {
2508
+ break;
2509
+ }
2510
+ reader.skip(tag & 7);
2320
2511
  }
2321
- if ((tag & 7) === 4 || tag === 0) {
2322
- break;
2323
- }
2324
- reader.skip(tag & 7);
2512
+ return message;
2513
+ }
2514
+ finally {
2515
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
2325
2516
  }
2326
- return message;
2327
2517
  },
2328
2518
  create(base) {
2329
2519
  return exports.FieldOptions_FeatureSupport.fromPartial(base ?? {});
@@ -2352,32 +2542,42 @@ exports.OneofOptions = {
2352
2542
  },
2353
2543
  decode(input, length) {
2354
2544
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
2355
- const end = length === undefined ? reader.len : reader.pos + length;
2356
- const message = createBaseOneofOptions();
2357
- while (reader.pos < end) {
2358
- const tag = reader.uint32();
2359
- switch (tag >>> 3) {
2360
- case 1: {
2361
- if (tag !== 10) {
2362
- break;
2545
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
2546
+ if (previousRecursionDepth >= 100) {
2547
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
2548
+ }
2549
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
2550
+ try {
2551
+ const end = length === undefined ? reader.len : reader.pos + length;
2552
+ const message = createBaseOneofOptions();
2553
+ while (reader.pos < end) {
2554
+ const tag = reader.uint32();
2555
+ switch (tag >>> 3) {
2556
+ case 1: {
2557
+ if (tag !== 10) {
2558
+ break;
2559
+ }
2560
+ message.features = exports.FeatureSet.decode(reader, reader.uint32());
2561
+ continue;
2363
2562
  }
2364
- message.features = exports.FeatureSet.decode(reader, reader.uint32());
2365
- continue;
2366
- }
2367
- case 999: {
2368
- if (tag !== 7994) {
2369
- break;
2563
+ case 999: {
2564
+ if (tag !== 7994) {
2565
+ break;
2566
+ }
2567
+ message.uninterpretedOption.push(exports.UninterpretedOption.decode(reader, reader.uint32()));
2568
+ continue;
2370
2569
  }
2371
- message.uninterpretedOption.push(exports.UninterpretedOption.decode(reader, reader.uint32()));
2372
- continue;
2373
2570
  }
2571
+ if ((tag & 7) === 4 || tag === 0) {
2572
+ break;
2573
+ }
2574
+ reader.skip(tag & 7);
2374
2575
  }
2375
- if ((tag & 7) === 4 || tag === 0) {
2376
- break;
2377
- }
2378
- reader.skip(tag & 7);
2576
+ return message;
2577
+ }
2578
+ finally {
2579
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
2379
2580
  }
2380
- return message;
2381
2581
  },
2382
2582
  create(base) {
2383
2583
  return exports.OneofOptions.fromPartial(base ?? {});
@@ -2421,53 +2621,63 @@ exports.EnumOptions = {
2421
2621
  },
2422
2622
  decode(input, length) {
2423
2623
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
2424
- const end = length === undefined ? reader.len : reader.pos + length;
2425
- const message = createBaseEnumOptions();
2426
- while (reader.pos < end) {
2427
- const tag = reader.uint32();
2428
- switch (tag >>> 3) {
2429
- case 2: {
2430
- if (tag !== 16) {
2431
- break;
2624
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
2625
+ if (previousRecursionDepth >= 100) {
2626
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
2627
+ }
2628
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
2629
+ try {
2630
+ const end = length === undefined ? reader.len : reader.pos + length;
2631
+ const message = createBaseEnumOptions();
2632
+ while (reader.pos < end) {
2633
+ const tag = reader.uint32();
2634
+ switch (tag >>> 3) {
2635
+ case 2: {
2636
+ if (tag !== 16) {
2637
+ break;
2638
+ }
2639
+ message.allowAlias = reader.bool();
2640
+ continue;
2432
2641
  }
2433
- message.allowAlias = reader.bool();
2434
- continue;
2435
- }
2436
- case 3: {
2437
- if (tag !== 24) {
2438
- break;
2642
+ case 3: {
2643
+ if (tag !== 24) {
2644
+ break;
2645
+ }
2646
+ message.deprecated = reader.bool();
2647
+ continue;
2439
2648
  }
2440
- message.deprecated = reader.bool();
2441
- continue;
2442
- }
2443
- case 6: {
2444
- if (tag !== 48) {
2445
- break;
2649
+ case 6: {
2650
+ if (tag !== 48) {
2651
+ break;
2652
+ }
2653
+ message.deprecatedLegacyJsonFieldConflicts = reader.bool();
2654
+ continue;
2446
2655
  }
2447
- message.deprecatedLegacyJsonFieldConflicts = reader.bool();
2448
- continue;
2449
- }
2450
- case 7: {
2451
- if (tag !== 58) {
2452
- break;
2656
+ case 7: {
2657
+ if (tag !== 58) {
2658
+ break;
2659
+ }
2660
+ message.features = exports.FeatureSet.decode(reader, reader.uint32());
2661
+ continue;
2453
2662
  }
2454
- message.features = exports.FeatureSet.decode(reader, reader.uint32());
2455
- continue;
2456
- }
2457
- case 999: {
2458
- if (tag !== 7994) {
2459
- break;
2663
+ case 999: {
2664
+ if (tag !== 7994) {
2665
+ break;
2666
+ }
2667
+ message.uninterpretedOption.push(exports.UninterpretedOption.decode(reader, reader.uint32()));
2668
+ continue;
2460
2669
  }
2461
- message.uninterpretedOption.push(exports.UninterpretedOption.decode(reader, reader.uint32()));
2462
- continue;
2463
2670
  }
2671
+ if ((tag & 7) === 4 || tag === 0) {
2672
+ break;
2673
+ }
2674
+ reader.skip(tag & 7);
2464
2675
  }
2465
- if ((tag & 7) === 4 || tag === 0) {
2466
- break;
2467
- }
2468
- reader.skip(tag & 7);
2676
+ return message;
2677
+ }
2678
+ finally {
2679
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
2469
2680
  }
2470
- return message;
2471
2681
  },
2472
2682
  create(base) {
2473
2683
  return exports.EnumOptions.fromPartial(base ?? {});
@@ -2514,53 +2724,63 @@ exports.EnumValueOptions = {
2514
2724
  },
2515
2725
  decode(input, length) {
2516
2726
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
2517
- const end = length === undefined ? reader.len : reader.pos + length;
2518
- const message = createBaseEnumValueOptions();
2519
- while (reader.pos < end) {
2520
- const tag = reader.uint32();
2521
- switch (tag >>> 3) {
2522
- case 1: {
2523
- if (tag !== 8) {
2524
- break;
2727
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
2728
+ if (previousRecursionDepth >= 100) {
2729
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
2730
+ }
2731
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
2732
+ try {
2733
+ const end = length === undefined ? reader.len : reader.pos + length;
2734
+ const message = createBaseEnumValueOptions();
2735
+ while (reader.pos < end) {
2736
+ const tag = reader.uint32();
2737
+ switch (tag >>> 3) {
2738
+ case 1: {
2739
+ if (tag !== 8) {
2740
+ break;
2741
+ }
2742
+ message.deprecated = reader.bool();
2743
+ continue;
2525
2744
  }
2526
- message.deprecated = reader.bool();
2527
- continue;
2528
- }
2529
- case 2: {
2530
- if (tag !== 18) {
2531
- break;
2745
+ case 2: {
2746
+ if (tag !== 18) {
2747
+ break;
2748
+ }
2749
+ message.features = exports.FeatureSet.decode(reader, reader.uint32());
2750
+ continue;
2532
2751
  }
2533
- message.features = exports.FeatureSet.decode(reader, reader.uint32());
2534
- continue;
2535
- }
2536
- case 3: {
2537
- if (tag !== 24) {
2538
- break;
2752
+ case 3: {
2753
+ if (tag !== 24) {
2754
+ break;
2755
+ }
2756
+ message.debugRedact = reader.bool();
2757
+ continue;
2539
2758
  }
2540
- message.debugRedact = reader.bool();
2541
- continue;
2542
- }
2543
- case 4: {
2544
- if (tag !== 34) {
2545
- break;
2759
+ case 4: {
2760
+ if (tag !== 34) {
2761
+ break;
2762
+ }
2763
+ message.featureSupport = exports.FieldOptions_FeatureSupport.decode(reader, reader.uint32());
2764
+ continue;
2546
2765
  }
2547
- message.featureSupport = exports.FieldOptions_FeatureSupport.decode(reader, reader.uint32());
2548
- continue;
2549
- }
2550
- case 999: {
2551
- if (tag !== 7994) {
2552
- break;
2766
+ case 999: {
2767
+ if (tag !== 7994) {
2768
+ break;
2769
+ }
2770
+ message.uninterpretedOption.push(exports.UninterpretedOption.decode(reader, reader.uint32()));
2771
+ continue;
2553
2772
  }
2554
- message.uninterpretedOption.push(exports.UninterpretedOption.decode(reader, reader.uint32()));
2555
- continue;
2556
2773
  }
2774
+ if ((tag & 7) === 4 || tag === 0) {
2775
+ break;
2776
+ }
2777
+ reader.skip(tag & 7);
2557
2778
  }
2558
- if ((tag & 7) === 4 || tag === 0) {
2559
- break;
2560
- }
2561
- reader.skip(tag & 7);
2779
+ return message;
2780
+ }
2781
+ finally {
2782
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
2562
2783
  }
2563
- return message;
2564
2784
  },
2565
2785
  create(base) {
2566
2786
  return exports.EnumValueOptions.fromPartial(base ?? {});
@@ -2597,39 +2817,49 @@ exports.ServiceOptions = {
2597
2817
  },
2598
2818
  decode(input, length) {
2599
2819
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
2600
- const end = length === undefined ? reader.len : reader.pos + length;
2601
- const message = createBaseServiceOptions();
2602
- while (reader.pos < end) {
2603
- const tag = reader.uint32();
2604
- switch (tag >>> 3) {
2605
- case 34: {
2606
- if (tag !== 274) {
2607
- break;
2820
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
2821
+ if (previousRecursionDepth >= 100) {
2822
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
2823
+ }
2824
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
2825
+ try {
2826
+ const end = length === undefined ? reader.len : reader.pos + length;
2827
+ const message = createBaseServiceOptions();
2828
+ while (reader.pos < end) {
2829
+ const tag = reader.uint32();
2830
+ switch (tag >>> 3) {
2831
+ case 34: {
2832
+ if (tag !== 274) {
2833
+ break;
2834
+ }
2835
+ message.features = exports.FeatureSet.decode(reader, reader.uint32());
2836
+ continue;
2608
2837
  }
2609
- message.features = exports.FeatureSet.decode(reader, reader.uint32());
2610
- continue;
2611
- }
2612
- case 33: {
2613
- if (tag !== 264) {
2614
- break;
2838
+ case 33: {
2839
+ if (tag !== 264) {
2840
+ break;
2841
+ }
2842
+ message.deprecated = reader.bool();
2843
+ continue;
2615
2844
  }
2616
- message.deprecated = reader.bool();
2617
- continue;
2618
- }
2619
- case 999: {
2620
- if (tag !== 7994) {
2621
- break;
2845
+ case 999: {
2846
+ if (tag !== 7994) {
2847
+ break;
2848
+ }
2849
+ message.uninterpretedOption.push(exports.UninterpretedOption.decode(reader, reader.uint32()));
2850
+ continue;
2622
2851
  }
2623
- message.uninterpretedOption.push(exports.UninterpretedOption.decode(reader, reader.uint32()));
2624
- continue;
2625
2852
  }
2853
+ if ((tag & 7) === 4 || tag === 0) {
2854
+ break;
2855
+ }
2856
+ reader.skip(tag & 7);
2626
2857
  }
2627
- if ((tag & 7) === 4 || tag === 0) {
2628
- break;
2629
- }
2630
- reader.skip(tag & 7);
2858
+ return message;
2859
+ }
2860
+ finally {
2861
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
2631
2862
  }
2632
- return message;
2633
2863
  },
2634
2864
  create(base) {
2635
2865
  return exports.ServiceOptions.fromPartial(base ?? {});
@@ -2665,46 +2895,56 @@ exports.MethodOptions = {
2665
2895
  },
2666
2896
  decode(input, length) {
2667
2897
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
2668
- const end = length === undefined ? reader.len : reader.pos + length;
2669
- const message = createBaseMethodOptions();
2670
- while (reader.pos < end) {
2671
- const tag = reader.uint32();
2672
- switch (tag >>> 3) {
2673
- case 33: {
2674
- if (tag !== 264) {
2675
- break;
2898
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
2899
+ if (previousRecursionDepth >= 100) {
2900
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
2901
+ }
2902
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
2903
+ try {
2904
+ const end = length === undefined ? reader.len : reader.pos + length;
2905
+ const message = createBaseMethodOptions();
2906
+ while (reader.pos < end) {
2907
+ const tag = reader.uint32();
2908
+ switch (tag >>> 3) {
2909
+ case 33: {
2910
+ if (tag !== 264) {
2911
+ break;
2912
+ }
2913
+ message.deprecated = reader.bool();
2914
+ continue;
2676
2915
  }
2677
- message.deprecated = reader.bool();
2678
- continue;
2679
- }
2680
- case 34: {
2681
- if (tag !== 272) {
2682
- break;
2916
+ case 34: {
2917
+ if (tag !== 272) {
2918
+ break;
2919
+ }
2920
+ message.idempotencyLevel = reader.int32();
2921
+ continue;
2683
2922
  }
2684
- message.idempotencyLevel = reader.int32();
2685
- continue;
2686
- }
2687
- case 35: {
2688
- if (tag !== 282) {
2689
- break;
2923
+ case 35: {
2924
+ if (tag !== 282) {
2925
+ break;
2926
+ }
2927
+ message.features = exports.FeatureSet.decode(reader, reader.uint32());
2928
+ continue;
2690
2929
  }
2691
- message.features = exports.FeatureSet.decode(reader, reader.uint32());
2692
- continue;
2693
- }
2694
- case 999: {
2695
- if (tag !== 7994) {
2696
- break;
2930
+ case 999: {
2931
+ if (tag !== 7994) {
2932
+ break;
2933
+ }
2934
+ message.uninterpretedOption.push(exports.UninterpretedOption.decode(reader, reader.uint32()));
2935
+ continue;
2697
2936
  }
2698
- message.uninterpretedOption.push(exports.UninterpretedOption.decode(reader, reader.uint32()));
2699
- continue;
2700
2937
  }
2938
+ if ((tag & 7) === 4 || tag === 0) {
2939
+ break;
2940
+ }
2941
+ reader.skip(tag & 7);
2701
2942
  }
2702
- if ((tag & 7) === 4 || tag === 0) {
2703
- break;
2704
- }
2705
- reader.skip(tag & 7);
2943
+ return message;
2944
+ }
2945
+ finally {
2946
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
2706
2947
  }
2707
- return message;
2708
2948
  },
2709
2949
  create(base) {
2710
2950
  return exports.MethodOptions.fromPartial(base ?? {});
@@ -2764,67 +3004,77 @@ exports.UninterpretedOption = {
2764
3004
  },
2765
3005
  decode(input, length) {
2766
3006
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
2767
- const end = length === undefined ? reader.len : reader.pos + length;
2768
- const message = createBaseUninterpretedOption();
2769
- while (reader.pos < end) {
2770
- const tag = reader.uint32();
2771
- switch (tag >>> 3) {
2772
- case 2: {
2773
- if (tag !== 18) {
2774
- break;
3007
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
3008
+ if (previousRecursionDepth >= 100) {
3009
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
3010
+ }
3011
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
3012
+ try {
3013
+ const end = length === undefined ? reader.len : reader.pos + length;
3014
+ const message = createBaseUninterpretedOption();
3015
+ while (reader.pos < end) {
3016
+ const tag = reader.uint32();
3017
+ switch (tag >>> 3) {
3018
+ case 2: {
3019
+ if (tag !== 18) {
3020
+ break;
3021
+ }
3022
+ message.name.push(exports.UninterpretedOption_NamePart.decode(reader, reader.uint32()));
3023
+ continue;
2775
3024
  }
2776
- message.name.push(exports.UninterpretedOption_NamePart.decode(reader, reader.uint32()));
2777
- continue;
2778
- }
2779
- case 3: {
2780
- if (tag !== 26) {
2781
- break;
3025
+ case 3: {
3026
+ if (tag !== 26) {
3027
+ break;
3028
+ }
3029
+ message.identifierValue = reader.string();
3030
+ continue;
2782
3031
  }
2783
- message.identifierValue = reader.string();
2784
- continue;
2785
- }
2786
- case 4: {
2787
- if (tag !== 32) {
2788
- break;
3032
+ case 4: {
3033
+ if (tag !== 32) {
3034
+ break;
3035
+ }
3036
+ message.positiveIntValue = reader.uint64();
3037
+ continue;
2789
3038
  }
2790
- message.positiveIntValue = reader.uint64();
2791
- continue;
2792
- }
2793
- case 5: {
2794
- if (tag !== 40) {
2795
- break;
3039
+ case 5: {
3040
+ if (tag !== 40) {
3041
+ break;
3042
+ }
3043
+ message.negativeIntValue = reader.int64();
3044
+ continue;
2796
3045
  }
2797
- message.negativeIntValue = reader.int64();
2798
- continue;
2799
- }
2800
- case 6: {
2801
- if (tag !== 49) {
2802
- break;
3046
+ case 6: {
3047
+ if (tag !== 49) {
3048
+ break;
3049
+ }
3050
+ message.doubleValue = reader.double();
3051
+ continue;
2803
3052
  }
2804
- message.doubleValue = reader.double();
2805
- continue;
2806
- }
2807
- case 7: {
2808
- if (tag !== 58) {
2809
- break;
3053
+ case 7: {
3054
+ if (tag !== 58) {
3055
+ break;
3056
+ }
3057
+ message.stringValue = reader.bytes();
3058
+ continue;
2810
3059
  }
2811
- message.stringValue = reader.bytes();
2812
- continue;
2813
- }
2814
- case 8: {
2815
- if (tag !== 66) {
2816
- break;
3060
+ case 8: {
3061
+ if (tag !== 66) {
3062
+ break;
3063
+ }
3064
+ message.aggregateValue = reader.string();
3065
+ continue;
2817
3066
  }
2818
- message.aggregateValue = reader.string();
2819
- continue;
2820
3067
  }
3068
+ if ((tag & 7) === 4 || tag === 0) {
3069
+ break;
3070
+ }
3071
+ reader.skip(tag & 7);
2821
3072
  }
2822
- if ((tag & 7) === 4 || tag === 0) {
2823
- break;
2824
- }
2825
- reader.skip(tag & 7);
3073
+ return message;
3074
+ }
3075
+ finally {
3076
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
2826
3077
  }
2827
- return message;
2828
3078
  },
2829
3079
  create(base) {
2830
3080
  return exports.UninterpretedOption.fromPartial(base ?? {});
@@ -2860,32 +3110,42 @@ exports.UninterpretedOption_NamePart = {
2860
3110
  },
2861
3111
  decode(input, length) {
2862
3112
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
2863
- const end = length === undefined ? reader.len : reader.pos + length;
2864
- const message = createBaseUninterpretedOption_NamePart();
2865
- while (reader.pos < end) {
2866
- const tag = reader.uint32();
2867
- switch (tag >>> 3) {
2868
- case 1: {
2869
- if (tag !== 10) {
2870
- break;
3113
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
3114
+ if (previousRecursionDepth >= 100) {
3115
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
3116
+ }
3117
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
3118
+ try {
3119
+ const end = length === undefined ? reader.len : reader.pos + length;
3120
+ const message = createBaseUninterpretedOption_NamePart();
3121
+ while (reader.pos < end) {
3122
+ const tag = reader.uint32();
3123
+ switch (tag >>> 3) {
3124
+ case 1: {
3125
+ if (tag !== 10) {
3126
+ break;
3127
+ }
3128
+ message.namePart = reader.string();
3129
+ continue;
2871
3130
  }
2872
- message.namePart = reader.string();
2873
- continue;
2874
- }
2875
- case 2: {
2876
- if (tag !== 16) {
2877
- break;
3131
+ case 2: {
3132
+ if (tag !== 16) {
3133
+ break;
3134
+ }
3135
+ message.isExtension = reader.bool();
3136
+ continue;
2878
3137
  }
2879
- message.isExtension = reader.bool();
2880
- continue;
2881
3138
  }
3139
+ if ((tag & 7) === 4 || tag === 0) {
3140
+ break;
3141
+ }
3142
+ reader.skip(tag & 7);
2882
3143
  }
2883
- if ((tag & 7) === 4 || tag === 0) {
2884
- break;
2885
- }
2886
- reader.skip(tag & 7);
3144
+ return message;
3145
+ }
3146
+ finally {
3147
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
2887
3148
  }
2888
- return message;
2889
3149
  },
2890
3150
  create(base) {
2891
3151
  return exports.UninterpretedOption_NamePart.fromPartial(base ?? {});
@@ -2939,74 +3199,84 @@ exports.FeatureSet = {
2939
3199
  },
2940
3200
  decode(input, length) {
2941
3201
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
2942
- const end = length === undefined ? reader.len : reader.pos + length;
2943
- const message = createBaseFeatureSet();
2944
- while (reader.pos < end) {
2945
- const tag = reader.uint32();
2946
- switch (tag >>> 3) {
2947
- case 1: {
2948
- if (tag !== 8) {
2949
- break;
3202
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
3203
+ if (previousRecursionDepth >= 100) {
3204
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
3205
+ }
3206
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
3207
+ try {
3208
+ const end = length === undefined ? reader.len : reader.pos + length;
3209
+ const message = createBaseFeatureSet();
3210
+ while (reader.pos < end) {
3211
+ const tag = reader.uint32();
3212
+ switch (tag >>> 3) {
3213
+ case 1: {
3214
+ if (tag !== 8) {
3215
+ break;
3216
+ }
3217
+ message.fieldPresence = reader.int32();
3218
+ continue;
2950
3219
  }
2951
- message.fieldPresence = reader.int32();
2952
- continue;
2953
- }
2954
- case 2: {
2955
- if (tag !== 16) {
2956
- break;
3220
+ case 2: {
3221
+ if (tag !== 16) {
3222
+ break;
3223
+ }
3224
+ message.enumType = reader.int32();
3225
+ continue;
2957
3226
  }
2958
- message.enumType = reader.int32();
2959
- continue;
2960
- }
2961
- case 3: {
2962
- if (tag !== 24) {
2963
- break;
3227
+ case 3: {
3228
+ if (tag !== 24) {
3229
+ break;
3230
+ }
3231
+ message.repeatedFieldEncoding = reader.int32();
3232
+ continue;
2964
3233
  }
2965
- message.repeatedFieldEncoding = reader.int32();
2966
- continue;
2967
- }
2968
- case 4: {
2969
- if (tag !== 32) {
2970
- break;
3234
+ case 4: {
3235
+ if (tag !== 32) {
3236
+ break;
3237
+ }
3238
+ message.utf8Validation = reader.int32();
3239
+ continue;
2971
3240
  }
2972
- message.utf8Validation = reader.int32();
2973
- continue;
2974
- }
2975
- case 5: {
2976
- if (tag !== 40) {
2977
- break;
3241
+ case 5: {
3242
+ if (tag !== 40) {
3243
+ break;
3244
+ }
3245
+ message.messageEncoding = reader.int32();
3246
+ continue;
2978
3247
  }
2979
- message.messageEncoding = reader.int32();
2980
- continue;
2981
- }
2982
- case 6: {
2983
- if (tag !== 48) {
2984
- break;
3248
+ case 6: {
3249
+ if (tag !== 48) {
3250
+ break;
3251
+ }
3252
+ message.jsonFormat = reader.int32();
3253
+ continue;
2985
3254
  }
2986
- message.jsonFormat = reader.int32();
2987
- continue;
2988
- }
2989
- case 7: {
2990
- if (tag !== 56) {
2991
- break;
3255
+ case 7: {
3256
+ if (tag !== 56) {
3257
+ break;
3258
+ }
3259
+ message.enforceNamingStyle = reader.int32();
3260
+ continue;
2992
3261
  }
2993
- message.enforceNamingStyle = reader.int32();
2994
- continue;
2995
- }
2996
- case 8: {
2997
- if (tag !== 64) {
2998
- break;
3262
+ case 8: {
3263
+ if (tag !== 64) {
3264
+ break;
3265
+ }
3266
+ message.defaultSymbolVisibility = reader.int32();
3267
+ continue;
2999
3268
  }
3000
- message.defaultSymbolVisibility = reader.int32();
3001
- continue;
3002
3269
  }
3270
+ if ((tag & 7) === 4 || tag === 0) {
3271
+ break;
3272
+ }
3273
+ reader.skip(tag & 7);
3003
3274
  }
3004
- if ((tag & 7) === 4 || tag === 0) {
3005
- break;
3006
- }
3007
- reader.skip(tag & 7);
3275
+ return message;
3276
+ }
3277
+ finally {
3278
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
3008
3279
  }
3009
- return message;
3010
3280
  },
3011
3281
  create(base) {
3012
3282
  return exports.FeatureSet.fromPartial(base ?? {});
@@ -3033,18 +3303,28 @@ exports.FeatureSet_VisibilityFeature = {
3033
3303
  },
3034
3304
  decode(input, length) {
3035
3305
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
3036
- const end = length === undefined ? reader.len : reader.pos + length;
3037
- const message = createBaseFeatureSet_VisibilityFeature();
3038
- while (reader.pos < end) {
3039
- const tag = reader.uint32();
3040
- switch (tag >>> 3) {
3041
- }
3042
- if ((tag & 7) === 4 || tag === 0) {
3043
- break;
3306
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
3307
+ if (previousRecursionDepth >= 100) {
3308
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
3309
+ }
3310
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
3311
+ try {
3312
+ const end = length === undefined ? reader.len : reader.pos + length;
3313
+ const message = createBaseFeatureSet_VisibilityFeature();
3314
+ while (reader.pos < end) {
3315
+ const tag = reader.uint32();
3316
+ switch (tag >>> 3) {
3317
+ }
3318
+ if ((tag & 7) === 4 || tag === 0) {
3319
+ break;
3320
+ }
3321
+ reader.skip(tag & 7);
3044
3322
  }
3045
- reader.skip(tag & 7);
3323
+ return message;
3324
+ }
3325
+ finally {
3326
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
3046
3327
  }
3047
- return message;
3048
3328
  },
3049
3329
  create(base) {
3050
3330
  return exports.FeatureSet_VisibilityFeature.fromPartial(base ?? {});
@@ -3072,39 +3352,49 @@ exports.FeatureSetDefaults = {
3072
3352
  },
3073
3353
  decode(input, length) {
3074
3354
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
3075
- const end = length === undefined ? reader.len : reader.pos + length;
3076
- const message = createBaseFeatureSetDefaults();
3077
- while (reader.pos < end) {
3078
- const tag = reader.uint32();
3079
- switch (tag >>> 3) {
3080
- case 1: {
3081
- if (tag !== 10) {
3082
- break;
3355
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
3356
+ if (previousRecursionDepth >= 100) {
3357
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
3358
+ }
3359
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
3360
+ try {
3361
+ const end = length === undefined ? reader.len : reader.pos + length;
3362
+ const message = createBaseFeatureSetDefaults();
3363
+ while (reader.pos < end) {
3364
+ const tag = reader.uint32();
3365
+ switch (tag >>> 3) {
3366
+ case 1: {
3367
+ if (tag !== 10) {
3368
+ break;
3369
+ }
3370
+ message.defaults.push(exports.FeatureSetDefaults_FeatureSetEditionDefault.decode(reader, reader.uint32()));
3371
+ continue;
3083
3372
  }
3084
- message.defaults.push(exports.FeatureSetDefaults_FeatureSetEditionDefault.decode(reader, reader.uint32()));
3085
- continue;
3086
- }
3087
- case 4: {
3088
- if (tag !== 32) {
3089
- break;
3373
+ case 4: {
3374
+ if (tag !== 32) {
3375
+ break;
3376
+ }
3377
+ message.minimumEdition = reader.int32();
3378
+ continue;
3090
3379
  }
3091
- message.minimumEdition = reader.int32();
3092
- continue;
3093
- }
3094
- case 5: {
3095
- if (tag !== 40) {
3096
- break;
3380
+ case 5: {
3381
+ if (tag !== 40) {
3382
+ break;
3383
+ }
3384
+ message.maximumEdition = reader.int32();
3385
+ continue;
3097
3386
  }
3098
- message.maximumEdition = reader.int32();
3099
- continue;
3100
3387
  }
3388
+ if ((tag & 7) === 4 || tag === 0) {
3389
+ break;
3390
+ }
3391
+ reader.skip(tag & 7);
3101
3392
  }
3102
- if ((tag & 7) === 4 || tag === 0) {
3103
- break;
3104
- }
3105
- reader.skip(tag & 7);
3393
+ return message;
3394
+ }
3395
+ finally {
3396
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
3106
3397
  }
3107
- return message;
3108
3398
  },
3109
3399
  create(base) {
3110
3400
  return exports.FeatureSetDefaults.fromPartial(base ?? {});
@@ -3135,39 +3425,49 @@ exports.FeatureSetDefaults_FeatureSetEditionDefault = {
3135
3425
  },
3136
3426
  decode(input, length) {
3137
3427
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
3138
- const end = length === undefined ? reader.len : reader.pos + length;
3139
- const message = createBaseFeatureSetDefaults_FeatureSetEditionDefault();
3140
- while (reader.pos < end) {
3141
- const tag = reader.uint32();
3142
- switch (tag >>> 3) {
3143
- case 3: {
3144
- if (tag !== 24) {
3145
- break;
3428
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
3429
+ if (previousRecursionDepth >= 100) {
3430
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
3431
+ }
3432
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
3433
+ try {
3434
+ const end = length === undefined ? reader.len : reader.pos + length;
3435
+ const message = createBaseFeatureSetDefaults_FeatureSetEditionDefault();
3436
+ while (reader.pos < end) {
3437
+ const tag = reader.uint32();
3438
+ switch (tag >>> 3) {
3439
+ case 3: {
3440
+ if (tag !== 24) {
3441
+ break;
3442
+ }
3443
+ message.edition = reader.int32();
3444
+ continue;
3146
3445
  }
3147
- message.edition = reader.int32();
3148
- continue;
3149
- }
3150
- case 4: {
3151
- if (tag !== 34) {
3152
- break;
3446
+ case 4: {
3447
+ if (tag !== 34) {
3448
+ break;
3449
+ }
3450
+ message.overridableFeatures = exports.FeatureSet.decode(reader, reader.uint32());
3451
+ continue;
3153
3452
  }
3154
- message.overridableFeatures = exports.FeatureSet.decode(reader, reader.uint32());
3155
- continue;
3156
- }
3157
- case 5: {
3158
- if (tag !== 42) {
3159
- break;
3453
+ case 5: {
3454
+ if (tag !== 42) {
3455
+ break;
3456
+ }
3457
+ message.fixedFeatures = exports.FeatureSet.decode(reader, reader.uint32());
3458
+ continue;
3160
3459
  }
3161
- message.fixedFeatures = exports.FeatureSet.decode(reader, reader.uint32());
3162
- continue;
3163
3460
  }
3461
+ if ((tag & 7) === 4 || tag === 0) {
3462
+ break;
3463
+ }
3464
+ reader.skip(tag & 7);
3164
3465
  }
3165
- if ((tag & 7) === 4 || tag === 0) {
3166
- break;
3167
- }
3168
- reader.skip(tag & 7);
3466
+ return message;
3467
+ }
3468
+ finally {
3469
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
3169
3470
  }
3170
- return message;
3171
3471
  },
3172
3472
  create(base) {
3173
3473
  return exports.FeatureSetDefaults_FeatureSetEditionDefault.fromPartial(base ?? {});
@@ -3196,25 +3496,35 @@ exports.SourceCodeInfo = {
3196
3496
  },
3197
3497
  decode(input, length) {
3198
3498
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
3199
- const end = length === undefined ? reader.len : reader.pos + length;
3200
- const message = createBaseSourceCodeInfo();
3201
- while (reader.pos < end) {
3202
- const tag = reader.uint32();
3203
- switch (tag >>> 3) {
3204
- case 1: {
3205
- if (tag !== 10) {
3206
- break;
3499
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
3500
+ if (previousRecursionDepth >= 100) {
3501
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
3502
+ }
3503
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
3504
+ try {
3505
+ const end = length === undefined ? reader.len : reader.pos + length;
3506
+ const message = createBaseSourceCodeInfo();
3507
+ while (reader.pos < end) {
3508
+ const tag = reader.uint32();
3509
+ switch (tag >>> 3) {
3510
+ case 1: {
3511
+ if (tag !== 10) {
3512
+ break;
3513
+ }
3514
+ message.location.push(exports.SourceCodeInfo_Location.decode(reader, reader.uint32()));
3515
+ continue;
3207
3516
  }
3208
- message.location.push(exports.SourceCodeInfo_Location.decode(reader, reader.uint32()));
3209
- continue;
3210
3517
  }
3518
+ if ((tag & 7) === 4 || tag === 0) {
3519
+ break;
3520
+ }
3521
+ reader.skip(tag & 7);
3211
3522
  }
3212
- if ((tag & 7) === 4 || tag === 0) {
3213
- break;
3214
- }
3215
- reader.skip(tag & 7);
3523
+ return message;
3524
+ }
3525
+ finally {
3526
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
3216
3527
  }
3217
- return message;
3218
3528
  },
3219
3529
  create(base) {
3220
3530
  return exports.SourceCodeInfo.fromPartial(base ?? {});
@@ -3253,67 +3563,77 @@ exports.SourceCodeInfo_Location = {
3253
3563
  },
3254
3564
  decode(input, length) {
3255
3565
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
3256
- const end = length === undefined ? reader.len : reader.pos + length;
3257
- const message = createBaseSourceCodeInfo_Location();
3258
- while (reader.pos < end) {
3259
- const tag = reader.uint32();
3260
- switch (tag >>> 3) {
3261
- case 1: {
3262
- if (tag === 8) {
3263
- message.path.push(reader.int32());
3264
- continue;
3265
- }
3266
- if (tag === 10) {
3267
- const end2 = reader.uint32() + reader.pos;
3268
- while (reader.pos < end2) {
3566
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
3567
+ if (previousRecursionDepth >= 100) {
3568
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
3569
+ }
3570
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
3571
+ try {
3572
+ const end = length === undefined ? reader.len : reader.pos + length;
3573
+ const message = createBaseSourceCodeInfo_Location();
3574
+ while (reader.pos < end) {
3575
+ const tag = reader.uint32();
3576
+ switch (tag >>> 3) {
3577
+ case 1: {
3578
+ if (tag === 8) {
3269
3579
  message.path.push(reader.int32());
3580
+ continue;
3270
3581
  }
3271
- continue;
3272
- }
3273
- break;
3274
- }
3275
- case 2: {
3276
- if (tag === 16) {
3277
- message.span.push(reader.int32());
3278
- continue;
3582
+ if (tag === 10) {
3583
+ const end2 = reader.uint32() + reader.pos;
3584
+ while (reader.pos < end2) {
3585
+ message.path.push(reader.int32());
3586
+ }
3587
+ continue;
3588
+ }
3589
+ break;
3279
3590
  }
3280
- if (tag === 18) {
3281
- const end2 = reader.uint32() + reader.pos;
3282
- while (reader.pos < end2) {
3591
+ case 2: {
3592
+ if (tag === 16) {
3283
3593
  message.span.push(reader.int32());
3594
+ continue;
3595
+ }
3596
+ if (tag === 18) {
3597
+ const end2 = reader.uint32() + reader.pos;
3598
+ while (reader.pos < end2) {
3599
+ message.span.push(reader.int32());
3600
+ }
3601
+ continue;
3602
+ }
3603
+ break;
3604
+ }
3605
+ case 3: {
3606
+ if (tag !== 26) {
3607
+ break;
3284
3608
  }
3609
+ message.leadingComments = reader.string();
3285
3610
  continue;
3286
3611
  }
3287
- break;
3288
- }
3289
- case 3: {
3290
- if (tag !== 26) {
3291
- break;
3612
+ case 4: {
3613
+ if (tag !== 34) {
3614
+ break;
3615
+ }
3616
+ message.trailingComments = reader.string();
3617
+ continue;
3292
3618
  }
3293
- message.leadingComments = reader.string();
3294
- continue;
3295
- }
3296
- case 4: {
3297
- if (tag !== 34) {
3298
- break;
3619
+ case 6: {
3620
+ if (tag !== 50) {
3621
+ break;
3622
+ }
3623
+ message.leadingDetachedComments.push(reader.string());
3624
+ continue;
3299
3625
  }
3300
- message.trailingComments = reader.string();
3301
- continue;
3302
3626
  }
3303
- case 6: {
3304
- if (tag !== 50) {
3305
- break;
3306
- }
3307
- message.leadingDetachedComments.push(reader.string());
3308
- continue;
3627
+ if ((tag & 7) === 4 || tag === 0) {
3628
+ break;
3309
3629
  }
3630
+ reader.skip(tag & 7);
3310
3631
  }
3311
- if ((tag & 7) === 4 || tag === 0) {
3312
- break;
3313
- }
3314
- reader.skip(tag & 7);
3632
+ return message;
3633
+ }
3634
+ finally {
3635
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
3315
3636
  }
3316
- return message;
3317
3637
  },
3318
3638
  create(base) {
3319
3639
  return exports.SourceCodeInfo_Location.fromPartial(base ?? {});
@@ -3340,25 +3660,35 @@ exports.GeneratedCodeInfo = {
3340
3660
  },
3341
3661
  decode(input, length) {
3342
3662
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
3343
- const end = length === undefined ? reader.len : reader.pos + length;
3344
- const message = createBaseGeneratedCodeInfo();
3345
- while (reader.pos < end) {
3346
- const tag = reader.uint32();
3347
- switch (tag >>> 3) {
3348
- case 1: {
3349
- if (tag !== 10) {
3350
- break;
3663
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
3664
+ if (previousRecursionDepth >= 100) {
3665
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
3666
+ }
3667
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
3668
+ try {
3669
+ const end = length === undefined ? reader.len : reader.pos + length;
3670
+ const message = createBaseGeneratedCodeInfo();
3671
+ while (reader.pos < end) {
3672
+ const tag = reader.uint32();
3673
+ switch (tag >>> 3) {
3674
+ case 1: {
3675
+ if (tag !== 10) {
3676
+ break;
3677
+ }
3678
+ message.annotation.push(exports.GeneratedCodeInfo_Annotation.decode(reader, reader.uint32()));
3679
+ continue;
3351
3680
  }
3352
- message.annotation.push(exports.GeneratedCodeInfo_Annotation.decode(reader, reader.uint32()));
3353
- continue;
3354
3681
  }
3682
+ if ((tag & 7) === 4 || tag === 0) {
3683
+ break;
3684
+ }
3685
+ reader.skip(tag & 7);
3355
3686
  }
3356
- if ((tag & 7) === 4 || tag === 0) {
3357
- break;
3358
- }
3359
- reader.skip(tag & 7);
3687
+ return message;
3688
+ }
3689
+ finally {
3690
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
3360
3691
  }
3361
- return message;
3362
3692
  },
3363
3693
  create(base) {
3364
3694
  return exports.GeneratedCodeInfo.fromPartial(base ?? {});
@@ -3395,60 +3725,70 @@ exports.GeneratedCodeInfo_Annotation = {
3395
3725
  },
3396
3726
  decode(input, length) {
3397
3727
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
3398
- const end = length === undefined ? reader.len : reader.pos + length;
3399
- const message = createBaseGeneratedCodeInfo_Annotation();
3400
- while (reader.pos < end) {
3401
- const tag = reader.uint32();
3402
- switch (tag >>> 3) {
3403
- case 1: {
3404
- if (tag === 8) {
3405
- message.path.push(reader.int32());
3406
- continue;
3407
- }
3408
- if (tag === 10) {
3409
- const end2 = reader.uint32() + reader.pos;
3410
- while (reader.pos < end2) {
3728
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
3729
+ if (previousRecursionDepth >= 100) {
3730
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
3731
+ }
3732
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
3733
+ try {
3734
+ const end = length === undefined ? reader.len : reader.pos + length;
3735
+ const message = createBaseGeneratedCodeInfo_Annotation();
3736
+ while (reader.pos < end) {
3737
+ const tag = reader.uint32();
3738
+ switch (tag >>> 3) {
3739
+ case 1: {
3740
+ if (tag === 8) {
3411
3741
  message.path.push(reader.int32());
3742
+ continue;
3743
+ }
3744
+ if (tag === 10) {
3745
+ const end2 = reader.uint32() + reader.pos;
3746
+ while (reader.pos < end2) {
3747
+ message.path.push(reader.int32());
3748
+ }
3749
+ continue;
3750
+ }
3751
+ break;
3752
+ }
3753
+ case 2: {
3754
+ if (tag !== 18) {
3755
+ break;
3412
3756
  }
3757
+ message.sourceFile = reader.string();
3413
3758
  continue;
3414
3759
  }
3415
- break;
3416
- }
3417
- case 2: {
3418
- if (tag !== 18) {
3419
- break;
3760
+ case 3: {
3761
+ if (tag !== 24) {
3762
+ break;
3763
+ }
3764
+ message.begin = reader.int32();
3765
+ continue;
3420
3766
  }
3421
- message.sourceFile = reader.string();
3422
- continue;
3423
- }
3424
- case 3: {
3425
- if (tag !== 24) {
3426
- break;
3767
+ case 4: {
3768
+ if (tag !== 32) {
3769
+ break;
3770
+ }
3771
+ message.end = reader.int32();
3772
+ continue;
3427
3773
  }
3428
- message.begin = reader.int32();
3429
- continue;
3430
- }
3431
- case 4: {
3432
- if (tag !== 32) {
3433
- break;
3774
+ case 5: {
3775
+ if (tag !== 40) {
3776
+ break;
3777
+ }
3778
+ message.semantic = reader.int32();
3779
+ continue;
3434
3780
  }
3435
- message.end = reader.int32();
3436
- continue;
3437
3781
  }
3438
- case 5: {
3439
- if (tag !== 40) {
3440
- break;
3441
- }
3442
- message.semantic = reader.int32();
3443
- continue;
3782
+ if ((tag & 7) === 4 || tag === 0) {
3783
+ break;
3444
3784
  }
3785
+ reader.skip(tag & 7);
3445
3786
  }
3446
- if ((tag & 7) === 4 || tag === 0) {
3447
- break;
3448
- }
3449
- reader.skip(tag & 7);
3787
+ return message;
3788
+ }
3789
+ finally {
3790
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
3450
3791
  }
3451
- return message;
3452
3792
  },
3453
3793
  create(base) {
3454
3794
  return exports.GeneratedCodeInfo_Annotation.fromPartial(base ?? {});