@nakanoaas/uuid58 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Nakano as a Service
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,114 @@
+# uuid58
+
+[![JSR](https://jsr.io/badges/@nakanoaas/uuid58)](https://jsr.io/@nakanoaas/uuid58)
+[![npm](https://badge.fury.io/js/@nakanoaas%2Fuuid58.svg)](https://badge.fury.io/js/@nakanoaas%2Fuuid58)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+A tiny, zero-dependency library for generating and converting UUIDs to
+Base58-encoded strings (using Bitcoin-style alphabet). Perfect for creating
+shorter, URL-safe identifiers while maintaining the uniqueness of UUIDs.
+
+## Features
+
+- 🚀 Generate short, URL-safe identifiers (~22 characters)
+- 🔄 Bidirectional conversion between UUID and Base58
+- 🪶 Zero dependencies
+- 💪 Type-safe with TypeScript
+- 🔒 Uses native `crypto.randomUUID()` for secure UUID generation
+- 📦 Supports both ESM and CommonJS
+
+## Installation
+
+### Deno
+
+```bash
+deno add @nakanoaas/uuid58
+```
+
+### Node.js
+
+Using npm:
+
+```bash
+npm install @nakanoaas/uuid58
+```
+
+Using yarn:
+
+```bash
+yarn add @nakanoaas/uuid58
+```
+
+Using pnpm:
+
+```bash
+pnpm add @nakanoaas/uuid58
+```
+
+## Usage
+
+```typescript
+import { decodeUuid58, encodeUuid58, uuid58 } from "@nakanoaas/uuid58";
+
+// Generate a new Base58-encoded UUID
+const id = uuid58();
+// => "XDY9dmBbcMBXqcRvYw8xJ2"
+
+// Convert existing UUID to Base58
+const encoded = encodeUuid58("f4b247fd-1f87-45d4-aa06-1c6fc0a8dfaf");
+// => "XDY9dmBbcMBXqcRvYw8xJ2"
+
+// Convert Base58 back to UUID
+const decoded = decodeUuid58("XDY9dmBbcMBXqcRvYw8xJ2");
+// => "f4b247fd-1f87-45d4-aa06-1c6fc0a8dfaf"
+```
+
+## API Reference
+
+### `uuid58()`
+
+Generates a new Base58-encoded UUID.
+
+```typescript
+function uuid58(): string;
+```
+
+### `encodeUuid58(uuid: string)`
+
+Converts a standard UUID string to a Base58-encoded format.
+
+```typescript
+function encodeUuid58(uuid: string): string;
+```
+
+- **Parameters:**
+  - `uuid`: The UUID string to encode (with or without hyphens)
+- **Returns:** A Base58-encoded string
+- **Throws:** `InvalidUuidError` if the input is not a valid UUID
+
+### `decodeUuid58(encoded: string)`
+
+Converts a Base58-encoded string back to a standard UUID format.
+
+```typescript
+function decodeUuid58(encoded: string): string;
+```
+
+- **Parameters:**
+  - `encoded`: The Base58-encoded string to decode
+- **Returns:** A standard UUID string (lowercase, with hyphens)
+- **Throws:** `InvalidBase58Error` if the input contains invalid Base58
+  characters
+
+## Why uuid58?
+
+Standard UUIDs are 36 characters long (including hyphens), which can be
+cumbersome in URLs or when space is limited. Base58 encoding reduces this to
+around 22 characters while maintaining uniqueness and using only URL-safe
+characters. The Base58 alphabet used in this library is the same as Bitcoin's,
+which excludes similar-looking characters (0, O, I, l) to prevent visual
+ambiguity and confusion.
+
+## License
+
+MIT License - see the [LICENSE](LICENSE) file for details

package/esm/alphabet.d.ts

@@ -0,0 +1,3 @@
+export declare const BASE58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+export declare const ALPHABET_LENGTH: bigint;
+//# sourceMappingURL=alphabet.d.ts.map

package/esm/alphabet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"alphabet.d.ts","sourceRoot":"","sources":["../src/alphabet.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,eAAe,+DACkC,CAAC;AAC/D,eAAO,MAAM,eAAe,QAAiC,CAAC"}

package/esm/alphabet.js

@@ -0,0 +1,3 @@
+// Character set for Base58 (Bitcoin compatible)
+export const BASE58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"; // cspell:disable-line
+export const ALPHABET_LENGTH = BigInt(BASE58_ALPHABET.length);

package/esm/decode.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Error thrown when an invalid Base58 string is provided for decoding.
+ * This includes strings containing characters not in the Base58 alphabet.
+ */
+export declare class InvalidBase58Error extends Error {
+    constructor(base58: string);
+}
+/**
+ * Converts a Base58-encoded string back to a standard UUID string format.
+ *
+ * @param base58 - The Base58-encoded string to decode
+ * @returns A standard UUID string in the format "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" (always in lowercase)
+ * @throws {InvalidBase58Error} If the input string contains characters not in the Base58 alphabet
+ *
+ * @example
+ * ```typescript
+ * const uuid = decodeUuid58("XDY9dmBbcMBXqcRvYw8xJ2"); // returns "f4b247fd-1f87-45d4-aa06-1c6fc0a8dfaf"
+ * ```
+ */
+export declare function decodeUuid58(base58: string): string;
+//# sourceMappingURL=decode.d.ts.map

package/esm/decode.d.ts.map

@@ -0,0 +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,CAuBnD"}

package/esm/decode.js

@@ -0,0 +1,51 @@
+var _a;
+import { ALPHABET_LENGTH, BASE58_ALPHABET } from "./alphabet.js";
+// Fast lookup map from alphabet characters to their indices
+const BASE58_MAP = {};
+for (let i = 0; i < BASE58_ALPHABET.length; i++) {
+    BASE58_MAP[BASE58_ALPHABET[i]] = BigInt(i);
+}
+/**
+ * Error thrown when an invalid Base58 string is provided for decoding.
+ * This includes strings containing characters not in the Base58 alphabet.
+ */
+export class InvalidBase58Error extends Error {
+    constructor(base58) {
+        super(`Invalid Base58 string: ${base58}`);
+    }
+}
+_a = InvalidBase58Error;
+(() => {
+    _a.prototype.name = "InvalidBase58Error";
+})();
+/**
+ * Converts a Base58-encoded string back to a standard UUID string format.
+ *
+ * @param base58 - The Base58-encoded string to decode
+ * @returns A standard UUID string in the format "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" (always in lowercase)
+ * @throws {InvalidBase58Error} If the input string contains characters not in the Base58 alphabet
+ *
+ * @example
+ * ```typescript
+ * const uuid = decodeUuid58("XDY9dmBbcMBXqcRvYw8xJ2"); // returns "f4b247fd-1f87-45d4-aa06-1c6fc0a8dfaf"
+ * ```
+ */
+export function decodeUuid58(base58) {
+    if (!/^[1-9A-HJ-NP-Za-km-z]+$/.test(base58)) {
+        throw new InvalidBase58Error(base58);
+    }
+    let num = 0n;
+    for (const char of base58) {
+        num = num * ALPHABET_LENGTH + BASE58_MAP[char];
+    }
+    const hex = num.toString(16).padStart(32, "0");
+    return (hex.slice(0, 8) +
+        "-" +
+        hex.slice(8, 12) +
+        "-" +
+        hex.slice(12, 16) +
+        "-" +
+        hex.slice(16, 20) +
+        "-" +
+        hex.slice(20));
+}

package/esm/encode.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Error thrown when an invalid UUID string is provided for encoding.
+ * This includes strings that don't match the standard UUID format (32 hexadecimal characters with optional hyphens).
+ */
+export declare class InvalidUuidError extends Error {
+    constructor(uuid: string);
+}
+/**
+ * Converts a standard UUID string to a shortened Base58-encoded format.
+ *
+ * @param uuid - The UUID string to encode. Can be provided with or without hyphens
+ *              (format: "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" or "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx").
+ *              The input is case-insensitive, so both uppercase and lowercase hexadecimal characters are accepted.
+ * @returns A Base58-encoded string representation of the UUID
+ * @throws {InvalidUuidError} If the input string is not a valid UUID format
+ *
+ * @example
+ * ```typescript
+ * // With hyphens
+ * const base58 = encodeUuid58("f4b247fd-1f87-45d4-aa06-1c6fc0a8dfaf"); // returns "XDY9dmBbcMBXqcRvYw8xJ2"
+ * // Without hyphens
+ * const base58 = encodeUuid58("f4b247fd1f8745d4aa061c6fc0a8dfaf"); // returns "XDY9dmBbcMBXqcRvYw8xJ2"
+ * // Uppercase UUID is also accepted
+ * const base58 = encodeUuid58("F4B247FD-1F87-45D4-AA06-1C6FC0A8DFAF"); // returns "XDY9dmBbcMBXqcRvYw8xJ2"
+ * ```
+ */
+export declare function encodeUuid58(uuid: string): string;
+//# sourceMappingURL=encode.d.ts.map

package/esm/encode.d.ts.map

@@ -0,0 +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,CAejD"}

package/esm/encode.js

@@ -0,0 +1,48 @@
+var _a;
+import { ALPHABET_LENGTH, BASE58_ALPHABET } from "./alphabet.js";
+/**
+ * Error thrown when an invalid UUID string is provided for encoding.
+ * This includes strings that don't match the standard UUID format (32 hexadecimal characters with optional hyphens).
+ */
+export class InvalidUuidError extends Error {
+    constructor(uuid) {
+        super(`Invalid UUID format: ${uuid}`);
+    }
+}
+_a = InvalidUuidError;
+(() => {
+    _a.prototype.name = "InvalidUuidError";
+})();
+/**
+ * Converts a standard UUID string to a shortened Base58-encoded format.
+ *
+ * @param uuid - The UUID string to encode. Can be provided with or without hyphens
+ *              (format: "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" or "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx").
+ *              The input is case-insensitive, so both uppercase and lowercase hexadecimal characters are accepted.
+ * @returns A Base58-encoded string representation of the UUID
+ * @throws {InvalidUuidError} If the input string is not a valid UUID format
+ *
+ * @example
+ * ```typescript
+ * // With hyphens
+ * const base58 = encodeUuid58("f4b247fd-1f87-45d4-aa06-1c6fc0a8dfaf"); // returns "XDY9dmBbcMBXqcRvYw8xJ2"
+ * // Without hyphens
+ * const base58 = encodeUuid58("f4b247fd1f8745d4aa061c6fc0a8dfaf"); // returns "XDY9dmBbcMBXqcRvYw8xJ2"
+ * // Uppercase UUID is also accepted
+ * const base58 = encodeUuid58("F4B247FD-1F87-45D4-AA06-1C6FC0A8DFAF"); // returns "XDY9dmBbcMBXqcRvYw8xJ2"
+ * ```
+ */
+export function encodeUuid58(uuid) {
+    const hex = uuid.replace(/-/g, "").toLowerCase();
+    if (!/^[0-9a-f]{32}$/.test(hex)) {
+        throw new InvalidUuidError(uuid);
+    }
+    let num = BigInt("0x" + hex);
+    let encoded = "";
+    do {
+        const rem = Number(num % ALPHABET_LENGTH);
+        encoded = BASE58_ALPHABET[rem] + encoded;
+        num /= ALPHABET_LENGTH;
+    } while (num > 0n);
+    return encoded;
+}

package/esm/index.d.ts

@@ -0,0 +1,4 @@
+export { encodeUuid58 } from "./encode.js";
+export { decodeUuid58 } from "./decode.js";
+export { uuid58 } from "./uuid58.js";
+//# sourceMappingURL=index.d.ts.map

package/esm/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC"}

package/esm/index.js

@@ -0,0 +1,3 @@
+export { encodeUuid58 } from "./encode.js";
+export { decodeUuid58 } from "./decode.js";
+export { uuid58 } from "./uuid58.js";

package/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/esm/uuid58.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Generates a new Base58-encoded UUID.
+ *
+ * This function combines the standard UUID generation (using crypto.randomUUID())
+ * with Base58 encoding to create a shorter, URL-safe identifier.
+ *
+ * @returns A Base58-encoded string representing a newly generated UUID
+ *
+ * @example
+ * ```typescript
+ * const id = uuid58(); // returns something like "XDY9dmBbcMBXqcRvYw8xJ2"
+ * ```
+ */
+export declare function uuid58(): string;
+//# sourceMappingURL=uuid58.d.ts.map

package/esm/uuid58.d.ts.map

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

package/esm/uuid58.js

@@ -0,0 +1,17 @@
+import { encodeUuid58 } from "./encode.js";
+/**
+ * Generates a new Base58-encoded UUID.
+ *
+ * This function combines the standard UUID generation (using crypto.randomUUID())
+ * with Base58 encoding to create a shorter, URL-safe identifier.
+ *
+ * @returns A Base58-encoded string representing a newly generated UUID
+ *
+ * @example
+ * ```typescript
+ * const id = uuid58(); // returns something like "XDY9dmBbcMBXqcRvYw8xJ2"
+ * ```
+ */
+export function uuid58() {
+    return encodeUuid58(crypto.randomUUID());
+}

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@nakanoaas/uuid58",
+  "version": "0.0.1",
+  "description": "A tiny, zero-dependency library for generating and converting UUIDs to Base58-encoded strings.",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/nakanoasaservice/uuid58.git"
+  },
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/nakanoasaservice/uuid58/issues"
+  },
+  "main": "./script/index.js",
+  "module": "./esm/index.js",
+  "exports": {
+    ".": {
+      "import": "./esm/index.js",
+      "require": "./script/index.js"
+    }
+  },
+  "devDependencies": {
+    "@types/node": "^20.9.0"
+  },
+  "_generatedBy": "dnt@dev"
+}

package/script/alphabet.d.ts

@@ -0,0 +1,3 @@
+export declare const BASE58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+export declare const ALPHABET_LENGTH: bigint;
+//# sourceMappingURL=alphabet.d.ts.map

package/script/alphabet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"alphabet.d.ts","sourceRoot":"","sources":["../src/alphabet.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,eAAe,+DACkC,CAAC;AAC/D,eAAO,MAAM,eAAe,QAAiC,CAAC"}

package/script/alphabet.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ALPHABET_LENGTH = exports.BASE58_ALPHABET = void 0;
+// Character set for Base58 (Bitcoin compatible)
+exports.BASE58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"; // cspell:disable-line
+exports.ALPHABET_LENGTH = BigInt(exports.BASE58_ALPHABET.length);

package/script/decode.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Error thrown when an invalid Base58 string is provided for decoding.
+ * This includes strings containing characters not in the Base58 alphabet.
+ */
+export declare class InvalidBase58Error extends Error {
+    constructor(base58: string);
+}
+/**
+ * Converts a Base58-encoded string back to a standard UUID string format.
+ *
+ * @param base58 - The Base58-encoded string to decode
+ * @returns A standard UUID string in the format "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" (always in lowercase)
+ * @throws {InvalidBase58Error} If the input string contains characters not in the Base58 alphabet
+ *
+ * @example
+ * ```typescript
+ * const uuid = decodeUuid58("XDY9dmBbcMBXqcRvYw8xJ2"); // returns "f4b247fd-1f87-45d4-aa06-1c6fc0a8dfaf"
+ * ```
+ */
+export declare function decodeUuid58(base58: string): string;
+//# sourceMappingURL=decode.d.ts.map

package/script/decode.d.ts.map

@@ -0,0 +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,CAuBnD"}

package/script/decode.js

@@ -0,0 +1,56 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidBase58Error = void 0;
+exports.decodeUuid58 = decodeUuid58;
+const alphabet_js_1 = require("./alphabet.js");
+// Fast lookup map from alphabet characters to their indices
+const BASE58_MAP = {};
+for (let i = 0; i < alphabet_js_1.BASE58_ALPHABET.length; i++) {
+    BASE58_MAP[alphabet_js_1.BASE58_ALPHABET[i]] = BigInt(i);
+}
+/**
+ * Error thrown when an invalid Base58 string is provided for decoding.
+ * This includes strings containing characters not in the Base58 alphabet.
+ */
+class InvalidBase58Error extends Error {
+    constructor(base58) {
+        super(`Invalid Base58 string: ${base58}`);
+    }
+}
+exports.InvalidBase58Error = InvalidBase58Error;
+_a = InvalidBase58Error;
+(() => {
+    _a.prototype.name = "InvalidBase58Error";
+})();
+/**
+ * Converts a Base58-encoded string back to a standard UUID string format.
+ *
+ * @param base58 - The Base58-encoded string to decode
+ * @returns A standard UUID string in the format "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" (always in lowercase)
+ * @throws {InvalidBase58Error} If the input string contains characters not in the Base58 alphabet
+ *
+ * @example
+ * ```typescript
+ * const uuid = decodeUuid58("XDY9dmBbcMBXqcRvYw8xJ2"); // returns "f4b247fd-1f87-45d4-aa06-1c6fc0a8dfaf"
+ * ```
+ */
+function decodeUuid58(base58) {
+    if (!/^[1-9A-HJ-NP-Za-km-z]+$/.test(base58)) {
+        throw new InvalidBase58Error(base58);
+    }
+    let num = 0n;
+    for (const char of base58) {
+        num = num * alphabet_js_1.ALPHABET_LENGTH + BASE58_MAP[char];
+    }
+    const hex = num.toString(16).padStart(32, "0");
+    return (hex.slice(0, 8) +
+        "-" +
+        hex.slice(8, 12) +
+        "-" +
+        hex.slice(12, 16) +
+        "-" +
+        hex.slice(16, 20) +
+        "-" +
+        hex.slice(20));
+}

package/script/encode.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Error thrown when an invalid UUID string is provided for encoding.
+ * This includes strings that don't match the standard UUID format (32 hexadecimal characters with optional hyphens).
+ */
+export declare class InvalidUuidError extends Error {
+    constructor(uuid: string);
+}
+/**
+ * Converts a standard UUID string to a shortened Base58-encoded format.
+ *
+ * @param uuid - The UUID string to encode. Can be provided with or without hyphens
+ *              (format: "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" or "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx").
+ *              The input is case-insensitive, so both uppercase and lowercase hexadecimal characters are accepted.
+ * @returns A Base58-encoded string representation of the UUID
+ * @throws {InvalidUuidError} If the input string is not a valid UUID format
+ *
+ * @example
+ * ```typescript
+ * // With hyphens
+ * const base58 = encodeUuid58("f4b247fd-1f87-45d4-aa06-1c6fc0a8dfaf"); // returns "XDY9dmBbcMBXqcRvYw8xJ2"
+ * // Without hyphens
+ * const base58 = encodeUuid58("f4b247fd1f8745d4aa061c6fc0a8dfaf"); // returns "XDY9dmBbcMBXqcRvYw8xJ2"
+ * // Uppercase UUID is also accepted
+ * const base58 = encodeUuid58("F4B247FD-1F87-45D4-AA06-1C6FC0A8DFAF"); // returns "XDY9dmBbcMBXqcRvYw8xJ2"
+ * ```
+ */
+export declare function encodeUuid58(uuid: string): string;
+//# sourceMappingURL=encode.d.ts.map

package/script/encode.d.ts.map

@@ -0,0 +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,CAejD"}

package/script/encode.js

@@ -0,0 +1,53 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidUuidError = void 0;
+exports.encodeUuid58 = encodeUuid58;
+const alphabet_js_1 = require("./alphabet.js");
+/**
+ * Error thrown when an invalid UUID string is provided for encoding.
+ * This includes strings that don't match the standard UUID format (32 hexadecimal characters with optional hyphens).
+ */
+class InvalidUuidError extends Error {
+    constructor(uuid) {
+        super(`Invalid UUID format: ${uuid}`);
+    }
+}
+exports.InvalidUuidError = InvalidUuidError;
+_a = InvalidUuidError;
+(() => {
+    _a.prototype.name = "InvalidUuidError";
+})();
+/**
+ * Converts a standard UUID string to a shortened Base58-encoded format.
+ *
+ * @param uuid - The UUID string to encode. Can be provided with or without hyphens
+ *              (format: "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" or "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx").
+ *              The input is case-insensitive, so both uppercase and lowercase hexadecimal characters are accepted.
+ * @returns A Base58-encoded string representation of the UUID
+ * @throws {InvalidUuidError} If the input string is not a valid UUID format
+ *
+ * @example
+ * ```typescript
+ * // With hyphens
+ * const base58 = encodeUuid58("f4b247fd-1f87-45d4-aa06-1c6fc0a8dfaf"); // returns "XDY9dmBbcMBXqcRvYw8xJ2"
+ * // Without hyphens
+ * const base58 = encodeUuid58("f4b247fd1f8745d4aa061c6fc0a8dfaf"); // returns "XDY9dmBbcMBXqcRvYw8xJ2"
+ * // Uppercase UUID is also accepted
+ * const base58 = encodeUuid58("F4B247FD-1F87-45D4-AA06-1C6FC0A8DFAF"); // returns "XDY9dmBbcMBXqcRvYw8xJ2"
+ * ```
+ */
+function encodeUuid58(uuid) {
+    const hex = uuid.replace(/-/g, "").toLowerCase();
+    if (!/^[0-9a-f]{32}$/.test(hex)) {
+        throw new InvalidUuidError(uuid);
+    }
+    let num = BigInt("0x" + hex);
+    let encoded = "";
+    do {
+        const rem = Number(num % alphabet_js_1.ALPHABET_LENGTH);
+        encoded = alphabet_js_1.BASE58_ALPHABET[rem] + encoded;
+        num /= alphabet_js_1.ALPHABET_LENGTH;
+    } while (num > 0n);
+    return encoded;
+}

package/script/index.d.ts

@@ -0,0 +1,4 @@
+export { encodeUuid58 } from "./encode.js";
+export { decodeUuid58 } from "./decode.js";
+export { uuid58 } from "./uuid58.js";
+//# sourceMappingURL=index.d.ts.map

package/script/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC"}

package/script/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uuid58 = exports.decodeUuid58 = exports.encodeUuid58 = void 0;
+var encode_js_1 = require("./encode.js");
+Object.defineProperty(exports, "encodeUuid58", { enumerable: true, get: function () { return encode_js_1.encodeUuid58; } });
+var decode_js_1 = require("./decode.js");
+Object.defineProperty(exports, "decodeUuid58", { enumerable: true, get: function () { return decode_js_1.decodeUuid58; } });
+var uuid58_js_1 = require("./uuid58.js");
+Object.defineProperty(exports, "uuid58", { enumerable: true, get: function () { return uuid58_js_1.uuid58; } });

package/script/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/script/uuid58.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Generates a new Base58-encoded UUID.
+ *
+ * This function combines the standard UUID generation (using crypto.randomUUID())
+ * with Base58 encoding to create a shorter, URL-safe identifier.
+ *
+ * @returns A Base58-encoded string representing a newly generated UUID
+ *
+ * @example
+ * ```typescript
+ * const id = uuid58(); // returns something like "XDY9dmBbcMBXqcRvYw8xJ2"
+ * ```
+ */
+export declare function uuid58(): string;
+//# sourceMappingURL=uuid58.d.ts.map

package/script/uuid58.d.ts.map

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

package/script/uuid58.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uuid58 = uuid58;
+const encode_js_1 = require("./encode.js");
+/**
+ * Generates a new Base58-encoded UUID.
+ *
+ * This function combines the standard UUID generation (using crypto.randomUUID())
+ * with Base58 encoding to create a shorter, URL-safe identifier.
+ *
+ * @returns A Base58-encoded string representing a newly generated UUID
+ *
+ * @example
+ * ```typescript
+ * const id = uuid58(); // returns something like "XDY9dmBbcMBXqcRvYw8xJ2"
+ * ```
+ */
+function uuid58() {
+    return (0, encode_js_1.encodeUuid58)(crypto.randomUUID());
+}