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 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
- [![Actions Status](https://github.com/ducminhquan/base32-key/workflows/Node.js%20Package/badge.svg)](https://github.com/ducminhquan/base32-key/actions)
3
+ [![CI](https://github.com/ducminhquan/base32-key/actions/workflows/ci.yml/badge.svg)](https://github.com/ducminhquan/base32-key/actions/workflows/ci.yml)
4
4
  [![GitHub license](https://img.shields.io/github/license/ducminhquan/base32-key.svg)](https://github.com/ducminhquan/base32-key/blob/master/LICENSE)
5
5
  [![GitHub release](https://img.shields.io/github/release/ducminhquan/base32-key.svg)](https://github.com/ducminhquan/base32-key/releases/)
6
6
  [![GitHub tag](https://img.shields.io/github/tag/ducminhquan/base32-key.svg)](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.
@@ -1,3 +1,9 @@
1
- import { toHexString } from './lib/decode';
2
- import { fromHexString } from './lib/encode';
3
- export { fromHexString, toHexString };
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';
@@ -1,8 +1,17 @@
1
1
  "use strict";
2
2
  Object.defineProperty(exports, "__esModule", { value: true });
3
- exports.toHexString = exports.fromHexString = void 0;
4
- const decode_1 = require("./lib/decode");
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
- const encode_1 = require("./lib/encode");
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
- //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEseUNBQTJDO0FBR25CLDRGQUhmLG9CQUFXLE9BR2U7QUFGbkMseUNBQTZDO0FBRXBDLDhGQUZBLHNCQUFhLE9BRUEifQ==
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 HexString
15
+ * Decode a Base32 key to a hex string.
3
16
  *
4
- * ### Example (es module)
17
+ * ### Example
5
18
  * ```js
6
19
  * import { toHexString } from 'base32-key'
7
- * console.log(fromHexString('222ET-3ZZGN'))
20
+ * toHexString('222ET-3ZZGN')
21
+ * // => 'c0ffee'
22
+ * toHexString('222et 3zzgn', { normalize: true })
8
23
  * // => 'c0ffee'
9
24
  * ```
10
25
  *
11
- * ### Example (commonjs)
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
- * var toHexString = require('base32-key').toHexString;
14
- * console.log(toHexString('222ET-3ZZGN'))
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
- * @param keyString - Input Base32-Key.
19
- * @param grouped - Split the result into groups.
20
- * @param checked - Include the checksum into Base32-Key.
21
- * @param upperCase - Use uppercase or lowercase Base32-Key.
22
- * @returns Base-16 string.
23
- * @anotherNote Some other value.
59
+ * ### Example
60
+ * ```js
61
+ * formatInput('222et3zz')
62
+ * // => '222ET-3ZZ'
63
+ * ```
24
64
  */
25
- export declare const toHexString: (keyString: string, grouped?: boolean, checked?: boolean, upperCase?: boolean) => string;
65
+ export declare function formatInput(raw: string, options?: EncodeOptions): string;
@@ -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
- function decode(keyString, grouped, checked, upperCase) {
20
- const digits = upperCase ? utils_1.BASE_32_DIGITS : utils_1.BASE_32_DIGITS_LOWERCASE;
21
- const base32num = utils_1.baseDecode(keyString, digits);
22
- if (base32num == null ||
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
- if (checked) {
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
- throw new Error('Invalid');
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
- return utils_1.baseEncode(base32toBase16(base32num), utils_1.BASE_16_DIGITS);
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
- * Decode Base32 key to HexString
114
+ * Check a key without throwing, for example while the user is typing.
38
115
  *
39
- * ### Example (es module)
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
- * import { toHexString } from 'base32-key'
42
- * console.log(fromHexString('222ET-3ZZGN'))
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 (commonjs)
143
+ * ### Example
47
144
  * ```js
48
- * var toHexString = require('base32-key').toHexString;
49
- * console.log(toHexString('222ET-3ZZGN'))
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
- exports.toHexString = (keyString, grouped = true, checked = true, upperCase = true) => {
62
- const result = keyString
63
- .split('-')
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
- return result.substring(i);
73
- };
74
- //# sourceMappingURL=data:application/json;base64,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
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 from HexString
4
+ * Encode a hex string as a Base32 key.
3
5
  *
4
- * ### Example (es module)
6
+ * ### Example
5
7
  * ```js
6
8
  * import { fromHexString } from 'base32-key'
7
- * console.log(fromHexString('c0ffee'))
9
+ * fromHexString('c0ffee')
8
10
  * // => '222ET-3ZZGN'
11
+ * fromHexString('c0ffee', { grouped: false, case: 'lower' })
12
+ * // => 'nb99qj'
9
13
  * ```
10
14
  *
11
- * ### Example (commonjs)
12
- * ```js
13
- * var fromHexString = require('base32-key').fromHexString;
14
- * console.log(fromHexString('c0ffee'))
15
- * // => '222ET-3ZZGN'
16
- * ```
17
- *
18
- * @param base16String - Input HexString.
19
- * @param grouped - Split the result into groups.
20
- * @param checked - Include the checksum into Base32-Key.
21
- * @param upperCase - Use uppercase or lowercase Base32-Key.
22
- * @returns Base32-Key string.
23
- * @anotherNote Some other value.
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 const fromHexString: (base16String: string, grouped?: boolean, checked?: boolean, upperCase?: boolean) => string;
29
+ export declare function fromHexString(base16String: string, grouped?: boolean, checked?: boolean, upperCase?: boolean): string;