rapidhash-js 1.0.1 → 1.0.3

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/CHANGELOG.md ADDED
@@ -0,0 +1,5 @@
1
+ # Changelog
2
+
3
+ ## [1.0.3] - 2024-09-24
4
+
5
+ - Some performance improvements.
package/README.md CHANGED
@@ -1,6 +1,6 @@
1
1
  # rapidhash-js
2
2
 
3
- [![npm version](https://badge.fury.io/js/rapidhash-js.svg)](https://badge.fury.io/js/rapidhash-js)
3
+ [![npm version](https://badge.fury.io/js/rapidhash-js.png)](https://badge.fury.io/js/rapidhash-js)
4
4
  [![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/komiya-atsushi/rapidhash-js/test.yaml)](https://github.com/komiya-atsushi/rapidhash-js/actions/workflows/test.yaml)
5
5
  [![NPM License](https://img.shields.io/npm/l/rapidhash-js)](https://opensource.org/licenses/MIT)
6
6
 
@@ -18,7 +18,7 @@ npm install rapidhash-js
18
18
  ## Usage
19
19
 
20
20
  ```typescript
21
- import {rapidhash} from 'rapidhash';
21
+ import {rapidhash} from 'rapidhash-js';
22
22
 
23
23
  // rapidhash() returns a 64-bit hash value represented as bigint.
24
24
  console.log(rapidhash('hello world')); // Output: 17498481775468162579n
@@ -7,41 +7,56 @@ const rapid_secret = [
7
7
  0x8bb84b93962eacc9n,
8
8
  0x4b33a62ed433d4a3n,
9
9
  ];
10
- function rapid_mum_fast(a, b) {
11
- return a * b;
10
+ function rapid_mix_fast(a, b) {
11
+ const m = a * b;
12
+ return BigInt.asUintN(64, m) ^ (m >> 64n);
13
+ }
14
+ function rapidhash_epilogue_fast(a, b, secret, len) {
15
+ const m0 = a * b;
16
+ const m1 = (BigInt.asUintN(64, m0) ^ secret[0] ^ len) * ((m0 >> 64n) ^ secret[1]);
17
+ return BigInt.asUintN(64, m1) ^ (m1 >> 64n);
12
18
  }
13
- function rapid_mum_protected(a, b) {
19
+ function rapid_mix_protected(a, b) {
14
20
  const m = a * b;
15
- return m ^ (a | (b << 64n));
21
+ return BigInt.asUintN(64, m) ^ (m >> 64n) ^ a ^ b;
16
22
  }
17
- function rapid_mix(a, b, rapid_mum) {
18
- const m = rapid_mum(a, b);
19
- return (m & 0xffffffffffffffffn) ^ (m >> 64n);
23
+ function rapidhash_epilogue_protected(a0, b0, secret, len) {
24
+ const m0 = a0 * b0;
25
+ const a1 = BigInt.asUintN(64, m0) ^ secret[0] ^ len ^ a0;
26
+ const b1 = (m0 >> 64n) ^ secret[1] ^ b0;
27
+ const m1 = a1 * b1;
28
+ return BigInt.asUintN(64, m1) ^ (m1 >> 64n) ^ a1 ^ b1;
20
29
  }
21
- function rapid_read32(buf, offset) {
22
- return BigInt(buf.getUint32(offset, true));
30
+ const read32x2Buffer = new Uint8Array(8);
31
+ const read32x2View = new DataView(read32x2Buffer.buffer);
32
+ function rapid_read32x2(buf, offset1, offset2) {
33
+ read32x2View.setUint32(4, buf.getUint32(offset1, true), true);
34
+ read32x2View.setUint32(0, buf.getUint32(offset2, true), true);
35
+ return read32x2View.getBigUint64(0, true);
23
36
  }
24
37
  function rapid_read64(buf, offset) {
25
38
  return buf.getBigUint64(offset, true);
26
39
  }
40
+ const readSmallBuffer = new Uint8Array(8);
41
+ const readSmallView = new DataView(readSmallBuffer.buffer);
27
42
  function rapid_readSmall(buf, offset, k) {
28
- const v1 = buf.getUint8(offset);
29
- const v2 = buf.getUint8(offset + (k >> 1));
30
- const v3 = buf.getUint8(offset + k - 1);
31
- return (BigInt(v1) << 56n) | (BigInt(v2) << 32n) | BigInt(v3);
43
+ readSmallBuffer[7] = buf.getUint8(offset);
44
+ readSmallBuffer[4] = buf.getUint8(offset + (k >> 1));
45
+ readSmallBuffer[0] = buf.getUint8(offset + k - 1);
46
+ return readSmallView.getBigUint64(0, true);
32
47
  }
33
- function rapidhash_internal(key, seed, secret, rapid_mum) {
48
+ function rapidhash_internal(key, seed, secret, rapid_mix, rapidhash_epilogue) {
34
49
  const len = key.byteLength;
35
50
  const lenBI = BigInt(key.byteLength);
36
- seed ^= rapid_mix(seed ^ secret[0], secret[1], rapid_mum) ^ lenBI;
51
+ seed ^= rapid_mix(seed ^ secret[0], secret[1]) ^ lenBI;
37
52
  let a;
38
53
  let b;
39
54
  if (len <= 16) {
40
55
  if (len >= 4) {
41
56
  const last = len - 4;
42
- a = (rapid_read32(key, 0) << 32n) | rapid_read32(key, last);
57
+ a = rapid_read32x2(key, 0, last);
43
58
  const delta = (len & 24) >> (len >> 3);
44
- b = (rapid_read32(key, delta) << 32n) | rapid_read32(key, last - delta);
59
+ b = rapid_read32x2(key, delta, last - delta);
45
60
  }
46
61
  else if (len > 0) {
47
62
  a = rapid_readSmall(key, 0, len);
@@ -58,28 +73,28 @@ function rapidhash_internal(key, seed, secret, rapid_mum) {
58
73
  if (i > 48) {
59
74
  let see1 = seed, see2 = seed;
60
75
  while (i >= 96) {
61
- seed = rapid_mix(rapid_read64(key, p) ^ secret[0], rapid_read64(key, p + 8) ^ seed, rapid_mum);
62
- see1 = rapid_mix(rapid_read64(key, p + 16) ^ secret[1], rapid_read64(key, p + 24) ^ see1, rapid_mum);
63
- see2 = rapid_mix(rapid_read64(key, p + 32) ^ secret[2], rapid_read64(key, p + 40) ^ see2, rapid_mum);
64
- seed = rapid_mix(rapid_read64(key, p + 48) ^ secret[0], rapid_read64(key, p + 56) ^ seed, rapid_mum);
65
- see1 = rapid_mix(rapid_read64(key, p + 64) ^ secret[1], rapid_read64(key, p + 72) ^ see1, rapid_mum);
66
- see2 = rapid_mix(rapid_read64(key, p + 80) ^ secret[2], rapid_read64(key, p + 88) ^ see2, rapid_mum);
76
+ seed = rapid_mix(rapid_read64(key, p) ^ secret[0], rapid_read64(key, p + 8) ^ seed);
77
+ see1 = rapid_mix(rapid_read64(key, p + 16) ^ secret[1], rapid_read64(key, p + 24) ^ see1);
78
+ see2 = rapid_mix(rapid_read64(key, p + 32) ^ secret[2], rapid_read64(key, p + 40) ^ see2);
79
+ seed = rapid_mix(rapid_read64(key, p + 48) ^ secret[0], rapid_read64(key, p + 56) ^ seed);
80
+ see1 = rapid_mix(rapid_read64(key, p + 64) ^ secret[1], rapid_read64(key, p + 72) ^ see1);
81
+ see2 = rapid_mix(rapid_read64(key, p + 80) ^ secret[2], rapid_read64(key, p + 88) ^ see2);
67
82
  p += 96;
68
83
  i -= 96;
69
84
  }
70
85
  if (i >= 48) {
71
- seed = rapid_mix(rapid_read64(key, p) ^ secret[0], rapid_read64(key, p + 8) ^ seed, rapid_mum);
72
- see1 = rapid_mix(rapid_read64(key, p + 16) ^ secret[1], rapid_read64(key, p + 24) ^ see1, rapid_mum);
73
- see2 = rapid_mix(rapid_read64(key, p + 32) ^ secret[2], rapid_read64(key, p + 40) ^ see2, rapid_mum);
86
+ seed = rapid_mix(rapid_read64(key, p) ^ secret[0], rapid_read64(key, p + 8) ^ seed);
87
+ see1 = rapid_mix(rapid_read64(key, p + 16) ^ secret[1], rapid_read64(key, p + 24) ^ see1);
88
+ see2 = rapid_mix(rapid_read64(key, p + 32) ^ secret[2], rapid_read64(key, p + 40) ^ see2);
74
89
  p += 48;
75
90
  i -= 48;
76
91
  }
77
92
  seed ^= see1 ^ see2;
78
93
  }
79
94
  if (i > 16) {
80
- seed = rapid_mix(rapid_read64(key, p) ^ secret[2], rapid_read64(key, p + 8) ^ seed ^ secret[1], rapid_mum);
95
+ seed = rapid_mix(rapid_read64(key, p) ^ secret[2], rapid_read64(key, p + 8) ^ seed ^ secret[1]);
81
96
  if (i > 32) {
82
- seed = rapid_mix(rapid_read64(key, p + 16) ^ secret[2], rapid_read64(key, p + 24) ^ seed, rapid_mum);
97
+ seed = rapid_mix(rapid_read64(key, p + 16) ^ secret[2], rapid_read64(key, p + 24) ^ seed);
83
98
  }
84
99
  }
85
100
  a = rapid_read64(key, p + i - 16);
@@ -87,13 +102,18 @@ function rapidhash_internal(key, seed, secret, rapid_mum) {
87
102
  }
88
103
  a ^= secret[1];
89
104
  b ^= seed;
90
- const m = rapid_mum(a, b);
91
- return rapid_mix((m & 0xffffffffffffffffn) ^ secret[0] ^ lenBI, (m >> 64n) ^ secret[1], rapid_mum);
105
+ return rapidhash_epilogue(a, b, secret, lenBI);
92
106
  }
93
107
  const defaultRapidMumBehaviour = 'fast';
94
108
  const rapidMumImplementations = {
95
- fast: rapid_mum_fast,
96
- protected: rapid_mum_protected,
109
+ fast: {
110
+ rapid_mix: rapid_mix_fast,
111
+ rapidhash_epilogue: rapidhash_epilogue_fast,
112
+ },
113
+ protected: {
114
+ rapid_mix: rapid_mix_protected,
115
+ rapidhash_epilogue: rapidhash_epilogue_protected,
116
+ },
97
117
  };
98
118
  function isBigUint64(value) {
99
119
  return value >= 0n && value <= 0xffffffffffffffffn;
@@ -118,15 +138,22 @@ function validateOptions(options) {
118
138
  return result;
119
139
  }
120
140
  const textEncoder = new TextEncoder();
141
+ const utf8BufferSize = 2048;
142
+ const stringLengthThresholdToUseBuffer = utf8BufferSize / 3;
143
+ const utf8Buffer = new Uint8Array(utf8BufferSize);
121
144
  function toDataView(message) {
122
- if (message instanceof DataView) {
123
- return message;
145
+ if (typeof message === 'string') {
146
+ if (message.length <= stringLengthThresholdToUseBuffer) {
147
+ const { written } = textEncoder.encodeInto(message, utf8Buffer);
148
+ return new DataView(utf8Buffer.buffer, 0, written);
149
+ }
150
+ const utf8bytes = textEncoder.encode(message);
151
+ return new DataView(utf8bytes.buffer, utf8bytes.byteOffset, utf8bytes.byteLength);
124
152
  }
125
153
  if (message instanceof Uint8Array) {
126
154
  return new DataView(message.buffer, message.byteOffset, message.byteLength);
127
155
  }
128
- const utf8bytes = textEncoder.encode(message);
129
- return new DataView(utf8bytes.buffer, utf8bytes.byteOffset, utf8bytes.byteLength);
156
+ return message;
130
157
  }
131
158
  /**
132
159
  * Calculate a 64-bit hash value of the given message.
@@ -138,7 +165,8 @@ function toDataView(message) {
138
165
  */
139
166
  function rapidhash(message, options) {
140
167
  const { seed, rapidMumBehaviour } = validateOptions(options);
141
- return rapidhash_internal(toDataView(message), seed, rapid_secret, rapidMumImplementations[rapidMumBehaviour]);
168
+ const { rapid_mix, rapidhash_epilogue } = rapidMumImplementations[rapidMumBehaviour];
169
+ return rapidhash_internal(toDataView(message), seed, rapid_secret, rapid_mix, rapidhash_epilogue);
142
170
  }
143
171
  exports.rapidhash = rapidhash;
144
172
  /**
@@ -151,7 +179,7 @@ exports.rapidhash = rapidhash;
151
179
  */
152
180
  function rapidhash_fast(message, options) {
153
181
  const { seed } = validateOptions(options);
154
- return rapidhash_internal(toDataView(message), seed, rapid_secret, rapid_mum_fast);
182
+ return rapidhash_internal(toDataView(message), seed, rapid_secret, rapid_mix_fast, rapidhash_epilogue_fast);
155
183
  }
156
184
  exports.rapidhash_fast = rapidhash_fast;
157
185
  /**
@@ -164,7 +192,7 @@ exports.rapidhash_fast = rapidhash_fast;
164
192
  */
165
193
  function rapidhash_protected(message, options) {
166
194
  const { seed } = validateOptions(options);
167
- return rapidhash_internal(toDataView(message), seed, rapid_secret, rapid_mum_protected);
195
+ return rapidhash_internal(toDataView(message), seed, rapid_secret, rapid_mix_protected, rapidhash_epilogue_protected);
168
196
  }
169
197
  exports.rapidhash_protected = rapidhash_protected;
170
198
  //# sourceMappingURL=rapidhash.js.map
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "rapidhash-js",
3
- "version": "1.0.1",
3
+ "version": "1.0.3",
4
4
  "description": "A TypeScript implementation of Rapidhash",
5
5
  "keywords": [
6
6
  "hash",
@@ -27,6 +27,7 @@
27
27
  },
28
28
  "main": "build/src/index.js",
29
29
  "files": [
30
- "build/src/**/*.{js,d.ts}"
30
+ "build/src/**/*.{js,d.ts}",
31
+ "CHANGELOG.md"
31
32
  ]
32
33
  }