base32-key 1.0.8 → 1.1.0
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 +14 -0
- package/README.md +93 -1
- package/build/main/index.d.ts +9 -3
- package/build/main/index.js +13 -4
- package/build/main/lib/bigint.d.ts +14 -0
- package/build/main/lib/bigint.js +32 -0
- package/build/main/lib/decode.d.ts +54 -14
- package/build/main/lib/decode.js +123 -39
- package/build/main/lib/encode.d.ts +21 -17
- package/build/main/lib/encode.js +29 -41
- package/build/main/lib/errors.d.ts +22 -0
- package/build/main/lib/errors.js +19 -0
- package/build/main/lib/generate.d.ts +36 -0
- package/build/main/lib/generate.js +58 -0
- package/build/main/lib/options.d.ts +28 -0
- package/build/main/lib/options.js +35 -0
- package/build/module/index.d.ts +9 -3
- package/build/module/index.js +6 -4
- package/build/module/lib/bigint.d.ts +14 -0
- package/build/module/lib/bigint.js +27 -0
- package/build/module/lib/decode.d.ts +54 -14
- package/build/module/lib/decode.js +118 -38
- package/build/module/lib/encode.d.ts +21 -17
- package/build/module/lib/encode.js +25 -39
- package/build/module/lib/errors.d.ts +22 -0
- package/build/module/lib/errors.js +15 -0
- package/build/module/lib/generate.d.ts +36 -0
- package/build/module/lib/generate.js +54 -0
- package/build/module/lib/options.d.ts +28 -0
- package/build/module/lib/options.js +31 -0
- package/package.json +6 -7
package/CHANGELOG.md
CHANGED
|
@@ -2,6 +2,20 @@
|
|
|
2
2
|
|
|
3
3
|
All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
|
|
4
4
|
|
|
5
|
+
## [1.1.0](https://github.com/ducminhquan/base32-key/compare/v1.0.9...v1.1.0) (2026-11-22)
|
|
6
|
+
|
|
7
|
+
|
|
8
|
+
### Features
|
|
9
|
+
|
|
10
|
+
* options API, structured errors, validate, formatInput, generateKey and BigInt helpers ([7380edb](https://github.com/ducminhquan/base32-key/commit/7380edb42a442183a898d9785841ebf30cd1c876))
|
|
11
|
+
|
|
12
|
+
### [1.0.9](https://github.com/ducminhquan/base32-key/compare/v1.0.8...v1.0.9) (2026-11-22)
|
|
13
|
+
|
|
14
|
+
|
|
15
|
+
### Bug Fixes
|
|
16
|
+
|
|
17
|
+
* reject invalid hex input and handle zero/empty edge cases ([5ae92a7](https://github.com/ducminhquan/base32-key/commit/5ae92a73215cded9f9e92464e418692c886e43e3))
|
|
18
|
+
|
|
5
19
|
### [1.0.8](https://github.com/ducminhquan/base32-key/compare/v1.0.7...v1.0.8) (2020-09-28)
|
|
6
20
|
|
|
7
21
|
### [1.0.7](https://github.com/ducminhquan/base32-key/compare/v1.0.6...v1.0.7) (2020-09-28)
|
package/README.md
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
# base32-key - A base 32 encoding for binary strings
|
|
2
2
|
|
|
3
|
-
[](https://github.com/ducminhquan/base32-key/actions/workflows/ci.yml)
|
|
4
4
|
[](https://github.com/ducminhquan/base32-key/blob/master/LICENSE)
|
|
5
5
|
[](https://github.com/ducminhquan/base32-key/releases/)
|
|
6
6
|
[](https://GitHub.com/ducminhquan/base32-key/tags/)
|
|
@@ -40,8 +40,100 @@ console.log(toHexString('222ET-3ZZGN'));
|
|
|
40
40
|
// => 'c0ffee'
|
|
41
41
|
```
|
|
42
42
|
|
|
43
|
+
### Options
|
|
44
|
+
|
|
45
|
+
Every function takes an optional options object. The old positional booleans
|
|
46
|
+
(`fromHexString(hex, grouped, checked, upperCase)`) still work but are deprecated.
|
|
47
|
+
|
|
48
|
+
| Option | Default | Meaning |
|
|
49
|
+
| ----------- | --------- | ---------------------------------------------------------------------------- |
|
|
50
|
+
| `grouped` | `true` | Split the key into hyphen-separated groups of 4 data digits. |
|
|
51
|
+
| `checked` | `true` | Add a CRC-5 check digit (one per group when grouped). |
|
|
52
|
+
| `case` | `'upper'` | `'upper'` or `'lower'` alphabet. |
|
|
53
|
+
| `normalize` | see below | Decoding only: ignore whitespace, letter case and where the hyphens are put. |
|
|
54
|
+
|
|
55
|
+
`normalize` defaults to `false` for `toHexString` and `toBigInt` and to `true` for `validate`.
|
|
56
|
+
|
|
57
|
+
```js
|
|
58
|
+
fromHexString('c0ffee', { grouped: false, case: 'lower' });
|
|
59
|
+
// => 'nb99qj'
|
|
60
|
+
toHexString(' 222et 3zzgn ', { normalize: true });
|
|
61
|
+
// => 'c0ffee'
|
|
62
|
+
```
|
|
63
|
+
|
|
64
|
+
### Checking a key while the user types
|
|
65
|
+
|
|
66
|
+
```js
|
|
67
|
+
import { formatInput, validate } from 'base32-key';
|
|
68
|
+
|
|
69
|
+
formatInput('222et3zz');
|
|
70
|
+
// => '222ET-3ZZ' (put this back in the input field)
|
|
71
|
+
|
|
72
|
+
validate('222ET-3ZZGX');
|
|
73
|
+
// => { valid: false, invalidGroups: [1], code: 'CHECKSUM_MISMATCH' }
|
|
74
|
+
```
|
|
75
|
+
|
|
76
|
+
`invalidGroups` holds 0-based group indexes, so you can highlight exactly the group that was mistyped.
|
|
77
|
+
|
|
78
|
+
### Errors
|
|
79
|
+
|
|
80
|
+
Invalid input throws a `Base32KeyError` with a `code` and the `invalidGroups`:
|
|
81
|
+
|
|
82
|
+
```js
|
|
83
|
+
import { Base32KeyError, toHexString } from 'base32-key';
|
|
84
|
+
|
|
85
|
+
try {
|
|
86
|
+
toHexString('222EX-3ZZGN');
|
|
87
|
+
} catch (error) {
|
|
88
|
+
if (error instanceof Base32KeyError) {
|
|
89
|
+
error.code; // 'CHECKSUM_MISMATCH'
|
|
90
|
+
error.invalidGroups; // [0]
|
|
91
|
+
}
|
|
92
|
+
}
|
|
93
|
+
```
|
|
94
|
+
|
|
95
|
+
| Code | When |
|
|
96
|
+
| ------------------- | ------------------------------------------------------------- |
|
|
97
|
+
| `INVALID_HEX` | The hex input is empty or has non-hex characters. |
|
|
98
|
+
| `INVALID_CHARACTER` | A group has a character outside the alphabet (e.g. `0`, `O`). |
|
|
99
|
+
| `INVALID_LENGTH` | The key or a group has the wrong length. |
|
|
100
|
+
| `CHECKSUM_MISMATCH` | A check digit does not match its group. |
|
|
101
|
+
| `GENERATION_FAILED` | `generateKey` found no key accepted by `filter`. |
|
|
102
|
+
| `NO_RANDOM_SOURCE` | No `crypto.getRandomValues`; pass the `random` option. |
|
|
103
|
+
|
|
104
|
+
A non-string argument throws a `TypeError`.
|
|
105
|
+
|
|
106
|
+
### Generating keys
|
|
107
|
+
|
|
108
|
+
```js
|
|
109
|
+
import { generateKey } from 'base32-key';
|
|
110
|
+
|
|
111
|
+
generateKey();
|
|
112
|
+
// => e.g. 'K7RQX-2HMTD-9WCJA-PNE4F' (4 groups, 80 random bits)
|
|
113
|
+
|
|
114
|
+
generateKey({ groups: 3, filter: (key) => !blocklist.has(key) });
|
|
115
|
+
```
|
|
116
|
+
|
|
117
|
+
`generateKey` uses `crypto.getRandomValues` (browsers, Node.js 19+). On older
|
|
118
|
+
Node.js pass `random: (n) => require('crypto').randomBytes(n)`.
|
|
119
|
+
|
|
120
|
+
### Numbers
|
|
121
|
+
|
|
122
|
+
```js
|
|
123
|
+
import { fromBigInt, toBigInt } from 'base32-key';
|
|
124
|
+
|
|
125
|
+
fromBigInt(12648430n);
|
|
126
|
+
// => '222ET-3ZZGN'
|
|
127
|
+
toBigInt('222ET-3ZZGN');
|
|
128
|
+
// => 12648430n
|
|
129
|
+
```
|
|
130
|
+
|
|
43
131
|
<!-- cspell:enable -->
|
|
44
132
|
|
|
133
|
+
## Releasing
|
|
134
|
+
|
|
135
|
+
Releases run from GitHub Actions and are staged on npm for approval. See [RELEASING.md](.github/RELEASING.md).
|
|
136
|
+
|
|
45
137
|
## A base 32 encoding for binary strings
|
|
46
138
|
|
|
47
139
|
This document describes a human-readable base 32 encoding for binary strings. It is intended to be used for e.g. product keys, which may be printed on paper and entered using a keyboard. As such, it is important that codes are easy to read, easy to type, and that errors can be detected.
|
package/build/main/index.d.ts
CHANGED
|
@@ -1,3 +1,9 @@
|
|
|
1
|
-
|
|
2
|
-
|
|
3
|
-
export { fromHexString
|
|
1
|
+
export { formatInput, toHexString, validate } from './lib/decode';
|
|
2
|
+
export type { ValidationResult } from './lib/decode';
|
|
3
|
+
export { fromHexString } from './lib/encode';
|
|
4
|
+
export { Base32KeyError } from './lib/errors';
|
|
5
|
+
export type { Base32KeyErrorCode } from './lib/errors';
|
|
6
|
+
export { fromBigInt, toBigInt } from './lib/bigint';
|
|
7
|
+
export { generateKey } from './lib/generate';
|
|
8
|
+
export type { GenerateOptions } from './lib/generate';
|
|
9
|
+
export type { DecodeOptions, EncodeOptions, KeyCase } from './lib/options';
|
package/build/main/index.js
CHANGED
|
@@ -1,8 +1,17 @@
|
|
|
1
1
|
"use strict";
|
|
2
2
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
3
|
-
exports.
|
|
4
|
-
|
|
3
|
+
exports.generateKey = exports.toBigInt = exports.fromBigInt = exports.Base32KeyError = exports.fromHexString = exports.validate = exports.toHexString = exports.formatInput = void 0;
|
|
4
|
+
var decode_1 = require("./lib/decode");
|
|
5
|
+
Object.defineProperty(exports, "formatInput", { enumerable: true, get: function () { return decode_1.formatInput; } });
|
|
5
6
|
Object.defineProperty(exports, "toHexString", { enumerable: true, get: function () { return decode_1.toHexString; } });
|
|
6
|
-
|
|
7
|
+
Object.defineProperty(exports, "validate", { enumerable: true, get: function () { return decode_1.validate; } });
|
|
8
|
+
var encode_1 = require("./lib/encode");
|
|
7
9
|
Object.defineProperty(exports, "fromHexString", { enumerable: true, get: function () { return encode_1.fromHexString; } });
|
|
8
|
-
|
|
10
|
+
var errors_1 = require("./lib/errors");
|
|
11
|
+
Object.defineProperty(exports, "Base32KeyError", { enumerable: true, get: function () { return errors_1.Base32KeyError; } });
|
|
12
|
+
var bigint_1 = require("./lib/bigint");
|
|
13
|
+
Object.defineProperty(exports, "fromBigInt", { enumerable: true, get: function () { return bigint_1.fromBigInt; } });
|
|
14
|
+
Object.defineProperty(exports, "toBigInt", { enumerable: true, get: function () { return bigint_1.toBigInt; } });
|
|
15
|
+
var generate_1 = require("./lib/generate");
|
|
16
|
+
Object.defineProperty(exports, "generateKey", { enumerable: true, get: function () { return generate_1.generateKey; } });
|
|
17
|
+
//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsdUNBQWtFO0FBQXpELHFHQUFBLFdBQVcsT0FBQTtBQUFFLHFHQUFBLFdBQVcsT0FBQTtBQUFFLGtHQUFBLFFBQVEsT0FBQTtBQUUzQyx1Q0FBNkM7QUFBcEMsdUdBQUEsYUFBYSxPQUFBO0FBQ3RCLHVDQUE4QztBQUFyQyx3R0FBQSxjQUFjLE9BQUE7QUFFdkIsdUNBQW9EO0FBQTNDLG9HQUFBLFVBQVUsT0FBQTtBQUFFLGtHQUFBLFFBQVEsT0FBQTtBQUM3QiwyQ0FBNkM7QUFBcEMsdUdBQUEsV0FBVyxPQUFBIn0=
|
|
@@ -0,0 +1,14 @@
|
|
|
1
|
+
import { DecodeOptions, EncodeOptions } from './options';
|
|
2
|
+
/**
|
|
3
|
+
* Encode a non-negative BigInt as a Base32 key.
|
|
4
|
+
*
|
|
5
|
+
* @example `fromBigInt(BigInt(12648430))` returns `'222ET-3ZZGN'`.
|
|
6
|
+
*/
|
|
7
|
+
export declare function fromBigInt(value: bigint, options?: EncodeOptions): string;
|
|
8
|
+
/**
|
|
9
|
+
* Decode a Base32 key to a BigInt.
|
|
10
|
+
*
|
|
11
|
+
* @example `toBigInt('222ET-3ZZGN')` returns `12648430n`.
|
|
12
|
+
* @throws {@link Base32KeyError} like {@link toHexString}.
|
|
13
|
+
*/
|
|
14
|
+
export declare function toBigInt(keyString: string, options?: DecodeOptions): bigint;
|
|
@@ -0,0 +1,32 @@
|
|
|
1
|
+
"use strict";
|
|
2
|
+
Object.defineProperty(exports, "__esModule", { value: true });
|
|
3
|
+
exports.toBigInt = exports.fromBigInt = void 0;
|
|
4
|
+
const decode_1 = require("./decode");
|
|
5
|
+
const encode_1 = require("./encode");
|
|
6
|
+
// cspell: disable
|
|
7
|
+
/**
|
|
8
|
+
* Encode a non-negative BigInt as a Base32 key.
|
|
9
|
+
*
|
|
10
|
+
* @example `fromBigInt(BigInt(12648430))` returns `'222ET-3ZZGN'`.
|
|
11
|
+
*/
|
|
12
|
+
function fromBigInt(value, options) {
|
|
13
|
+
if (typeof value !== 'bigint') {
|
|
14
|
+
throw new TypeError('Invalid: expected a bigint');
|
|
15
|
+
}
|
|
16
|
+
if (value < BigInt(0)) {
|
|
17
|
+
throw new RangeError('Invalid: expected a non-negative bigint');
|
|
18
|
+
}
|
|
19
|
+
return encode_1.fromHexString(value.toString(16), options);
|
|
20
|
+
}
|
|
21
|
+
exports.fromBigInt = fromBigInt;
|
|
22
|
+
/**
|
|
23
|
+
* Decode a Base32 key to a BigInt.
|
|
24
|
+
*
|
|
25
|
+
* @example `toBigInt('222ET-3ZZGN')` returns `12648430n`.
|
|
26
|
+
* @throws {@link Base32KeyError} like {@link toHexString}.
|
|
27
|
+
*/
|
|
28
|
+
function toBigInt(keyString, options) {
|
|
29
|
+
return BigInt(`0x${decode_1.toHexString(keyString, options)}`);
|
|
30
|
+
}
|
|
31
|
+
exports.toBigInt = toBigInt;
|
|
32
|
+
//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmlnaW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2xpYi9iaWdpbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEscUNBQXVDO0FBQ3ZDLHFDQUF5QztBQUd6QyxrQkFBa0I7QUFDbEI7Ozs7R0FJRztBQUNILFNBQWdCLFVBQVUsQ0FBQyxLQUFhLEVBQUUsT0FBdUI7SUFDL0QsSUFBSSxPQUFPLEtBQUssS0FBSyxRQUFRLEVBQUU7UUFDN0IsTUFBTSxJQUFJLFNBQVMsQ0FBQyw0QkFBNEIsQ0FBQyxDQUFDO0tBQ25EO0lBQ0QsSUFBSSxLQUFLLEdBQUcsTUFBTSxDQUFDLENBQUMsQ0FBQyxFQUFFO1FBQ3JCLE1BQU0sSUFBSSxVQUFVLENBQUMseUNBQXlDLENBQUMsQ0FBQztLQUNqRTtJQUNELE9BQU8sc0JBQWEsQ0FBQyxLQUFLLENBQUMsUUFBUSxDQUFDLEVBQUUsQ0FBQyxFQUFFLE9BQU8sQ0FBQyxDQUFDO0FBQ3BELENBQUM7QUFSRCxnQ0FRQztBQUVEOzs7OztHQUtHO0FBQ0gsU0FBZ0IsUUFBUSxDQUFDLFNBQWlCLEVBQUUsT0FBdUI7SUFDakUsT0FBTyxNQUFNLENBQUMsS0FBSyxvQkFBVyxDQUFDLFNBQVMsRUFBRSxPQUFPLENBQUMsRUFBRSxDQUFDLENBQUM7QUFDeEQsQ0FBQztBQUZELDRCQUVDIn0=
|
|
@@ -1,25 +1,65 @@
|
|
|
1
|
+
import { Base32KeyErrorCode } from './errors';
|
|
2
|
+
import { DecodeOptions, EncodeOptions, ResolvedOptions } from './options';
|
|
3
|
+
/** Splits a key into the groups that are decoded independently. */
|
|
4
|
+
export declare function splitKey(keyString: string, options: ResolvedOptions): string[];
|
|
5
|
+
/** Result of {@link validate}. */
|
|
6
|
+
export interface ValidationResult {
|
|
7
|
+
/** `true` when the whole key decodes and every check digit matches. */
|
|
8
|
+
readonly valid: boolean;
|
|
9
|
+
/** 0-based indexes of the groups that are invalid. */
|
|
10
|
+
readonly invalidGroups: readonly number[];
|
|
11
|
+
/** Reason of the first invalid group, when the key is invalid. */
|
|
12
|
+
readonly code?: Base32KeyErrorCode;
|
|
13
|
+
}
|
|
1
14
|
/**
|
|
2
|
-
* Decode Base32 key to
|
|
15
|
+
* Decode a Base32 key to a hex string.
|
|
3
16
|
*
|
|
4
|
-
* ### Example
|
|
17
|
+
* ### Example
|
|
5
18
|
* ```js
|
|
6
19
|
* import { toHexString } from 'base32-key'
|
|
7
|
-
*
|
|
20
|
+
* toHexString('222ET-3ZZGN')
|
|
21
|
+
* // => 'c0ffee'
|
|
22
|
+
* toHexString('222et 3zzgn', { normalize: true })
|
|
8
23
|
* // => 'c0ffee'
|
|
9
24
|
* ```
|
|
10
25
|
*
|
|
11
|
-
*
|
|
26
|
+
* @param keyString - Input Base32 key.
|
|
27
|
+
* @param options - Decoding options, or the legacy `grouped` boolean.
|
|
28
|
+
* @returns Hex string without leading zeroes.
|
|
29
|
+
* @throws {@link Base32KeyError} if the key is empty, malformed or fails a
|
|
30
|
+
* checksum; its `invalidGroups` lists the groups at fault.
|
|
31
|
+
*/
|
|
32
|
+
export declare function toHexString(keyString: string, options?: DecodeOptions): string;
|
|
33
|
+
/**
|
|
34
|
+
* @deprecated Pass an options object instead of positional booleans.
|
|
35
|
+
* @param keyString - Input Base32 key.
|
|
36
|
+
* @param grouped - The key is split into groups.
|
|
37
|
+
* @param checked - The key includes check digits.
|
|
38
|
+
* @param upperCase - The key uses the uppercase alphabet.
|
|
39
|
+
*/
|
|
40
|
+
export declare function toHexString(keyString: string, grouped?: boolean, checked?: boolean, upperCase?: boolean): string;
|
|
41
|
+
/**
|
|
42
|
+
* Check a key without throwing, for example while the user is typing.
|
|
43
|
+
*
|
|
44
|
+
* Input is normalized by default (whitespace, letter case and hyphen
|
|
45
|
+
* placement are ignored); pass `normalize: false` to check it as is.
|
|
46
|
+
*
|
|
47
|
+
* ### Example
|
|
12
48
|
* ```js
|
|
13
|
-
*
|
|
14
|
-
*
|
|
15
|
-
* // => 'c0ffee'
|
|
49
|
+
* validate('222ET-3ZZGX')
|
|
50
|
+
* // => { valid: false, invalidGroups: [1], code: 'CHECKSUM_MISMATCH' }
|
|
16
51
|
* ```
|
|
52
|
+
*/
|
|
53
|
+
export declare function validate(keyString: string, options?: DecodeOptions): ValidationResult;
|
|
54
|
+
/**
|
|
55
|
+
* Format raw user input as a key: drops whitespace, applies the alphabet's
|
|
56
|
+
* letter case and inserts hyphens between groups. Partial input is fine.
|
|
57
|
+
* Characters outside the alphabet are kept so `validate` can flag them.
|
|
17
58
|
*
|
|
18
|
-
*
|
|
19
|
-
*
|
|
20
|
-
*
|
|
21
|
-
*
|
|
22
|
-
*
|
|
23
|
-
* @anotherNote Some other value.
|
|
59
|
+
* ### Example
|
|
60
|
+
* ```js
|
|
61
|
+
* formatInput('222et3zz')
|
|
62
|
+
* // => '222ET-3ZZ'
|
|
63
|
+
* ```
|
|
24
64
|
*/
|
|
25
|
-
export declare
|
|
65
|
+
export declare function formatInput(raw: string, options?: EncodeOptions): string;
|
package/build/main/lib/decode.js
CHANGED
|
@@ -1,6 +1,8 @@
|
|
|
1
1
|
"use strict";
|
|
2
2
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
3
|
-
exports.toHexString = void 0;
|
|
3
|
+
exports.formatInput = exports.validate = exports.toHexString = exports.splitKey = void 0;
|
|
4
|
+
const errors_1 = require("./errors");
|
|
5
|
+
const options_1 = require("./options");
|
|
4
6
|
const utils_1 = require("./utils");
|
|
5
7
|
function base32toBase16(base32Numbers) {
|
|
6
8
|
while (base32Numbers.length % 4 != 0) {
|
|
@@ -16,59 +18,141 @@ function base32toBase16(base32Numbers) {
|
|
|
16
18
|
}
|
|
17
19
|
return base16Numbers;
|
|
18
20
|
}
|
|
19
|
-
|
|
20
|
-
|
|
21
|
-
|
|
22
|
-
|
|
23
|
-
(grouped && base32num.length != 4 + (checked ? 1 : 0))) {
|
|
24
|
-
throw new Error('Invalid');
|
|
21
|
+
/** Splits a key into the groups that are decoded independently. */
|
|
22
|
+
function splitKey(keyString, options) {
|
|
23
|
+
if (!options.normalize) {
|
|
24
|
+
return keyString.split('-');
|
|
25
25
|
}
|
|
26
|
-
|
|
26
|
+
const cleaned = keyString.replace(/[\s-]+/g, '');
|
|
27
|
+
const folded = options.upperCase
|
|
28
|
+
? cleaned.toUpperCase()
|
|
29
|
+
: cleaned.toLowerCase();
|
|
30
|
+
if (!options.grouped) {
|
|
31
|
+
return [folded];
|
|
32
|
+
}
|
|
33
|
+
const size = options.checked ? 5 : 4;
|
|
34
|
+
const groups = [];
|
|
35
|
+
for (let i = 0; i < folded.length; i += size) {
|
|
36
|
+
groups.push(folded.substring(i, i + size));
|
|
37
|
+
}
|
|
38
|
+
return groups.length > 0 ? groups : [''];
|
|
39
|
+
}
|
|
40
|
+
exports.splitKey = splitKey;
|
|
41
|
+
function decodeGroup(group, options) {
|
|
42
|
+
const alphabet = options.upperCase
|
|
43
|
+
? utils_1.BASE_32_DIGITS
|
|
44
|
+
: utils_1.BASE_32_DIGITS_LOWERCASE;
|
|
45
|
+
const base32num = utils_1.baseDecode(group, alphabet);
|
|
46
|
+
if (base32num == null) {
|
|
47
|
+
return { ok: false, code: 'INVALID_CHARACTER' };
|
|
48
|
+
}
|
|
49
|
+
if (base32num.length === 0 ||
|
|
50
|
+
(options.grouped && base32num.length != 4 + (options.checked ? 1 : 0))) {
|
|
51
|
+
return { ok: false, code: 'INVALID_LENGTH' };
|
|
52
|
+
}
|
|
53
|
+
if (options.checked) {
|
|
27
54
|
// Remove and verify check digit.
|
|
28
55
|
const check = base32num.pop();
|
|
29
56
|
if (utils_1.calculateCrc5(base32num) !== check) {
|
|
30
|
-
|
|
57
|
+
return { ok: false, code: 'CHECKSUM_MISMATCH' };
|
|
58
|
+
}
|
|
59
|
+
}
|
|
60
|
+
return {
|
|
61
|
+
ok: true,
|
|
62
|
+
hex: utils_1.baseEncode(base32toBase16(base32num), utils_1.BASE_16_DIGITS),
|
|
63
|
+
};
|
|
64
|
+
}
|
|
65
|
+
const MESSAGES = {
|
|
66
|
+
INVALID_CHARACTER: 'a character outside the alphabet',
|
|
67
|
+
INVALID_LENGTH: 'the wrong length',
|
|
68
|
+
CHECKSUM_MISMATCH: 'a check digit that does not match',
|
|
69
|
+
};
|
|
70
|
+
function analyze(keyString, options) {
|
|
71
|
+
const groups = splitKey(keyString, options);
|
|
72
|
+
const invalidGroups = [];
|
|
73
|
+
let code;
|
|
74
|
+
let hex = '';
|
|
75
|
+
groups.forEach((group, index) => {
|
|
76
|
+
const result = decodeGroup(group, options);
|
|
77
|
+
if (result.ok) {
|
|
78
|
+
hex += result.hex;
|
|
79
|
+
}
|
|
80
|
+
else {
|
|
81
|
+
invalidGroups.push(index);
|
|
82
|
+
code = code || result.code;
|
|
31
83
|
}
|
|
84
|
+
});
|
|
85
|
+
return { hex, invalidGroups, code };
|
|
86
|
+
}
|
|
87
|
+
function decodeKey(keyString, options) {
|
|
88
|
+
if (typeof keyString !== 'string') {
|
|
89
|
+
throw new TypeError('Invalid: expected a string');
|
|
90
|
+
}
|
|
91
|
+
const { hex, invalidGroups, code } = analyze(keyString, options);
|
|
92
|
+
if (code !== undefined) {
|
|
93
|
+
const where = invalidGroups.length === 1
|
|
94
|
+
? `group ${invalidGroups[0] + 1}`
|
|
95
|
+
: `groups ${invalidGroups.map((i) => i + 1).join(', ')}`;
|
|
96
|
+
throw new errors_1.Base32KeyError(code, `Invalid key: ${where} ${invalidGroups.length === 1 ? 'has' : 'have'} ${MESSAGES[code]}`, invalidGroups);
|
|
97
|
+
}
|
|
98
|
+
// Trim leading zeroes from result.
|
|
99
|
+
let i = 0;
|
|
100
|
+
const zero = utils_1.BASE_16_DIGITS.charAt(0);
|
|
101
|
+
while (i < hex.length - 1 && hex.charAt(i) === zero) {
|
|
102
|
+
++i;
|
|
32
103
|
}
|
|
33
|
-
|
|
104
|
+
// A key that encodes the value zero may carry no data digits at all
|
|
105
|
+
// (e.g. the key "2" without groups but with a checksum), which decodes to "".
|
|
106
|
+
return hex.substring(i) || zero;
|
|
107
|
+
}
|
|
108
|
+
function toHexString(keyString, ...args) {
|
|
109
|
+
return decodeKey(keyString, options_1.resolveOptions(args));
|
|
34
110
|
}
|
|
111
|
+
exports.toHexString = toHexString;
|
|
35
112
|
// cspell: disable
|
|
36
113
|
/**
|
|
37
|
-
*
|
|
114
|
+
* Check a key without throwing, for example while the user is typing.
|
|
38
115
|
*
|
|
39
|
-
*
|
|
116
|
+
* Input is normalized by default (whitespace, letter case and hyphen
|
|
117
|
+
* placement are ignored); pass `normalize: false` to check it as is.
|
|
118
|
+
*
|
|
119
|
+
* ### Example
|
|
40
120
|
* ```js
|
|
41
|
-
*
|
|
42
|
-
*
|
|
43
|
-
* // => 'c0ffee'
|
|
121
|
+
* validate('222ET-3ZZGX')
|
|
122
|
+
* // => { valid: false, invalidGroups: [1], code: 'CHECKSUM_MISMATCH' }
|
|
44
123
|
* ```
|
|
124
|
+
*/
|
|
125
|
+
// cspell: enable
|
|
126
|
+
function validate(keyString, options = {}) {
|
|
127
|
+
if (typeof keyString !== 'string') {
|
|
128
|
+
throw new TypeError('Invalid: expected a string');
|
|
129
|
+
}
|
|
130
|
+
const resolved = options_1.resolveOptions([options], true);
|
|
131
|
+
const { invalidGroups, code } = analyze(keyString, resolved);
|
|
132
|
+
return code === undefined
|
|
133
|
+
? { valid: true, invalidGroups }
|
|
134
|
+
: { valid: false, invalidGroups, code };
|
|
135
|
+
}
|
|
136
|
+
exports.validate = validate;
|
|
137
|
+
// cspell: disable
|
|
138
|
+
/**
|
|
139
|
+
* Format raw user input as a key: drops whitespace, applies the alphabet's
|
|
140
|
+
* letter case and inserts hyphens between groups. Partial input is fine.
|
|
141
|
+
* Characters outside the alphabet are kept so `validate` can flag them.
|
|
45
142
|
*
|
|
46
|
-
* ### Example
|
|
143
|
+
* ### Example
|
|
47
144
|
* ```js
|
|
48
|
-
*
|
|
49
|
-
*
|
|
50
|
-
* // => 'c0ffee'
|
|
145
|
+
* formatInput('222et3zz')
|
|
146
|
+
* // => '222ET-3ZZ'
|
|
51
147
|
* ```
|
|
52
|
-
*
|
|
53
|
-
* @param keyString - Input Base32-Key.
|
|
54
|
-
* @param grouped - Split the result into groups.
|
|
55
|
-
* @param checked - Include the checksum into Base32-Key.
|
|
56
|
-
* @param upperCase - Use uppercase or lowercase Base32-Key.
|
|
57
|
-
* @returns Base-16 string.
|
|
58
|
-
* @anotherNote Some other value.
|
|
59
148
|
*/
|
|
60
149
|
// cspell: enable
|
|
61
|
-
|
|
62
|
-
|
|
63
|
-
|
|
64
|
-
.map((k) => decode(k, grouped, checked, upperCase))
|
|
65
|
-
.join('');
|
|
66
|
-
// Trim leading zeroes from result.
|
|
67
|
-
let i = 0;
|
|
68
|
-
const zero = utils_1.BASE_16_DIGITS.charAt(0);
|
|
69
|
-
while (i < result.length - 1 && result.charAt(i) === zero) {
|
|
70
|
-
++i;
|
|
150
|
+
function formatInput(raw, options = {}) {
|
|
151
|
+
if (typeof raw !== 'string') {
|
|
152
|
+
throw new TypeError('Invalid: expected a string');
|
|
71
153
|
}
|
|
72
|
-
|
|
73
|
-
|
|
74
|
-
|
|
154
|
+
const resolved = options_1.resolveOptions([options], true);
|
|
155
|
+
return splitKey(raw, resolved).join(resolved.grouped ? '-' : '');
|
|
156
|
+
}
|
|
157
|
+
exports.formatInput = formatInput;
|
|
158
|
+
//# sourceMappingURL=data:application/json;base64,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
|
|
@@ -1,25 +1,29 @@
|
|
|
1
|
+
import { EncodeOptions } from './options';
|
|
2
|
+
export declare function encodeBase32(base32Numbers: number[], grouped: boolean, checked: boolean, upperCase: boolean, keepLeadingZeros?: boolean): string;
|
|
1
3
|
/**
|
|
2
|
-
* Encode Base32 key
|
|
4
|
+
* Encode a hex string as a Base32 key.
|
|
3
5
|
*
|
|
4
|
-
* ### Example
|
|
6
|
+
* ### Example
|
|
5
7
|
* ```js
|
|
6
8
|
* import { fromHexString } from 'base32-key'
|
|
7
|
-
*
|
|
9
|
+
* fromHexString('c0ffee')
|
|
8
10
|
* // => '222ET-3ZZGN'
|
|
11
|
+
* fromHexString('c0ffee', { grouped: false, case: 'lower' })
|
|
12
|
+
* // => 'nb99qj'
|
|
9
13
|
* ```
|
|
10
14
|
*
|
|
11
|
-
*
|
|
12
|
-
*
|
|
13
|
-
*
|
|
14
|
-
*
|
|
15
|
-
*
|
|
16
|
-
|
|
17
|
-
|
|
18
|
-
|
|
19
|
-
* @
|
|
20
|
-
* @param
|
|
21
|
-
* @param
|
|
22
|
-
* @
|
|
23
|
-
* @
|
|
15
|
+
* @param base16String - Input hex string (an optional `0x` prefix is allowed).
|
|
16
|
+
* @param options - Encoding options, or the legacy `grouped` boolean.
|
|
17
|
+
* @returns Base32 key.
|
|
18
|
+
* @throws {@link Base32KeyError} with code `INVALID_HEX` if `base16String` is
|
|
19
|
+
* empty or contains non-hex characters.
|
|
20
|
+
*/
|
|
21
|
+
export declare function fromHexString(base16String: string, options?: EncodeOptions): string;
|
|
22
|
+
/**
|
|
23
|
+
* @deprecated Pass an options object instead of positional booleans.
|
|
24
|
+
* @param base16String - Input hex string.
|
|
25
|
+
* @param grouped - Split the key into groups.
|
|
26
|
+
* @param checked - Add check digits.
|
|
27
|
+
* @param upperCase - Use the uppercase alphabet.
|
|
24
28
|
*/
|
|
25
|
-
export declare
|
|
29
|
+
export declare function fromHexString(base16String: string, grouped?: boolean, checked?: boolean, upperCase?: boolean): string;
|