@meshsdk/core-cst 1.9.0-beta.98 → 1.9.0-beta.99

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.
package/dist/index.cjs CHANGED
@@ -2622,1696 +2622,6 @@ var require_blake2b2 = __commonJS({
2622
2622
  }
2623
2623
  });
2624
2624
 
2625
- // ../../node_modules/minimalistic-assert/index.js
2626
- var require_minimalistic_assert = __commonJS({
2627
- "../../node_modules/minimalistic-assert/index.js"(exports2, module2) {
2628
- "use strict";
2629
- module2.exports = assert;
2630
- function assert(val, msg) {
2631
- if (!val)
2632
- throw new Error(msg || "Assertion failed");
2633
- }
2634
- assert.equal = function assertEqual(l, r, msg) {
2635
- if (l != r)
2636
- throw new Error(msg || "Assertion failed: " + l + " != " + r);
2637
- };
2638
- }
2639
- });
2640
-
2641
- // ../../node_modules/inherits/inherits_browser.js
2642
- var require_inherits_browser = __commonJS({
2643
- "../../node_modules/inherits/inherits_browser.js"(exports2, module2) {
2644
- "use strict";
2645
- if (typeof Object.create === "function") {
2646
- module2.exports = function inherits(ctor, superCtor) {
2647
- if (superCtor) {
2648
- ctor.super_ = superCtor;
2649
- ctor.prototype = Object.create(superCtor.prototype, {
2650
- constructor: {
2651
- value: ctor,
2652
- enumerable: false,
2653
- writable: true,
2654
- configurable: true
2655
- }
2656
- });
2657
- }
2658
- };
2659
- } else {
2660
- module2.exports = function inherits(ctor, superCtor) {
2661
- if (superCtor) {
2662
- ctor.super_ = superCtor;
2663
- var TempCtor = function() {
2664
- };
2665
- TempCtor.prototype = superCtor.prototype;
2666
- ctor.prototype = new TempCtor();
2667
- ctor.prototype.constructor = ctor;
2668
- }
2669
- };
2670
- }
2671
- }
2672
- });
2673
-
2674
- // ../../node_modules/inherits/inherits.js
2675
- var require_inherits = __commonJS({
2676
- "../../node_modules/inherits/inherits.js"(exports2, module2) {
2677
- "use strict";
2678
- try {
2679
- util = require("util");
2680
- if (typeof util.inherits !== "function") throw "";
2681
- module2.exports = util.inherits;
2682
- } catch (e) {
2683
- module2.exports = require_inherits_browser();
2684
- }
2685
- var util;
2686
- }
2687
- });
2688
-
2689
- // ../../node_modules/hash.js/lib/hash/utils.js
2690
- var require_utils = __commonJS({
2691
- "../../node_modules/hash.js/lib/hash/utils.js"(exports2) {
2692
- "use strict";
2693
- var assert = require_minimalistic_assert();
2694
- var inherits = require_inherits();
2695
- exports2.inherits = inherits;
2696
- function isSurrogatePair(msg, i) {
2697
- if ((msg.charCodeAt(i) & 64512) !== 55296) {
2698
- return false;
2699
- }
2700
- if (i < 0 || i + 1 >= msg.length) {
2701
- return false;
2702
- }
2703
- return (msg.charCodeAt(i + 1) & 64512) === 56320;
2704
- }
2705
- function toArray(msg, enc) {
2706
- if (Array.isArray(msg))
2707
- return msg.slice();
2708
- if (!msg)
2709
- return [];
2710
- var res = [];
2711
- if (typeof msg === "string") {
2712
- if (!enc) {
2713
- var p = 0;
2714
- for (var i = 0; i < msg.length; i++) {
2715
- var c = msg.charCodeAt(i);
2716
- if (c < 128) {
2717
- res[p++] = c;
2718
- } else if (c < 2048) {
2719
- res[p++] = c >> 6 | 192;
2720
- res[p++] = c & 63 | 128;
2721
- } else if (isSurrogatePair(msg, i)) {
2722
- c = 65536 + ((c & 1023) << 10) + (msg.charCodeAt(++i) & 1023);
2723
- res[p++] = c >> 18 | 240;
2724
- res[p++] = c >> 12 & 63 | 128;
2725
- res[p++] = c >> 6 & 63 | 128;
2726
- res[p++] = c & 63 | 128;
2727
- } else {
2728
- res[p++] = c >> 12 | 224;
2729
- res[p++] = c >> 6 & 63 | 128;
2730
- res[p++] = c & 63 | 128;
2731
- }
2732
- }
2733
- } else if (enc === "hex") {
2734
- msg = msg.replace(/[^a-z0-9]+/ig, "");
2735
- if (msg.length % 2 !== 0)
2736
- msg = "0" + msg;
2737
- for (i = 0; i < msg.length; i += 2)
2738
- res.push(parseInt(msg[i] + msg[i + 1], 16));
2739
- }
2740
- } else {
2741
- for (i = 0; i < msg.length; i++)
2742
- res[i] = msg[i] | 0;
2743
- }
2744
- return res;
2745
- }
2746
- exports2.toArray = toArray;
2747
- function toHex(msg) {
2748
- var res = "";
2749
- for (var i = 0; i < msg.length; i++)
2750
- res += zero2(msg[i].toString(16));
2751
- return res;
2752
- }
2753
- exports2.toHex = toHex;
2754
- function htonl(w) {
2755
- var res = w >>> 24 | w >>> 8 & 65280 | w << 8 & 16711680 | (w & 255) << 24;
2756
- return res >>> 0;
2757
- }
2758
- exports2.htonl = htonl;
2759
- function toHex32(msg, endian) {
2760
- var res = "";
2761
- for (var i = 0; i < msg.length; i++) {
2762
- var w = msg[i];
2763
- if (endian === "little")
2764
- w = htonl(w);
2765
- res += zero8(w.toString(16));
2766
- }
2767
- return res;
2768
- }
2769
- exports2.toHex32 = toHex32;
2770
- function zero2(word) {
2771
- if (word.length === 1)
2772
- return "0" + word;
2773
- else
2774
- return word;
2775
- }
2776
- exports2.zero2 = zero2;
2777
- function zero8(word) {
2778
- if (word.length === 7)
2779
- return "0" + word;
2780
- else if (word.length === 6)
2781
- return "00" + word;
2782
- else if (word.length === 5)
2783
- return "000" + word;
2784
- else if (word.length === 4)
2785
- return "0000" + word;
2786
- else if (word.length === 3)
2787
- return "00000" + word;
2788
- else if (word.length === 2)
2789
- return "000000" + word;
2790
- else if (word.length === 1)
2791
- return "0000000" + word;
2792
- else
2793
- return word;
2794
- }
2795
- exports2.zero8 = zero8;
2796
- function join32(msg, start, end, endian) {
2797
- var len = end - start;
2798
- assert(len % 4 === 0);
2799
- var res = new Array(len / 4);
2800
- for (var i = 0, k = start; i < res.length; i++, k += 4) {
2801
- var w;
2802
- if (endian === "big")
2803
- w = msg[k] << 24 | msg[k + 1] << 16 | msg[k + 2] << 8 | msg[k + 3];
2804
- else
2805
- w = msg[k + 3] << 24 | msg[k + 2] << 16 | msg[k + 1] << 8 | msg[k];
2806
- res[i] = w >>> 0;
2807
- }
2808
- return res;
2809
- }
2810
- exports2.join32 = join32;
2811
- function split32(msg, endian) {
2812
- var res = new Array(msg.length * 4);
2813
- for (var i = 0, k = 0; i < msg.length; i++, k += 4) {
2814
- var m = msg[i];
2815
- if (endian === "big") {
2816
- res[k] = m >>> 24;
2817
- res[k + 1] = m >>> 16 & 255;
2818
- res[k + 2] = m >>> 8 & 255;
2819
- res[k + 3] = m & 255;
2820
- } else {
2821
- res[k + 3] = m >>> 24;
2822
- res[k + 2] = m >>> 16 & 255;
2823
- res[k + 1] = m >>> 8 & 255;
2824
- res[k] = m & 255;
2825
- }
2826
- }
2827
- return res;
2828
- }
2829
- exports2.split32 = split32;
2830
- function rotr32(w, b) {
2831
- return w >>> b | w << 32 - b;
2832
- }
2833
- exports2.rotr32 = rotr32;
2834
- function rotl32(w, b) {
2835
- return w << b | w >>> 32 - b;
2836
- }
2837
- exports2.rotl32 = rotl32;
2838
- function sum32(a, b) {
2839
- return a + b >>> 0;
2840
- }
2841
- exports2.sum32 = sum32;
2842
- function sum32_3(a, b, c) {
2843
- return a + b + c >>> 0;
2844
- }
2845
- exports2.sum32_3 = sum32_3;
2846
- function sum32_4(a, b, c, d) {
2847
- return a + b + c + d >>> 0;
2848
- }
2849
- exports2.sum32_4 = sum32_4;
2850
- function sum32_5(a, b, c, d, e) {
2851
- return a + b + c + d + e >>> 0;
2852
- }
2853
- exports2.sum32_5 = sum32_5;
2854
- function sum64(buf, pos, ah, al) {
2855
- var bh = buf[pos];
2856
- var bl = buf[pos + 1];
2857
- var lo = al + bl >>> 0;
2858
- var hi = (lo < al ? 1 : 0) + ah + bh;
2859
- buf[pos] = hi >>> 0;
2860
- buf[pos + 1] = lo;
2861
- }
2862
- exports2.sum64 = sum64;
2863
- function sum64_hi(ah, al, bh, bl) {
2864
- var lo = al + bl >>> 0;
2865
- var hi = (lo < al ? 1 : 0) + ah + bh;
2866
- return hi >>> 0;
2867
- }
2868
- exports2.sum64_hi = sum64_hi;
2869
- function sum64_lo(ah, al, bh, bl) {
2870
- var lo = al + bl;
2871
- return lo >>> 0;
2872
- }
2873
- exports2.sum64_lo = sum64_lo;
2874
- function sum64_4_hi(ah, al, bh, bl, ch, cl, dh, dl) {
2875
- var carry = 0;
2876
- var lo = al;
2877
- lo = lo + bl >>> 0;
2878
- carry += lo < al ? 1 : 0;
2879
- lo = lo + cl >>> 0;
2880
- carry += lo < cl ? 1 : 0;
2881
- lo = lo + dl >>> 0;
2882
- carry += lo < dl ? 1 : 0;
2883
- var hi = ah + bh + ch + dh + carry;
2884
- return hi >>> 0;
2885
- }
2886
- exports2.sum64_4_hi = sum64_4_hi;
2887
- function sum64_4_lo(ah, al, bh, bl, ch, cl, dh, dl) {
2888
- var lo = al + bl + cl + dl;
2889
- return lo >>> 0;
2890
- }
2891
- exports2.sum64_4_lo = sum64_4_lo;
2892
- function sum64_5_hi(ah, al, bh, bl, ch, cl, dh, dl, eh, el) {
2893
- var carry = 0;
2894
- var lo = al;
2895
- lo = lo + bl >>> 0;
2896
- carry += lo < al ? 1 : 0;
2897
- lo = lo + cl >>> 0;
2898
- carry += lo < cl ? 1 : 0;
2899
- lo = lo + dl >>> 0;
2900
- carry += lo < dl ? 1 : 0;
2901
- lo = lo + el >>> 0;
2902
- carry += lo < el ? 1 : 0;
2903
- var hi = ah + bh + ch + dh + eh + carry;
2904
- return hi >>> 0;
2905
- }
2906
- exports2.sum64_5_hi = sum64_5_hi;
2907
- function sum64_5_lo(ah, al, bh, bl, ch, cl, dh, dl, eh, el) {
2908
- var lo = al + bl + cl + dl + el;
2909
- return lo >>> 0;
2910
- }
2911
- exports2.sum64_5_lo = sum64_5_lo;
2912
- function rotr64_hi(ah, al, num) {
2913
- var r = al << 32 - num | ah >>> num;
2914
- return r >>> 0;
2915
- }
2916
- exports2.rotr64_hi = rotr64_hi;
2917
- function rotr64_lo(ah, al, num) {
2918
- var r = ah << 32 - num | al >>> num;
2919
- return r >>> 0;
2920
- }
2921
- exports2.rotr64_lo = rotr64_lo;
2922
- function shr64_hi(ah, al, num) {
2923
- return ah >>> num;
2924
- }
2925
- exports2.shr64_hi = shr64_hi;
2926
- function shr64_lo(ah, al, num) {
2927
- var r = ah << 32 - num | al >>> num;
2928
- return r >>> 0;
2929
- }
2930
- exports2.shr64_lo = shr64_lo;
2931
- }
2932
- });
2933
-
2934
- // ../../node_modules/hash.js/lib/hash/common.js
2935
- var require_common = __commonJS({
2936
- "../../node_modules/hash.js/lib/hash/common.js"(exports2) {
2937
- "use strict";
2938
- var utils = require_utils();
2939
- var assert = require_minimalistic_assert();
2940
- function BlockHash() {
2941
- this.pending = null;
2942
- this.pendingTotal = 0;
2943
- this.blockSize = this.constructor.blockSize;
2944
- this.outSize = this.constructor.outSize;
2945
- this.hmacStrength = this.constructor.hmacStrength;
2946
- this.padLength = this.constructor.padLength / 8;
2947
- this.endian = "big";
2948
- this._delta8 = this.blockSize / 8;
2949
- this._delta32 = this.blockSize / 32;
2950
- }
2951
- exports2.BlockHash = BlockHash;
2952
- BlockHash.prototype.update = function update(msg, enc) {
2953
- msg = utils.toArray(msg, enc);
2954
- if (!this.pending)
2955
- this.pending = msg;
2956
- else
2957
- this.pending = this.pending.concat(msg);
2958
- this.pendingTotal += msg.length;
2959
- if (this.pending.length >= this._delta8) {
2960
- msg = this.pending;
2961
- var r = msg.length % this._delta8;
2962
- this.pending = msg.slice(msg.length - r, msg.length);
2963
- if (this.pending.length === 0)
2964
- this.pending = null;
2965
- msg = utils.join32(msg, 0, msg.length - r, this.endian);
2966
- for (var i = 0; i < msg.length; i += this._delta32)
2967
- this._update(msg, i, i + this._delta32);
2968
- }
2969
- return this;
2970
- };
2971
- BlockHash.prototype.digest = function digest(enc) {
2972
- this.update(this._pad());
2973
- assert(this.pending === null);
2974
- return this._digest(enc);
2975
- };
2976
- BlockHash.prototype._pad = function pad() {
2977
- var len = this.pendingTotal;
2978
- var bytes = this._delta8;
2979
- var k = bytes - (len + this.padLength) % bytes;
2980
- var res = new Array(k + this.padLength);
2981
- res[0] = 128;
2982
- for (var i = 1; i < k; i++)
2983
- res[i] = 0;
2984
- len <<= 3;
2985
- if (this.endian === "big") {
2986
- for (var t = 8; t < this.padLength; t++)
2987
- res[i++] = 0;
2988
- res[i++] = 0;
2989
- res[i++] = 0;
2990
- res[i++] = 0;
2991
- res[i++] = 0;
2992
- res[i++] = len >>> 24 & 255;
2993
- res[i++] = len >>> 16 & 255;
2994
- res[i++] = len >>> 8 & 255;
2995
- res[i++] = len & 255;
2996
- } else {
2997
- res[i++] = len & 255;
2998
- res[i++] = len >>> 8 & 255;
2999
- res[i++] = len >>> 16 & 255;
3000
- res[i++] = len >>> 24 & 255;
3001
- res[i++] = 0;
3002
- res[i++] = 0;
3003
- res[i++] = 0;
3004
- res[i++] = 0;
3005
- for (t = 8; t < this.padLength; t++)
3006
- res[i++] = 0;
3007
- }
3008
- return res;
3009
- };
3010
- }
3011
- });
3012
-
3013
- // ../../node_modules/hash.js/lib/hash/sha/common.js
3014
- var require_common2 = __commonJS({
3015
- "../../node_modules/hash.js/lib/hash/sha/common.js"(exports2) {
3016
- "use strict";
3017
- var utils = require_utils();
3018
- var rotr32 = utils.rotr32;
3019
- function ft_1(s, x, y, z) {
3020
- if (s === 0)
3021
- return ch32(x, y, z);
3022
- if (s === 1 || s === 3)
3023
- return p32(x, y, z);
3024
- if (s === 2)
3025
- return maj32(x, y, z);
3026
- }
3027
- exports2.ft_1 = ft_1;
3028
- function ch32(x, y, z) {
3029
- return x & y ^ ~x & z;
3030
- }
3031
- exports2.ch32 = ch32;
3032
- function maj32(x, y, z) {
3033
- return x & y ^ x & z ^ y & z;
3034
- }
3035
- exports2.maj32 = maj32;
3036
- function p32(x, y, z) {
3037
- return x ^ y ^ z;
3038
- }
3039
- exports2.p32 = p32;
3040
- function s0_256(x) {
3041
- return rotr32(x, 2) ^ rotr32(x, 13) ^ rotr32(x, 22);
3042
- }
3043
- exports2.s0_256 = s0_256;
3044
- function s1_256(x) {
3045
- return rotr32(x, 6) ^ rotr32(x, 11) ^ rotr32(x, 25);
3046
- }
3047
- exports2.s1_256 = s1_256;
3048
- function g0_256(x) {
3049
- return rotr32(x, 7) ^ rotr32(x, 18) ^ x >>> 3;
3050
- }
3051
- exports2.g0_256 = g0_256;
3052
- function g1_256(x) {
3053
- return rotr32(x, 17) ^ rotr32(x, 19) ^ x >>> 10;
3054
- }
3055
- exports2.g1_256 = g1_256;
3056
- }
3057
- });
3058
-
3059
- // ../../node_modules/hash.js/lib/hash/sha/1.js
3060
- var require__ = __commonJS({
3061
- "../../node_modules/hash.js/lib/hash/sha/1.js"(exports2, module2) {
3062
- "use strict";
3063
- var utils = require_utils();
3064
- var common = require_common();
3065
- var shaCommon = require_common2();
3066
- var rotl32 = utils.rotl32;
3067
- var sum32 = utils.sum32;
3068
- var sum32_5 = utils.sum32_5;
3069
- var ft_1 = shaCommon.ft_1;
3070
- var BlockHash = common.BlockHash;
3071
- var sha1_K = [
3072
- 1518500249,
3073
- 1859775393,
3074
- 2400959708,
3075
- 3395469782
3076
- ];
3077
- function SHA1() {
3078
- if (!(this instanceof SHA1))
3079
- return new SHA1();
3080
- BlockHash.call(this);
3081
- this.h = [
3082
- 1732584193,
3083
- 4023233417,
3084
- 2562383102,
3085
- 271733878,
3086
- 3285377520
3087
- ];
3088
- this.W = new Array(80);
3089
- }
3090
- utils.inherits(SHA1, BlockHash);
3091
- module2.exports = SHA1;
3092
- SHA1.blockSize = 512;
3093
- SHA1.outSize = 160;
3094
- SHA1.hmacStrength = 80;
3095
- SHA1.padLength = 64;
3096
- SHA1.prototype._update = function _update(msg, start) {
3097
- var W = this.W;
3098
- for (var i = 0; i < 16; i++)
3099
- W[i] = msg[start + i];
3100
- for (; i < W.length; i++)
3101
- W[i] = rotl32(W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16], 1);
3102
- var a = this.h[0];
3103
- var b = this.h[1];
3104
- var c = this.h[2];
3105
- var d = this.h[3];
3106
- var e = this.h[4];
3107
- for (i = 0; i < W.length; i++) {
3108
- var s = ~~(i / 20);
3109
- var t = sum32_5(rotl32(a, 5), ft_1(s, b, c, d), e, W[i], sha1_K[s]);
3110
- e = d;
3111
- d = c;
3112
- c = rotl32(b, 30);
3113
- b = a;
3114
- a = t;
3115
- }
3116
- this.h[0] = sum32(this.h[0], a);
3117
- this.h[1] = sum32(this.h[1], b);
3118
- this.h[2] = sum32(this.h[2], c);
3119
- this.h[3] = sum32(this.h[3], d);
3120
- this.h[4] = sum32(this.h[4], e);
3121
- };
3122
- SHA1.prototype._digest = function digest(enc) {
3123
- if (enc === "hex")
3124
- return utils.toHex32(this.h, "big");
3125
- else
3126
- return utils.split32(this.h, "big");
3127
- };
3128
- }
3129
- });
3130
-
3131
- // ../../node_modules/hash.js/lib/hash/sha/256.js
3132
- var require__2 = __commonJS({
3133
- "../../node_modules/hash.js/lib/hash/sha/256.js"(exports2, module2) {
3134
- "use strict";
3135
- var utils = require_utils();
3136
- var common = require_common();
3137
- var shaCommon = require_common2();
3138
- var assert = require_minimalistic_assert();
3139
- var sum32 = utils.sum32;
3140
- var sum32_4 = utils.sum32_4;
3141
- var sum32_5 = utils.sum32_5;
3142
- var ch32 = shaCommon.ch32;
3143
- var maj32 = shaCommon.maj32;
3144
- var s0_256 = shaCommon.s0_256;
3145
- var s1_256 = shaCommon.s1_256;
3146
- var g0_256 = shaCommon.g0_256;
3147
- var g1_256 = shaCommon.g1_256;
3148
- var BlockHash = common.BlockHash;
3149
- var sha256_K = [
3150
- 1116352408,
3151
- 1899447441,
3152
- 3049323471,
3153
- 3921009573,
3154
- 961987163,
3155
- 1508970993,
3156
- 2453635748,
3157
- 2870763221,
3158
- 3624381080,
3159
- 310598401,
3160
- 607225278,
3161
- 1426881987,
3162
- 1925078388,
3163
- 2162078206,
3164
- 2614888103,
3165
- 3248222580,
3166
- 3835390401,
3167
- 4022224774,
3168
- 264347078,
3169
- 604807628,
3170
- 770255983,
3171
- 1249150122,
3172
- 1555081692,
3173
- 1996064986,
3174
- 2554220882,
3175
- 2821834349,
3176
- 2952996808,
3177
- 3210313671,
3178
- 3336571891,
3179
- 3584528711,
3180
- 113926993,
3181
- 338241895,
3182
- 666307205,
3183
- 773529912,
3184
- 1294757372,
3185
- 1396182291,
3186
- 1695183700,
3187
- 1986661051,
3188
- 2177026350,
3189
- 2456956037,
3190
- 2730485921,
3191
- 2820302411,
3192
- 3259730800,
3193
- 3345764771,
3194
- 3516065817,
3195
- 3600352804,
3196
- 4094571909,
3197
- 275423344,
3198
- 430227734,
3199
- 506948616,
3200
- 659060556,
3201
- 883997877,
3202
- 958139571,
3203
- 1322822218,
3204
- 1537002063,
3205
- 1747873779,
3206
- 1955562222,
3207
- 2024104815,
3208
- 2227730452,
3209
- 2361852424,
3210
- 2428436474,
3211
- 2756734187,
3212
- 3204031479,
3213
- 3329325298
3214
- ];
3215
- function SHA256() {
3216
- if (!(this instanceof SHA256))
3217
- return new SHA256();
3218
- BlockHash.call(this);
3219
- this.h = [
3220
- 1779033703,
3221
- 3144134277,
3222
- 1013904242,
3223
- 2773480762,
3224
- 1359893119,
3225
- 2600822924,
3226
- 528734635,
3227
- 1541459225
3228
- ];
3229
- this.k = sha256_K;
3230
- this.W = new Array(64);
3231
- }
3232
- utils.inherits(SHA256, BlockHash);
3233
- module2.exports = SHA256;
3234
- SHA256.blockSize = 512;
3235
- SHA256.outSize = 256;
3236
- SHA256.hmacStrength = 192;
3237
- SHA256.padLength = 64;
3238
- SHA256.prototype._update = function _update(msg, start) {
3239
- var W = this.W;
3240
- for (var i = 0; i < 16; i++)
3241
- W[i] = msg[start + i];
3242
- for (; i < W.length; i++)
3243
- W[i] = sum32_4(g1_256(W[i - 2]), W[i - 7], g0_256(W[i - 15]), W[i - 16]);
3244
- var a = this.h[0];
3245
- var b = this.h[1];
3246
- var c = this.h[2];
3247
- var d = this.h[3];
3248
- var e = this.h[4];
3249
- var f = this.h[5];
3250
- var g = this.h[6];
3251
- var h = this.h[7];
3252
- assert(this.k.length === W.length);
3253
- for (i = 0; i < W.length; i++) {
3254
- var T1 = sum32_5(h, s1_256(e), ch32(e, f, g), this.k[i], W[i]);
3255
- var T2 = sum32(s0_256(a), maj32(a, b, c));
3256
- h = g;
3257
- g = f;
3258
- f = e;
3259
- e = sum32(d, T1);
3260
- d = c;
3261
- c = b;
3262
- b = a;
3263
- a = sum32(T1, T2);
3264
- }
3265
- this.h[0] = sum32(this.h[0], a);
3266
- this.h[1] = sum32(this.h[1], b);
3267
- this.h[2] = sum32(this.h[2], c);
3268
- this.h[3] = sum32(this.h[3], d);
3269
- this.h[4] = sum32(this.h[4], e);
3270
- this.h[5] = sum32(this.h[5], f);
3271
- this.h[6] = sum32(this.h[6], g);
3272
- this.h[7] = sum32(this.h[7], h);
3273
- };
3274
- SHA256.prototype._digest = function digest(enc) {
3275
- if (enc === "hex")
3276
- return utils.toHex32(this.h, "big");
3277
- else
3278
- return utils.split32(this.h, "big");
3279
- };
3280
- }
3281
- });
3282
-
3283
- // ../../node_modules/hash.js/lib/hash/sha/224.js
3284
- var require__3 = __commonJS({
3285
- "../../node_modules/hash.js/lib/hash/sha/224.js"(exports2, module2) {
3286
- "use strict";
3287
- var utils = require_utils();
3288
- var SHA256 = require__2();
3289
- function SHA224() {
3290
- if (!(this instanceof SHA224))
3291
- return new SHA224();
3292
- SHA256.call(this);
3293
- this.h = [
3294
- 3238371032,
3295
- 914150663,
3296
- 812702999,
3297
- 4144912697,
3298
- 4290775857,
3299
- 1750603025,
3300
- 1694076839,
3301
- 3204075428
3302
- ];
3303
- }
3304
- utils.inherits(SHA224, SHA256);
3305
- module2.exports = SHA224;
3306
- SHA224.blockSize = 512;
3307
- SHA224.outSize = 224;
3308
- SHA224.hmacStrength = 192;
3309
- SHA224.padLength = 64;
3310
- SHA224.prototype._digest = function digest(enc) {
3311
- if (enc === "hex")
3312
- return utils.toHex32(this.h.slice(0, 7), "big");
3313
- else
3314
- return utils.split32(this.h.slice(0, 7), "big");
3315
- };
3316
- }
3317
- });
3318
-
3319
- // ../../node_modules/hash.js/lib/hash/sha/512.js
3320
- var require__4 = __commonJS({
3321
- "../../node_modules/hash.js/lib/hash/sha/512.js"(exports2, module2) {
3322
- "use strict";
3323
- var utils = require_utils();
3324
- var common = require_common();
3325
- var assert = require_minimalistic_assert();
3326
- var rotr64_hi = utils.rotr64_hi;
3327
- var rotr64_lo = utils.rotr64_lo;
3328
- var shr64_hi = utils.shr64_hi;
3329
- var shr64_lo = utils.shr64_lo;
3330
- var sum64 = utils.sum64;
3331
- var sum64_hi = utils.sum64_hi;
3332
- var sum64_lo = utils.sum64_lo;
3333
- var sum64_4_hi = utils.sum64_4_hi;
3334
- var sum64_4_lo = utils.sum64_4_lo;
3335
- var sum64_5_hi = utils.sum64_5_hi;
3336
- var sum64_5_lo = utils.sum64_5_lo;
3337
- var BlockHash = common.BlockHash;
3338
- var sha512_K = [
3339
- 1116352408,
3340
- 3609767458,
3341
- 1899447441,
3342
- 602891725,
3343
- 3049323471,
3344
- 3964484399,
3345
- 3921009573,
3346
- 2173295548,
3347
- 961987163,
3348
- 4081628472,
3349
- 1508970993,
3350
- 3053834265,
3351
- 2453635748,
3352
- 2937671579,
3353
- 2870763221,
3354
- 3664609560,
3355
- 3624381080,
3356
- 2734883394,
3357
- 310598401,
3358
- 1164996542,
3359
- 607225278,
3360
- 1323610764,
3361
- 1426881987,
3362
- 3590304994,
3363
- 1925078388,
3364
- 4068182383,
3365
- 2162078206,
3366
- 991336113,
3367
- 2614888103,
3368
- 633803317,
3369
- 3248222580,
3370
- 3479774868,
3371
- 3835390401,
3372
- 2666613458,
3373
- 4022224774,
3374
- 944711139,
3375
- 264347078,
3376
- 2341262773,
3377
- 604807628,
3378
- 2007800933,
3379
- 770255983,
3380
- 1495990901,
3381
- 1249150122,
3382
- 1856431235,
3383
- 1555081692,
3384
- 3175218132,
3385
- 1996064986,
3386
- 2198950837,
3387
- 2554220882,
3388
- 3999719339,
3389
- 2821834349,
3390
- 766784016,
3391
- 2952996808,
3392
- 2566594879,
3393
- 3210313671,
3394
- 3203337956,
3395
- 3336571891,
3396
- 1034457026,
3397
- 3584528711,
3398
- 2466948901,
3399
- 113926993,
3400
- 3758326383,
3401
- 338241895,
3402
- 168717936,
3403
- 666307205,
3404
- 1188179964,
3405
- 773529912,
3406
- 1546045734,
3407
- 1294757372,
3408
- 1522805485,
3409
- 1396182291,
3410
- 2643833823,
3411
- 1695183700,
3412
- 2343527390,
3413
- 1986661051,
3414
- 1014477480,
3415
- 2177026350,
3416
- 1206759142,
3417
- 2456956037,
3418
- 344077627,
3419
- 2730485921,
3420
- 1290863460,
3421
- 2820302411,
3422
- 3158454273,
3423
- 3259730800,
3424
- 3505952657,
3425
- 3345764771,
3426
- 106217008,
3427
- 3516065817,
3428
- 3606008344,
3429
- 3600352804,
3430
- 1432725776,
3431
- 4094571909,
3432
- 1467031594,
3433
- 275423344,
3434
- 851169720,
3435
- 430227734,
3436
- 3100823752,
3437
- 506948616,
3438
- 1363258195,
3439
- 659060556,
3440
- 3750685593,
3441
- 883997877,
3442
- 3785050280,
3443
- 958139571,
3444
- 3318307427,
3445
- 1322822218,
3446
- 3812723403,
3447
- 1537002063,
3448
- 2003034995,
3449
- 1747873779,
3450
- 3602036899,
3451
- 1955562222,
3452
- 1575990012,
3453
- 2024104815,
3454
- 1125592928,
3455
- 2227730452,
3456
- 2716904306,
3457
- 2361852424,
3458
- 442776044,
3459
- 2428436474,
3460
- 593698344,
3461
- 2756734187,
3462
- 3733110249,
3463
- 3204031479,
3464
- 2999351573,
3465
- 3329325298,
3466
- 3815920427,
3467
- 3391569614,
3468
- 3928383900,
3469
- 3515267271,
3470
- 566280711,
3471
- 3940187606,
3472
- 3454069534,
3473
- 4118630271,
3474
- 4000239992,
3475
- 116418474,
3476
- 1914138554,
3477
- 174292421,
3478
- 2731055270,
3479
- 289380356,
3480
- 3203993006,
3481
- 460393269,
3482
- 320620315,
3483
- 685471733,
3484
- 587496836,
3485
- 852142971,
3486
- 1086792851,
3487
- 1017036298,
3488
- 365543100,
3489
- 1126000580,
3490
- 2618297676,
3491
- 1288033470,
3492
- 3409855158,
3493
- 1501505948,
3494
- 4234509866,
3495
- 1607167915,
3496
- 987167468,
3497
- 1816402316,
3498
- 1246189591
3499
- ];
3500
- function SHA512() {
3501
- if (!(this instanceof SHA512))
3502
- return new SHA512();
3503
- BlockHash.call(this);
3504
- this.h = [
3505
- 1779033703,
3506
- 4089235720,
3507
- 3144134277,
3508
- 2227873595,
3509
- 1013904242,
3510
- 4271175723,
3511
- 2773480762,
3512
- 1595750129,
3513
- 1359893119,
3514
- 2917565137,
3515
- 2600822924,
3516
- 725511199,
3517
- 528734635,
3518
- 4215389547,
3519
- 1541459225,
3520
- 327033209
3521
- ];
3522
- this.k = sha512_K;
3523
- this.W = new Array(160);
3524
- }
3525
- utils.inherits(SHA512, BlockHash);
3526
- module2.exports = SHA512;
3527
- SHA512.blockSize = 1024;
3528
- SHA512.outSize = 512;
3529
- SHA512.hmacStrength = 192;
3530
- SHA512.padLength = 128;
3531
- SHA512.prototype._prepareBlock = function _prepareBlock(msg, start) {
3532
- var W = this.W;
3533
- for (var i = 0; i < 32; i++)
3534
- W[i] = msg[start + i];
3535
- for (; i < W.length; i += 2) {
3536
- var c0_hi = g1_512_hi(W[i - 4], W[i - 3]);
3537
- var c0_lo = g1_512_lo(W[i - 4], W[i - 3]);
3538
- var c1_hi = W[i - 14];
3539
- var c1_lo = W[i - 13];
3540
- var c2_hi = g0_512_hi(W[i - 30], W[i - 29]);
3541
- var c2_lo = g0_512_lo(W[i - 30], W[i - 29]);
3542
- var c3_hi = W[i - 32];
3543
- var c3_lo = W[i - 31];
3544
- W[i] = sum64_4_hi(
3545
- c0_hi,
3546
- c0_lo,
3547
- c1_hi,
3548
- c1_lo,
3549
- c2_hi,
3550
- c2_lo,
3551
- c3_hi,
3552
- c3_lo
3553
- );
3554
- W[i + 1] = sum64_4_lo(
3555
- c0_hi,
3556
- c0_lo,
3557
- c1_hi,
3558
- c1_lo,
3559
- c2_hi,
3560
- c2_lo,
3561
- c3_hi,
3562
- c3_lo
3563
- );
3564
- }
3565
- };
3566
- SHA512.prototype._update = function _update(msg, start) {
3567
- this._prepareBlock(msg, start);
3568
- var W = this.W;
3569
- var ah = this.h[0];
3570
- var al = this.h[1];
3571
- var bh = this.h[2];
3572
- var bl = this.h[3];
3573
- var ch = this.h[4];
3574
- var cl = this.h[5];
3575
- var dh = this.h[6];
3576
- var dl = this.h[7];
3577
- var eh = this.h[8];
3578
- var el = this.h[9];
3579
- var fh = this.h[10];
3580
- var fl = this.h[11];
3581
- var gh = this.h[12];
3582
- var gl = this.h[13];
3583
- var hh = this.h[14];
3584
- var hl = this.h[15];
3585
- assert(this.k.length === W.length);
3586
- for (var i = 0; i < W.length; i += 2) {
3587
- var c0_hi = hh;
3588
- var c0_lo = hl;
3589
- var c1_hi = s1_512_hi(eh, el);
3590
- var c1_lo = s1_512_lo(eh, el);
3591
- var c2_hi = ch64_hi(eh, el, fh, fl, gh, gl);
3592
- var c2_lo = ch64_lo(eh, el, fh, fl, gh, gl);
3593
- var c3_hi = this.k[i];
3594
- var c3_lo = this.k[i + 1];
3595
- var c4_hi = W[i];
3596
- var c4_lo = W[i + 1];
3597
- var T1_hi = sum64_5_hi(
3598
- c0_hi,
3599
- c0_lo,
3600
- c1_hi,
3601
- c1_lo,
3602
- c2_hi,
3603
- c2_lo,
3604
- c3_hi,
3605
- c3_lo,
3606
- c4_hi,
3607
- c4_lo
3608
- );
3609
- var T1_lo = sum64_5_lo(
3610
- c0_hi,
3611
- c0_lo,
3612
- c1_hi,
3613
- c1_lo,
3614
- c2_hi,
3615
- c2_lo,
3616
- c3_hi,
3617
- c3_lo,
3618
- c4_hi,
3619
- c4_lo
3620
- );
3621
- c0_hi = s0_512_hi(ah, al);
3622
- c0_lo = s0_512_lo(ah, al);
3623
- c1_hi = maj64_hi(ah, al, bh, bl, ch, cl);
3624
- c1_lo = maj64_lo(ah, al, bh, bl, ch, cl);
3625
- var T2_hi = sum64_hi(c0_hi, c0_lo, c1_hi, c1_lo);
3626
- var T2_lo = sum64_lo(c0_hi, c0_lo, c1_hi, c1_lo);
3627
- hh = gh;
3628
- hl = gl;
3629
- gh = fh;
3630
- gl = fl;
3631
- fh = eh;
3632
- fl = el;
3633
- eh = sum64_hi(dh, dl, T1_hi, T1_lo);
3634
- el = sum64_lo(dl, dl, T1_hi, T1_lo);
3635
- dh = ch;
3636
- dl = cl;
3637
- ch = bh;
3638
- cl = bl;
3639
- bh = ah;
3640
- bl = al;
3641
- ah = sum64_hi(T1_hi, T1_lo, T2_hi, T2_lo);
3642
- al = sum64_lo(T1_hi, T1_lo, T2_hi, T2_lo);
3643
- }
3644
- sum64(this.h, 0, ah, al);
3645
- sum64(this.h, 2, bh, bl);
3646
- sum64(this.h, 4, ch, cl);
3647
- sum64(this.h, 6, dh, dl);
3648
- sum64(this.h, 8, eh, el);
3649
- sum64(this.h, 10, fh, fl);
3650
- sum64(this.h, 12, gh, gl);
3651
- sum64(this.h, 14, hh, hl);
3652
- };
3653
- SHA512.prototype._digest = function digest(enc) {
3654
- if (enc === "hex")
3655
- return utils.toHex32(this.h, "big");
3656
- else
3657
- return utils.split32(this.h, "big");
3658
- };
3659
- function ch64_hi(xh, xl, yh, yl, zh) {
3660
- var r = xh & yh ^ ~xh & zh;
3661
- if (r < 0)
3662
- r += 4294967296;
3663
- return r;
3664
- }
3665
- function ch64_lo(xh, xl, yh, yl, zh, zl) {
3666
- var r = xl & yl ^ ~xl & zl;
3667
- if (r < 0)
3668
- r += 4294967296;
3669
- return r;
3670
- }
3671
- function maj64_hi(xh, xl, yh, yl, zh) {
3672
- var r = xh & yh ^ xh & zh ^ yh & zh;
3673
- if (r < 0)
3674
- r += 4294967296;
3675
- return r;
3676
- }
3677
- function maj64_lo(xh, xl, yh, yl, zh, zl) {
3678
- var r = xl & yl ^ xl & zl ^ yl & zl;
3679
- if (r < 0)
3680
- r += 4294967296;
3681
- return r;
3682
- }
3683
- function s0_512_hi(xh, xl) {
3684
- var c0_hi = rotr64_hi(xh, xl, 28);
3685
- var c1_hi = rotr64_hi(xl, xh, 2);
3686
- var c2_hi = rotr64_hi(xl, xh, 7);
3687
- var r = c0_hi ^ c1_hi ^ c2_hi;
3688
- if (r < 0)
3689
- r += 4294967296;
3690
- return r;
3691
- }
3692
- function s0_512_lo(xh, xl) {
3693
- var c0_lo = rotr64_lo(xh, xl, 28);
3694
- var c1_lo = rotr64_lo(xl, xh, 2);
3695
- var c2_lo = rotr64_lo(xl, xh, 7);
3696
- var r = c0_lo ^ c1_lo ^ c2_lo;
3697
- if (r < 0)
3698
- r += 4294967296;
3699
- return r;
3700
- }
3701
- function s1_512_hi(xh, xl) {
3702
- var c0_hi = rotr64_hi(xh, xl, 14);
3703
- var c1_hi = rotr64_hi(xh, xl, 18);
3704
- var c2_hi = rotr64_hi(xl, xh, 9);
3705
- var r = c0_hi ^ c1_hi ^ c2_hi;
3706
- if (r < 0)
3707
- r += 4294967296;
3708
- return r;
3709
- }
3710
- function s1_512_lo(xh, xl) {
3711
- var c0_lo = rotr64_lo(xh, xl, 14);
3712
- var c1_lo = rotr64_lo(xh, xl, 18);
3713
- var c2_lo = rotr64_lo(xl, xh, 9);
3714
- var r = c0_lo ^ c1_lo ^ c2_lo;
3715
- if (r < 0)
3716
- r += 4294967296;
3717
- return r;
3718
- }
3719
- function g0_512_hi(xh, xl) {
3720
- var c0_hi = rotr64_hi(xh, xl, 1);
3721
- var c1_hi = rotr64_hi(xh, xl, 8);
3722
- var c2_hi = shr64_hi(xh, xl, 7);
3723
- var r = c0_hi ^ c1_hi ^ c2_hi;
3724
- if (r < 0)
3725
- r += 4294967296;
3726
- return r;
3727
- }
3728
- function g0_512_lo(xh, xl) {
3729
- var c0_lo = rotr64_lo(xh, xl, 1);
3730
- var c1_lo = rotr64_lo(xh, xl, 8);
3731
- var c2_lo = shr64_lo(xh, xl, 7);
3732
- var r = c0_lo ^ c1_lo ^ c2_lo;
3733
- if (r < 0)
3734
- r += 4294967296;
3735
- return r;
3736
- }
3737
- function g1_512_hi(xh, xl) {
3738
- var c0_hi = rotr64_hi(xh, xl, 19);
3739
- var c1_hi = rotr64_hi(xl, xh, 29);
3740
- var c2_hi = shr64_hi(xh, xl, 6);
3741
- var r = c0_hi ^ c1_hi ^ c2_hi;
3742
- if (r < 0)
3743
- r += 4294967296;
3744
- return r;
3745
- }
3746
- function g1_512_lo(xh, xl) {
3747
- var c0_lo = rotr64_lo(xh, xl, 19);
3748
- var c1_lo = rotr64_lo(xl, xh, 29);
3749
- var c2_lo = shr64_lo(xh, xl, 6);
3750
- var r = c0_lo ^ c1_lo ^ c2_lo;
3751
- if (r < 0)
3752
- r += 4294967296;
3753
- return r;
3754
- }
3755
- }
3756
- });
3757
-
3758
- // ../../node_modules/hash.js/lib/hash/sha/384.js
3759
- var require__5 = __commonJS({
3760
- "../../node_modules/hash.js/lib/hash/sha/384.js"(exports2, module2) {
3761
- "use strict";
3762
- var utils = require_utils();
3763
- var SHA512 = require__4();
3764
- function SHA384() {
3765
- if (!(this instanceof SHA384))
3766
- return new SHA384();
3767
- SHA512.call(this);
3768
- this.h = [
3769
- 3418070365,
3770
- 3238371032,
3771
- 1654270250,
3772
- 914150663,
3773
- 2438529370,
3774
- 812702999,
3775
- 355462360,
3776
- 4144912697,
3777
- 1731405415,
3778
- 4290775857,
3779
- 2394180231,
3780
- 1750603025,
3781
- 3675008525,
3782
- 1694076839,
3783
- 1203062813,
3784
- 3204075428
3785
- ];
3786
- }
3787
- utils.inherits(SHA384, SHA512);
3788
- module2.exports = SHA384;
3789
- SHA384.blockSize = 1024;
3790
- SHA384.outSize = 384;
3791
- SHA384.hmacStrength = 192;
3792
- SHA384.padLength = 128;
3793
- SHA384.prototype._digest = function digest(enc) {
3794
- if (enc === "hex")
3795
- return utils.toHex32(this.h.slice(0, 12), "big");
3796
- else
3797
- return utils.split32(this.h.slice(0, 12), "big");
3798
- };
3799
- }
3800
- });
3801
-
3802
- // ../../node_modules/hash.js/lib/hash/sha.js
3803
- var require_sha = __commonJS({
3804
- "../../node_modules/hash.js/lib/hash/sha.js"(exports2) {
3805
- "use strict";
3806
- exports2.sha1 = require__();
3807
- exports2.sha224 = require__3();
3808
- exports2.sha256 = require__2();
3809
- exports2.sha384 = require__5();
3810
- exports2.sha512 = require__4();
3811
- }
3812
- });
3813
-
3814
- // ../../node_modules/hash.js/lib/hash/ripemd.js
3815
- var require_ripemd = __commonJS({
3816
- "../../node_modules/hash.js/lib/hash/ripemd.js"(exports2) {
3817
- "use strict";
3818
- var utils = require_utils();
3819
- var common = require_common();
3820
- var rotl32 = utils.rotl32;
3821
- var sum32 = utils.sum32;
3822
- var sum32_3 = utils.sum32_3;
3823
- var sum32_4 = utils.sum32_4;
3824
- var BlockHash = common.BlockHash;
3825
- function RIPEMD160() {
3826
- if (!(this instanceof RIPEMD160))
3827
- return new RIPEMD160();
3828
- BlockHash.call(this);
3829
- this.h = [1732584193, 4023233417, 2562383102, 271733878, 3285377520];
3830
- this.endian = "little";
3831
- }
3832
- utils.inherits(RIPEMD160, BlockHash);
3833
- exports2.ripemd160 = RIPEMD160;
3834
- RIPEMD160.blockSize = 512;
3835
- RIPEMD160.outSize = 160;
3836
- RIPEMD160.hmacStrength = 192;
3837
- RIPEMD160.padLength = 64;
3838
- RIPEMD160.prototype._update = function update(msg, start) {
3839
- var A = this.h[0];
3840
- var B = this.h[1];
3841
- var C = this.h[2];
3842
- var D = this.h[3];
3843
- var E = this.h[4];
3844
- var Ah = A;
3845
- var Bh = B;
3846
- var Ch = C;
3847
- var Dh = D;
3848
- var Eh = E;
3849
- for (var j = 0; j < 80; j++) {
3850
- var T = sum32(
3851
- rotl32(
3852
- sum32_4(A, f(j, B, C, D), msg[r[j] + start], K(j)),
3853
- s[j]
3854
- ),
3855
- E
3856
- );
3857
- A = E;
3858
- E = D;
3859
- D = rotl32(C, 10);
3860
- C = B;
3861
- B = T;
3862
- T = sum32(
3863
- rotl32(
3864
- sum32_4(Ah, f(79 - j, Bh, Ch, Dh), msg[rh[j] + start], Kh(j)),
3865
- sh[j]
3866
- ),
3867
- Eh
3868
- );
3869
- Ah = Eh;
3870
- Eh = Dh;
3871
- Dh = rotl32(Ch, 10);
3872
- Ch = Bh;
3873
- Bh = T;
3874
- }
3875
- T = sum32_3(this.h[1], C, Dh);
3876
- this.h[1] = sum32_3(this.h[2], D, Eh);
3877
- this.h[2] = sum32_3(this.h[3], E, Ah);
3878
- this.h[3] = sum32_3(this.h[4], A, Bh);
3879
- this.h[4] = sum32_3(this.h[0], B, Ch);
3880
- this.h[0] = T;
3881
- };
3882
- RIPEMD160.prototype._digest = function digest(enc) {
3883
- if (enc === "hex")
3884
- return utils.toHex32(this.h, "little");
3885
- else
3886
- return utils.split32(this.h, "little");
3887
- };
3888
- function f(j, x, y, z) {
3889
- if (j <= 15)
3890
- return x ^ y ^ z;
3891
- else if (j <= 31)
3892
- return x & y | ~x & z;
3893
- else if (j <= 47)
3894
- return (x | ~y) ^ z;
3895
- else if (j <= 63)
3896
- return x & z | y & ~z;
3897
- else
3898
- return x ^ (y | ~z);
3899
- }
3900
- function K(j) {
3901
- if (j <= 15)
3902
- return 0;
3903
- else if (j <= 31)
3904
- return 1518500249;
3905
- else if (j <= 47)
3906
- return 1859775393;
3907
- else if (j <= 63)
3908
- return 2400959708;
3909
- else
3910
- return 2840853838;
3911
- }
3912
- function Kh(j) {
3913
- if (j <= 15)
3914
- return 1352829926;
3915
- else if (j <= 31)
3916
- return 1548603684;
3917
- else if (j <= 47)
3918
- return 1836072691;
3919
- else if (j <= 63)
3920
- return 2053994217;
3921
- else
3922
- return 0;
3923
- }
3924
- var r = [
3925
- 0,
3926
- 1,
3927
- 2,
3928
- 3,
3929
- 4,
3930
- 5,
3931
- 6,
3932
- 7,
3933
- 8,
3934
- 9,
3935
- 10,
3936
- 11,
3937
- 12,
3938
- 13,
3939
- 14,
3940
- 15,
3941
- 7,
3942
- 4,
3943
- 13,
3944
- 1,
3945
- 10,
3946
- 6,
3947
- 15,
3948
- 3,
3949
- 12,
3950
- 0,
3951
- 9,
3952
- 5,
3953
- 2,
3954
- 14,
3955
- 11,
3956
- 8,
3957
- 3,
3958
- 10,
3959
- 14,
3960
- 4,
3961
- 9,
3962
- 15,
3963
- 8,
3964
- 1,
3965
- 2,
3966
- 7,
3967
- 0,
3968
- 6,
3969
- 13,
3970
- 11,
3971
- 5,
3972
- 12,
3973
- 1,
3974
- 9,
3975
- 11,
3976
- 10,
3977
- 0,
3978
- 8,
3979
- 12,
3980
- 4,
3981
- 13,
3982
- 3,
3983
- 7,
3984
- 15,
3985
- 14,
3986
- 5,
3987
- 6,
3988
- 2,
3989
- 4,
3990
- 0,
3991
- 5,
3992
- 9,
3993
- 7,
3994
- 12,
3995
- 2,
3996
- 10,
3997
- 14,
3998
- 1,
3999
- 3,
4000
- 8,
4001
- 11,
4002
- 6,
4003
- 15,
4004
- 13
4005
- ];
4006
- var rh = [
4007
- 5,
4008
- 14,
4009
- 7,
4010
- 0,
4011
- 9,
4012
- 2,
4013
- 11,
4014
- 4,
4015
- 13,
4016
- 6,
4017
- 15,
4018
- 8,
4019
- 1,
4020
- 10,
4021
- 3,
4022
- 12,
4023
- 6,
4024
- 11,
4025
- 3,
4026
- 7,
4027
- 0,
4028
- 13,
4029
- 5,
4030
- 10,
4031
- 14,
4032
- 15,
4033
- 8,
4034
- 12,
4035
- 4,
4036
- 9,
4037
- 1,
4038
- 2,
4039
- 15,
4040
- 5,
4041
- 1,
4042
- 3,
4043
- 7,
4044
- 14,
4045
- 6,
4046
- 9,
4047
- 11,
4048
- 8,
4049
- 12,
4050
- 2,
4051
- 10,
4052
- 0,
4053
- 4,
4054
- 13,
4055
- 8,
4056
- 6,
4057
- 4,
4058
- 1,
4059
- 3,
4060
- 11,
4061
- 15,
4062
- 0,
4063
- 5,
4064
- 12,
4065
- 2,
4066
- 13,
4067
- 9,
4068
- 7,
4069
- 10,
4070
- 14,
4071
- 12,
4072
- 15,
4073
- 10,
4074
- 4,
4075
- 1,
4076
- 5,
4077
- 8,
4078
- 7,
4079
- 6,
4080
- 2,
4081
- 13,
4082
- 14,
4083
- 0,
4084
- 3,
4085
- 9,
4086
- 11
4087
- ];
4088
- var s = [
4089
- 11,
4090
- 14,
4091
- 15,
4092
- 12,
4093
- 5,
4094
- 8,
4095
- 7,
4096
- 9,
4097
- 11,
4098
- 13,
4099
- 14,
4100
- 15,
4101
- 6,
4102
- 7,
4103
- 9,
4104
- 8,
4105
- 7,
4106
- 6,
4107
- 8,
4108
- 13,
4109
- 11,
4110
- 9,
4111
- 7,
4112
- 15,
4113
- 7,
4114
- 12,
4115
- 15,
4116
- 9,
4117
- 11,
4118
- 7,
4119
- 13,
4120
- 12,
4121
- 11,
4122
- 13,
4123
- 6,
4124
- 7,
4125
- 14,
4126
- 9,
4127
- 13,
4128
- 15,
4129
- 14,
4130
- 8,
4131
- 13,
4132
- 6,
4133
- 5,
4134
- 12,
4135
- 7,
4136
- 5,
4137
- 11,
4138
- 12,
4139
- 14,
4140
- 15,
4141
- 14,
4142
- 15,
4143
- 9,
4144
- 8,
4145
- 9,
4146
- 14,
4147
- 5,
4148
- 6,
4149
- 8,
4150
- 6,
4151
- 5,
4152
- 12,
4153
- 9,
4154
- 15,
4155
- 5,
4156
- 11,
4157
- 6,
4158
- 8,
4159
- 13,
4160
- 12,
4161
- 5,
4162
- 12,
4163
- 13,
4164
- 14,
4165
- 11,
4166
- 8,
4167
- 5,
4168
- 6
4169
- ];
4170
- var sh = [
4171
- 8,
4172
- 9,
4173
- 9,
4174
- 11,
4175
- 13,
4176
- 15,
4177
- 15,
4178
- 5,
4179
- 7,
4180
- 7,
4181
- 8,
4182
- 11,
4183
- 14,
4184
- 14,
4185
- 12,
4186
- 6,
4187
- 9,
4188
- 13,
4189
- 15,
4190
- 7,
4191
- 12,
4192
- 8,
4193
- 9,
4194
- 11,
4195
- 7,
4196
- 7,
4197
- 12,
4198
- 7,
4199
- 6,
4200
- 15,
4201
- 13,
4202
- 11,
4203
- 9,
4204
- 7,
4205
- 15,
4206
- 11,
4207
- 8,
4208
- 6,
4209
- 6,
4210
- 14,
4211
- 12,
4212
- 13,
4213
- 5,
4214
- 14,
4215
- 13,
4216
- 13,
4217
- 7,
4218
- 5,
4219
- 15,
4220
- 5,
4221
- 8,
4222
- 11,
4223
- 14,
4224
- 14,
4225
- 6,
4226
- 14,
4227
- 6,
4228
- 9,
4229
- 12,
4230
- 9,
4231
- 12,
4232
- 5,
4233
- 15,
4234
- 8,
4235
- 8,
4236
- 5,
4237
- 12,
4238
- 9,
4239
- 12,
4240
- 5,
4241
- 14,
4242
- 6,
4243
- 8,
4244
- 13,
4245
- 6,
4246
- 5,
4247
- 15,
4248
- 13,
4249
- 11,
4250
- 11
4251
- ];
4252
- }
4253
- });
4254
-
4255
- // ../../node_modules/hash.js/lib/hash/hmac.js
4256
- var require_hmac = __commonJS({
4257
- "../../node_modules/hash.js/lib/hash/hmac.js"(exports2, module2) {
4258
- "use strict";
4259
- var utils = require_utils();
4260
- var assert = require_minimalistic_assert();
4261
- function Hmac(hash2, key, enc) {
4262
- if (!(this instanceof Hmac))
4263
- return new Hmac(hash2, key, enc);
4264
- this.Hash = hash2;
4265
- this.blockSize = hash2.blockSize / 8;
4266
- this.outSize = hash2.outSize / 8;
4267
- this.inner = null;
4268
- this.outer = null;
4269
- this._init(utils.toArray(key, enc));
4270
- }
4271
- module2.exports = Hmac;
4272
- Hmac.prototype._init = function init(key) {
4273
- if (key.length > this.blockSize)
4274
- key = new this.Hash().update(key).digest();
4275
- assert(key.length <= this.blockSize);
4276
- for (var i = key.length; i < this.blockSize; i++)
4277
- key.push(0);
4278
- for (i = 0; i < key.length; i++)
4279
- key[i] ^= 54;
4280
- this.inner = new this.Hash().update(key);
4281
- for (i = 0; i < key.length; i++)
4282
- key[i] ^= 106;
4283
- this.outer = new this.Hash().update(key);
4284
- };
4285
- Hmac.prototype.update = function update(msg, enc) {
4286
- this.inner.update(msg, enc);
4287
- return this;
4288
- };
4289
- Hmac.prototype.digest = function digest(enc) {
4290
- this.outer.update(this.inner.digest());
4291
- return this.outer.digest(enc);
4292
- };
4293
- }
4294
- });
4295
-
4296
- // ../../node_modules/hash.js/lib/hash.js
4297
- var require_hash = __commonJS({
4298
- "../../node_modules/hash.js/lib/hash.js"(exports2) {
4299
- "use strict";
4300
- var hash2 = exports2;
4301
- hash2.utils = require_utils();
4302
- hash2.common = require_common();
4303
- hash2.sha = require_sha();
4304
- hash2.ripemd = require_ripemd();
4305
- hash2.hmac = require_hmac();
4306
- hash2.sha1 = hash2.sha.sha1;
4307
- hash2.sha256 = hash2.sha.sha256;
4308
- hash2.sha224 = hash2.sha.sha224;
4309
- hash2.sha384 = hash2.sha.sha384;
4310
- hash2.sha512 = hash2.sha.sha512;
4311
- hash2.ripemd160 = hash2.ripemd.ripemd160;
4312
- }
4313
- });
4314
-
4315
2625
  // src/index.ts
4316
2626
  var index_exports = {};
4317
2627
  __export(index_exports, {
@@ -4483,9 +2793,9 @@ __export(index_exports, {
4483
2793
  resolveTxHash: () => resolveTxHash,
4484
2794
  scriptHashToBech32: () => scriptHashToBech32,
4485
2795
  scriptHashToRewardAddress: () => scriptHashToRewardAddress,
2796
+ serializeAddress: () => serializeAddress,
4486
2797
  serializeAddressObj: () => serializeAddressObj,
4487
2798
  serializePlutusAddressToBech32: () => serializePlutusAddressToBech32,
4488
- serialzeAddress: () => serialzeAddress,
4489
2799
  signData: () => signData,
4490
2800
  subValue: () => subValue,
4491
2801
  toAddress: () => toAddress,
@@ -4944,7 +3254,7 @@ var import_common9 = require("@meshsdk/common");
4944
3254
  var import_crypto3 = require("crypto");
4945
3255
  var import_blake2b = __toESM(require_blake2b2(), 1);
4946
3256
  var import_util2 = require("@cardano-sdk/util");
4947
- var import_hash = __toESM(require_hash(), 1);
3257
+ var import_hash = __toESM(require("hash.js"), 1);
4948
3258
  var import_common4 = require("@meshsdk/common");
4949
3259
  var buildBaseAddress = (networkId, paymentKeyHash, stakeKeyHash, paymentCredType = CredentialType.KeyHash, stakeCredType = CredentialType.KeyHash) => {
4950
3260
  return BaseAddress.fromCredentials(
@@ -5710,7 +4020,7 @@ function empty(v) {
5710
4020
  // src/utils/address.ts
5711
4021
  var import_util6 = require("@cardano-sdk/util");
5712
4022
  var import_common8 = require("@meshsdk/common");
5713
- var serialzeAddress = (deserializedAddress, networkId = 0) => {
4023
+ var serializeAddress = (deserializedAddress, networkId = 0) => {
5714
4024
  const {
5715
4025
  pubKeyHash,
5716
4026
  scriptHash,
@@ -8986,9 +7296,9 @@ var CardanoSDK = __toESM(require("@cardano-sdk/core"), 1);
8986
7296
  resolveTxHash,
8987
7297
  scriptHashToBech32,
8988
7298
  scriptHashToRewardAddress,
7299
+ serializeAddress,
8989
7300
  serializeAddressObj,
8990
7301
  serializePlutusAddressToBech32,
8991
- serialzeAddress,
8992
7302
  signData,
8993
7303
  subValue,
8994
7304
  toAddress,