@nakanoaas/uuid58 0.0.4 → 0.0.5

package/README.md

@@ -86,6 +86,21 @@ function uuid58Encode(uuid: string): string;
 - **Returns:** A Base58-encoded string
 - **Throws:** `InvalidUuidError` if the input is not a valid UUID
 
+### `uuid58EncodeSafe(uuid: string)`
+
+Converts a standard UUID string to a Base58-encoded format, but instead of
+throwing an error for invalid input, it returns an `InvalidUuidError` instance.
+
+```typescript
+function uuid58EncodeSafe(uuid: string): string | InvalidUuidError;
+```
+
+- **Parameters:**
+  - `uuid`: The UUID string to encode (with or without hyphens)
+- **Returns:** A Base58-encoded string, or an `InvalidUuidError` if the input is
+  not a valid UUID
+- **Note:** This function does not throw; it returns the error object instead.
+
 ### `uuid58Decode(encoded: string)`
 
 Converts a Base58-encoded string back to a standard UUID format.
@@ -100,6 +115,22 @@ function uuid58Decode(encoded: string): string;
 - **Throws:** `InvalidBase58Error` if the input contains invalid Base58
   characters
 
+### `uuid58DecodeSafe(encoded: string)`
+
+Converts a Base58-encoded string back to a standard UUID format, but instead of
+throwing an error for invalid input, it returns an `InvalidBase58Error`
+instance.
+
+```typescript
+function uuid58DecodeSafe(encoded: string): string | InvalidBase58Error;
+```
+
+- **Parameters:**
+  - `encoded`: The Base58-encoded string to decode
+- **Returns:** A standard UUID string (lowercase, with hyphens), or an
+  `InvalidBase58Error` if the input contains invalid Base58 characters
+- **Note:** This function does not throw; it returns the error object instead.
+
 ## Why uuid58?
 
 Standard UUIDs are 36 characters long (including hyphens), which can be

package/esm/decode.d.ts

@@ -5,6 +5,23 @@
 export declare class InvalidBase58Error extends Error {
     constructor(base58: string);
 }
+/**
+ * Converts a Base58-encoded string back to a standard UUID format, but instead of
+ * throwing an error for invalid input, it returns an `InvalidBase58Error`
+ * instance.
+ *
+ * @param base58 - The Base58-encoded string to decode
+ * @returns A standard UUID string (lowercase, with hyphens), or an
+ *   `InvalidBase58Error` if the input contains invalid Base58 characters
+ * @note This function does not throw; it returns the error object instead.
+ *
+ * @example
+ * ```typescript
+ * const uuid = uuid58DecodeSafe("XDY9dmBbcMBXqcRvYw8xJ2"); // returns "f4b247fd-1f87-45d4-aa06-1c6fc0a8dfaf"
+ * const error = uuid58DecodeSafe("invalid"); // returns InvalidBase58Error
+ * ```
+ */
+export declare function uuid58DecodeSafe(base58: string): string | InvalidBase58Error;
 /**
  * Converts a Base58-encoded string back to a standard UUID string format.
  *

package/esm/decode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"decode.d.ts","sourceRoot":"","sources":["../src/decode.ts"],"names":[],"mappings":"AAQA;;;GAGG;AACH,qBAAa,kBAAmB,SAAQ,KAAK;gBAK/B,MAAM,EAAE,MAAM;CAG3B;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CA0BnD"}
+{"version":3,"file":"decode.d.ts","sourceRoot":"","sources":["../src/decode.ts"],"names":[],"mappings":"AAQA;;;GAGG;AACH,qBAAa,kBAAmB,SAAQ,KAAK;gBAK/B,MAAM,EAAE,MAAM;CAG3B;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,kBAAkB,CA0B5E;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CA0BnD"}

package/esm/decode.js

@@ -18,6 +18,45 @@ _a = InvalidBase58Error;
 (() => {
     _a.prototype.name = "InvalidBase58Error";
 })();
+/**
+ * Converts a Base58-encoded string back to a standard UUID format, but instead of
+ * throwing an error for invalid input, it returns an `InvalidBase58Error`
+ * instance.
+ *
+ * @param base58 - The Base58-encoded string to decode
+ * @returns A standard UUID string (lowercase, with hyphens), or an
+ *   `InvalidBase58Error` if the input contains invalid Base58 characters
+ * @note This function does not throw; it returns the error object instead.
+ *
+ * @example
+ * ```typescript
+ * const uuid = uuid58DecodeSafe("XDY9dmBbcMBXqcRvYw8xJ2"); // returns "f4b247fd-1f87-45d4-aa06-1c6fc0a8dfaf"
+ * const error = uuid58DecodeSafe("invalid"); // returns InvalidBase58Error
+ * ```
+ */
+export function uuid58DecodeSafe(base58) {
+    let num = 0n;
+    for (const char of base58) {
+        const index = BASE58_MAP[char];
+        if (index === undefined) {
+            return new InvalidBase58Error(base58);
+        }
+        num = num * ALPHABET_LENGTH + index;
+    }
+    const hex = num.toString(16).padStart(32, "0");
+    if (hex.length !== 32) {
+        return new InvalidBase58Error(base58);
+    }
+    return (hex.slice(0, 8) +
+        "-" +
+        hex.slice(8, 12) +
+        "-" +
+        hex.slice(12, 16) +
+        "-" +
+        hex.slice(16, 20) +
+        "-" +
+        hex.slice(20));
+}
 /**
  * Converts a Base58-encoded string back to a standard UUID string format.
  *

package/esm/encode.d.ts

@@ -5,6 +5,28 @@
 export declare class InvalidUuidError extends Error {
     constructor(uuid: string);
 }
+/**
+ * Converts a standard UUID string to a Base58-encoded format, but instead of
+ * throwing an error for invalid input, it returns an `InvalidUuidError` instance.
+ *
+ * @param uuid - The UUID string to encode (with or without hyphens)
+ * @returns A Base58-encoded string, or an `InvalidUuidError` if the input is
+ *   not a valid UUID
+ * @note This function does not throw; it returns the error object instead.
+ *
+ * @example
+ * ```typescript
+ * // With hyphens
+ * const base58 = uuid58EncodeSafe("f4b247fd-1f87-45d4-aa06-1c6fc0a8dfaf"); // returns "XDY9dmBbcMBXqcRvYw8xJ2"
+ * // Without hyphens
+ * const base58 = uuid58EncodeSafe("f4b247fd1f8745d4aa061c6fc0a8dfaf"); // returns "XDY9dmBbcMBXqcRvYw8xJ2"
+ * // Uppercase UUID is also accepted
+ * const base58 = uuid58EncodeSafe("F4B247FD-1F87-45D4-AA06-1C6FC0A8DFAF"); // returns "XDY9dmBbcMBXqcRvYw8xJ2"
+ * // Invalid UUID format
+ * const error = uuid58EncodeSafe("invalid"); // returns InvalidUuidError
+ * ```
+ */
+export declare function uuid58EncodeSafe(uuid: string): string | InvalidUuidError;
 /**
  * Converts a standard UUID string to a shortened Base58-encoded format.
  *

package/esm/encode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"encode.d.ts","sourceRoot":"","sources":["../src/encode.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,qBAAa,gBAAiB,SAAQ,KAAK;gBAK7B,IAAI,EAAE,MAAM;CAGzB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAqBjD"}
+{"version":3,"file":"encode.d.ts","sourceRoot":"","sources":["../src/encode.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,qBAAa,gBAAiB,SAAQ,KAAK;gBAK7B,IAAI,EAAE,MAAM;CAGzB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,gBAAgB,CAoBxE;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAoBjD"}

package/esm/encode.js

@@ -13,6 +13,46 @@ _a = InvalidUuidError;
 (() => {
     _a.prototype.name = "InvalidUuidError";
 })();
+/**
+ * Converts a standard UUID string to a Base58-encoded format, but instead of
+ * throwing an error for invalid input, it returns an `InvalidUuidError` instance.
+ *
+ * @param uuid - The UUID string to encode (with or without hyphens)
+ * @returns A Base58-encoded string, or an `InvalidUuidError` if the input is
+ *   not a valid UUID
+ * @note This function does not throw; it returns the error object instead.
+ *
+ * @example
+ * ```typescript
+ * // With hyphens
+ * const base58 = uuid58EncodeSafe("f4b247fd-1f87-45d4-aa06-1c6fc0a8dfaf"); // returns "XDY9dmBbcMBXqcRvYw8xJ2"
+ * // Without hyphens
+ * const base58 = uuid58EncodeSafe("f4b247fd1f8745d4aa061c6fc0a8dfaf"); // returns "XDY9dmBbcMBXqcRvYw8xJ2"
+ * // Uppercase UUID is also accepted
+ * const base58 = uuid58EncodeSafe("F4B247FD-1F87-45D4-AA06-1C6FC0A8DFAF"); // returns "XDY9dmBbcMBXqcRvYw8xJ2"
+ * // Invalid UUID format
+ * const error = uuid58EncodeSafe("invalid"); // returns InvalidUuidError
+ * ```
+ */
+export function uuid58EncodeSafe(uuid) {
+    const hex = uuid.replace(/-/g, "").toLowerCase();
+    if (hex.length !== 32) {
+        return new InvalidUuidError(uuid);
+    }
+    let num;
+    try {
+        num = BigInt("0x" + hex);
+    }
+    catch {
+        return new InvalidUuidError(uuid);
+    }
+    let encoded = "";
+    do {
+        encoded = BASE58_ALPHABET[Number(num % ALPHABET_LENGTH)] + encoded;
+        num /= ALPHABET_LENGTH;
+    } while (num > 0n);
+    return encoded;
+}
 /**
  * Converts a standard UUID string to a shortened Base58-encoded format.
  *
@@ -46,8 +86,7 @@ export function uuid58Encode(uuid) {
     }
     let encoded = "";
     do {
-        const rem = Number(num % ALPHABET_LENGTH);
-        encoded = BASE58_ALPHABET[rem] + encoded;
+        encoded = BASE58_ALPHABET[Number(num % ALPHABET_LENGTH)] + encoded;
         num /= ALPHABET_LENGTH;
     } while (num > 0n);
     return encoded;

package/esm/uuid58.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"uuid58.d.ts","sourceRoot":"","sources":["../src/uuid58.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH,wBAAgB,MAAM,IAAI,MAAM,CAE/B"}
+{"version":3,"file":"uuid58.d.ts","sourceRoot":"","sources":["../src/uuid58.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH,wBAAgB,MAAM,IAAI,MAAM,CAU/B"}

package/esm/uuid58.js

@@ -1,4 +1,4 @@
-import { uuid58Encode } from "./encode.js";
+import { ALPHABET_LENGTH, BASE58_ALPHABET } from "./alphabet.js";
 /**
  * Generates a new Base58-encoded UUID.
  *
@@ -13,5 +13,11 @@ import { uuid58Encode } from "./encode.js";
  * ```
  */
 export function uuid58() {
-    return uuid58Encode(crypto.randomUUID());
+    let num = BigInt("0x" + crypto.randomUUID().replace(/-/g, ""));
+    let encoded = "";
+    do {
+        encoded = BASE58_ALPHABET[Number(num % ALPHABET_LENGTH)] + encoded;
+        num /= ALPHABET_LENGTH;
+    } while (num > 0n);
+    return encoded;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nakanoaas/uuid58",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "description": "A tiny, zero-dependency library for generating and converting UUIDs to Base58-encoded strings.",
   "repository": {
     "type": "git",

package/script/decode.d.ts

@@ -5,6 +5,23 @@
 export declare class InvalidBase58Error extends Error {
     constructor(base58: string);
 }
+/**
+ * Converts a Base58-encoded string back to a standard UUID format, but instead of
+ * throwing an error for invalid input, it returns an `InvalidBase58Error`
+ * instance.
+ *
+ * @param base58 - The Base58-encoded string to decode
+ * @returns A standard UUID string (lowercase, with hyphens), or an
+ *   `InvalidBase58Error` if the input contains invalid Base58 characters
+ * @note This function does not throw; it returns the error object instead.
+ *
+ * @example
+ * ```typescript
+ * const uuid = uuid58DecodeSafe("XDY9dmBbcMBXqcRvYw8xJ2"); // returns "f4b247fd-1f87-45d4-aa06-1c6fc0a8dfaf"
+ * const error = uuid58DecodeSafe("invalid"); // returns InvalidBase58Error
+ * ```
+ */
+export declare function uuid58DecodeSafe(base58: string): string | InvalidBase58Error;
 /**
  * Converts a Base58-encoded string back to a standard UUID string format.
  *

package/script/decode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"decode.d.ts","sourceRoot":"","sources":["../src/decode.ts"],"names":[],"mappings":"AAQA;;;GAGG;AACH,qBAAa,kBAAmB,SAAQ,KAAK;gBAK/B,MAAM,EAAE,MAAM;CAG3B;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CA0BnD"}
+{"version":3,"file":"decode.d.ts","sourceRoot":"","sources":["../src/decode.ts"],"names":[],"mappings":"AAQA;;;GAGG;AACH,qBAAa,kBAAmB,SAAQ,KAAK;gBAK/B,MAAM,EAAE,MAAM;CAG3B;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,kBAAkB,CA0B5E;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CA0BnD"}

package/script/decode.js

@@ -2,6 +2,7 @@
 var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidBase58Error = void 0;
+exports.uuid58DecodeSafe = uuid58DecodeSafe;
 exports.uuid58Decode = uuid58Decode;
 const alphabet_js_1 = require("./alphabet.js");
 // Fast lookup map from alphabet characters to their indices
@@ -23,6 +24,45 @@ _a = InvalidBase58Error;
 (() => {
     _a.prototype.name = "InvalidBase58Error";
 })();
+/**
+ * Converts a Base58-encoded string back to a standard UUID format, but instead of
+ * throwing an error for invalid input, it returns an `InvalidBase58Error`
+ * instance.
+ *
+ * @param base58 - The Base58-encoded string to decode
+ * @returns A standard UUID string (lowercase, with hyphens), or an
+ *   `InvalidBase58Error` if the input contains invalid Base58 characters
+ * @note This function does not throw; it returns the error object instead.
+ *
+ * @example
+ * ```typescript
+ * const uuid = uuid58DecodeSafe("XDY9dmBbcMBXqcRvYw8xJ2"); // returns "f4b247fd-1f87-45d4-aa06-1c6fc0a8dfaf"
+ * const error = uuid58DecodeSafe("invalid"); // returns InvalidBase58Error
+ * ```
+ */
+function uuid58DecodeSafe(base58) {
+    let num = 0n;
+    for (const char of base58) {
+        const index = BASE58_MAP[char];
+        if (index === undefined) {
+            return new InvalidBase58Error(base58);
+        }
+        num = num * alphabet_js_1.ALPHABET_LENGTH + index;
+    }
+    const hex = num.toString(16).padStart(32, "0");
+    if (hex.length !== 32) {
+        return new InvalidBase58Error(base58);
+    }
+    return (hex.slice(0, 8) +
+        "-" +
+        hex.slice(8, 12) +
+        "-" +
+        hex.slice(12, 16) +
+        "-" +
+        hex.slice(16, 20) +
+        "-" +
+        hex.slice(20));
+}
 /**
  * Converts a Base58-encoded string back to a standard UUID string format.
  *

package/script/encode.d.ts

@@ -5,6 +5,28 @@
 export declare class InvalidUuidError extends Error {
     constructor(uuid: string);
 }
+/**
+ * Converts a standard UUID string to a Base58-encoded format, but instead of
+ * throwing an error for invalid input, it returns an `InvalidUuidError` instance.
+ *
+ * @param uuid - The UUID string to encode (with or without hyphens)
+ * @returns A Base58-encoded string, or an `InvalidUuidError` if the input is
+ *   not a valid UUID
+ * @note This function does not throw; it returns the error object instead.
+ *
+ * @example
+ * ```typescript
+ * // With hyphens
+ * const base58 = uuid58EncodeSafe("f4b247fd-1f87-45d4-aa06-1c6fc0a8dfaf"); // returns "XDY9dmBbcMBXqcRvYw8xJ2"
+ * // Without hyphens
+ * const base58 = uuid58EncodeSafe("f4b247fd1f8745d4aa061c6fc0a8dfaf"); // returns "XDY9dmBbcMBXqcRvYw8xJ2"
+ * // Uppercase UUID is also accepted
+ * const base58 = uuid58EncodeSafe("F4B247FD-1F87-45D4-AA06-1C6FC0A8DFAF"); // returns "XDY9dmBbcMBXqcRvYw8xJ2"
+ * // Invalid UUID format
+ * const error = uuid58EncodeSafe("invalid"); // returns InvalidUuidError
+ * ```
+ */
+export declare function uuid58EncodeSafe(uuid: string): string | InvalidUuidError;
 /**
  * Converts a standard UUID string to a shortened Base58-encoded format.
  *

package/script/encode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"encode.d.ts","sourceRoot":"","sources":["../src/encode.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,qBAAa,gBAAiB,SAAQ,KAAK;gBAK7B,IAAI,EAAE,MAAM;CAGzB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAqBjD"}
+{"version":3,"file":"encode.d.ts","sourceRoot":"","sources":["../src/encode.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,qBAAa,gBAAiB,SAAQ,KAAK;gBAK7B,IAAI,EAAE,MAAM;CAGzB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,gBAAgB,CAoBxE;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAoBjD"}

package/script/encode.js

@@ -2,6 +2,7 @@
 var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidUuidError = void 0;
+exports.uuid58EncodeSafe = uuid58EncodeSafe;
 exports.uuid58Encode = uuid58Encode;
 const alphabet_js_1 = require("./alphabet.js");
 /**
@@ -18,6 +19,46 @@ _a = InvalidUuidError;
 (() => {
     _a.prototype.name = "InvalidUuidError";
 })();
+/**
+ * Converts a standard UUID string to a Base58-encoded format, but instead of
+ * throwing an error for invalid input, it returns an `InvalidUuidError` instance.
+ *
+ * @param uuid - The UUID string to encode (with or without hyphens)
+ * @returns A Base58-encoded string, or an `InvalidUuidError` if the input is
+ *   not a valid UUID
+ * @note This function does not throw; it returns the error object instead.
+ *
+ * @example
+ * ```typescript
+ * // With hyphens
+ * const base58 = uuid58EncodeSafe("f4b247fd-1f87-45d4-aa06-1c6fc0a8dfaf"); // returns "XDY9dmBbcMBXqcRvYw8xJ2"
+ * // Without hyphens
+ * const base58 = uuid58EncodeSafe("f4b247fd1f8745d4aa061c6fc0a8dfaf"); // returns "XDY9dmBbcMBXqcRvYw8xJ2"
+ * // Uppercase UUID is also accepted
+ * const base58 = uuid58EncodeSafe("F4B247FD-1F87-45D4-AA06-1C6FC0A8DFAF"); // returns "XDY9dmBbcMBXqcRvYw8xJ2"
+ * // Invalid UUID format
+ * const error = uuid58EncodeSafe("invalid"); // returns InvalidUuidError
+ * ```
+ */
+function uuid58EncodeSafe(uuid) {
+    const hex = uuid.replace(/-/g, "").toLowerCase();
+    if (hex.length !== 32) {
+        return new InvalidUuidError(uuid);
+    }
+    let num;
+    try {
+        num = BigInt("0x" + hex);
+    }
+    catch {
+        return new InvalidUuidError(uuid);
+    }
+    let encoded = "";
+    do {
+        encoded = alphabet_js_1.BASE58_ALPHABET[Number(num % alphabet_js_1.ALPHABET_LENGTH)] + encoded;
+        num /= alphabet_js_1.ALPHABET_LENGTH;
+    } while (num > 0n);
+    return encoded;
+}
 /**
  * Converts a standard UUID string to a shortened Base58-encoded format.
  *
@@ -51,8 +92,7 @@ function uuid58Encode(uuid) {
     }
     let encoded = "";
     do {
-        const rem = Number(num % alphabet_js_1.ALPHABET_LENGTH);
-        encoded = alphabet_js_1.BASE58_ALPHABET[rem] + encoded;
+        encoded = alphabet_js_1.BASE58_ALPHABET[Number(num % alphabet_js_1.ALPHABET_LENGTH)] + encoded;
         num /= alphabet_js_1.ALPHABET_LENGTH;
     } while (num > 0n);
     return encoded;

package/script/uuid58.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"uuid58.d.ts","sourceRoot":"","sources":["../src/uuid58.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH,wBAAgB,MAAM,IAAI,MAAM,CAE/B"}
+{"version":3,"file":"uuid58.d.ts","sourceRoot":"","sources":["../src/uuid58.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH,wBAAgB,MAAM,IAAI,MAAM,CAU/B"}

package/script/uuid58.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.uuid58 = uuid58;
-const encode_js_1 = require("./encode.js");
+const alphabet_js_1 = require("./alphabet.js");
 /**
  * Generates a new Base58-encoded UUID.
  *
@@ -16,5 +16,11 @@ const encode_js_1 = require("./encode.js");
  * ```
  */
 function uuid58() {
-    return (0, encode_js_1.uuid58Encode)(crypto.randomUUID());
+    let num = BigInt("0x" + crypto.randomUUID().replace(/-/g, ""));
+    let encoded = "";
+    do {
+        encoded = alphabet_js_1.BASE58_ALPHABET[Number(num % alphabet_js_1.ALPHABET_LENGTH)] + encoded;
+        num /= alphabet_js_1.ALPHABET_LENGTH;
+    } while (num > 0n);
+    return encoded;
 }