@chainflip/utils 0.1.0

package/dist/assertion.cjs

@@ -0,0 +1,86 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/assertion.ts
+var assertion_exports = {};
+__export(assertion_exports, {
+  assert: () => assert,
+  assertBigInt: () => assertBigInt,
+  assertBoolean: () => assertBoolean,
+  assertNumber: () => assertNumber,
+  assertObject: () => assertObject,
+  assertString: () => assertString,
+  assertSymbol: () => assertSymbol,
+  assertUndefined: () => assertUndefined,
+  unreachable: () => unreachable
+});
+module.exports = __toCommonJS(assertion_exports);
+
+// src/guard.ts
+var createIsGuard = (type) => (value) => typeof value === type;
+var isString = createIsGuard("string");
+var isNumber = createIsGuard("number");
+var isBigInt = createIsGuard("bigint");
+var isBoolean = createIsGuard("boolean");
+var isSymbol = createIsGuard("symbol");
+var isObject = createIsGuard("object");
+var isUndefined = createIsGuard("undefined");
+
+// src/assertion.ts
+function assert(condition, message = "assertion failed", Constructor = Error) {
+  if (!condition) {
+    throw new Constructor(message);
+  }
+}
+function assertString(value, message) {
+  assert(isString(value), message ?? `expected a "string", got "${typeof value}"`);
+}
+function assertNumber(value, message) {
+  assert(isNumber(value), message ?? `expected a "number", got "${typeof value}"`);
+}
+function assertBigInt(value, message) {
+  assert(isBigInt(value), message ?? `expected a "bigint", got "${typeof value}"`);
+}
+function assertBoolean(value, message) {
+  assert(isBoolean(value), message ?? `expected a "boolean", got "${typeof value}"`);
+}
+function assertSymbol(value, message) {
+  assert(isSymbol(value), message ?? `expected a "symbol", got "${typeof value}"`);
+}
+function assertObject(value, message) {
+  assert(isObject(value), message ?? `expected an "object", got "${typeof value}"`);
+}
+function assertUndefined(value, message) {
+  assert(isUndefined(value), message ?? `expected "undefined", got "${typeof value}"`);
+}
+var unreachable = (x, message = "unreachable") => {
+  throw new Error(message);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  assert,
+  assertBigInt,
+  assertBoolean,
+  assertNumber,
+  assertObject,
+  assertString,
+  assertSymbol,
+  assertUndefined,
+  unreachable
+});

package/dist/assertion.d.cts

@@ -0,0 +1,11 @@
+declare function assert(condition: unknown, message?: string, Constructor?: ErrorConstructor): asserts condition;
+declare function assertString(value: unknown, message?: string): asserts value is string;
+declare function assertNumber(value: unknown, message?: string): asserts value is number;
+declare function assertBigInt(value: unknown, message?: string): asserts value is bigint;
+declare function assertBoolean(value: unknown, message?: string): asserts value is boolean;
+declare function assertSymbol(value: unknown, message?: string): asserts value is symbol;
+declare function assertObject(value: unknown, message?: string): asserts value is object;
+declare function assertUndefined(value: unknown, message?: string): asserts value is undefined;
+declare const unreachable: (x: never, message?: string) => never;
+
+export { assert, assertBigInt, assertBoolean, assertNumber, assertObject, assertString, assertSymbol, assertUndefined, unreachable };

package/dist/assertion.d.ts

@@ -0,0 +1,11 @@
+declare function assert(condition: unknown, message?: string, Constructor?: ErrorConstructor): asserts condition;
+declare function assertString(value: unknown, message?: string): asserts value is string;
+declare function assertNumber(value: unknown, message?: string): asserts value is number;
+declare function assertBigInt(value: unknown, message?: string): asserts value is bigint;
+declare function assertBoolean(value: unknown, message?: string): asserts value is boolean;
+declare function assertSymbol(value: unknown, message?: string): asserts value is symbol;
+declare function assertObject(value: unknown, message?: string): asserts value is object;
+declare function assertUndefined(value: unknown, message?: string): asserts value is undefined;
+declare const unreachable: (x: never, message?: string) => never;
+
+export { assert, assertBigInt, assertBoolean, assertNumber, assertObject, assertString, assertSymbol, assertUndefined, unreachable };

package/dist/assertion.js

@@ -0,0 +1,23 @@
+import {
+  assert,
+  assertBigInt,
+  assertBoolean,
+  assertNumber,
+  assertObject,
+  assertString,
+  assertSymbol,
+  assertUndefined,
+  unreachable
+} from "./chunk-NYJKCZRI.js";
+import "./chunk-CZNX6EUV.js";
+export {
+  assert,
+  assertBigInt,
+  assertBoolean,
+  assertNumber,
+  assertObject,
+  assertString,
+  assertSymbol,
+  assertUndefined,
+  unreachable
+};

package/dist/async.cjs

@@ -0,0 +1,89 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/async.ts
+var async_exports = {};
+__export(async_exports, {
+  Queue: () => Queue,
+  RateLimiter: () => RateLimiter,
+  deferredPromise: () => deferredPromise,
+  sleep: () => sleep
+});
+module.exports = __toCommonJS(async_exports);
+var deferredPromise = () => {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+};
+var sleep = (ms, { signal } = {}) => {
+  const deferred = deferredPromise();
+  const timeout = setTimeout(deferred.resolve, ms);
+  if (signal) {
+    const abort = () => {
+      clearTimeout(timeout);
+      deferred.resolve();
+    };
+    signal.addEventListener("abort", abort);
+    deferred.promise = deferred.promise.finally(() => {
+      signal.removeEventListener("abort", abort);
+    });
+  }
+  return deferred.promise;
+};
+var Queue = class {
+  constructor(debounce) {
+    this.debounce = debounce;
+  }
+  promise = Promise.resolve();
+  enqueue(fn, ...args) {
+    return new Promise((resolve, reject) => {
+      this.promise = this.promise.then(async () => {
+        const sleepPromise = this.debounce ? sleep(this.debounce) : Promise.resolve();
+        await Promise.all([fn(...args).then(resolve, reject), sleepPromise]);
+      });
+    });
+  }
+};
+var RateLimiter = class {
+  fn;
+  debounce;
+  queues;
+  index = 0;
+  constructor(opts) {
+    this.fn = opts.fn;
+    this.debounce = opts.debounce;
+    this.queues = Array.from({ length: opts.maxConcurrency }, () => new Queue(this.debounce));
+  }
+  request(...args) {
+    const nextIndex = this.index;
+    this.index = (this.index + 1) % this.queues.length;
+    return this.queues[nextIndex].enqueue(this.fn, ...args);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Queue,
+  RateLimiter,
+  deferredPromise,
+  sleep
+});

package/dist/async.d.cts

@@ -0,0 +1,29 @@
+declare const deferredPromise: <T>() => {
+    promise: Promise<T>;
+    resolve: (value: T) => void;
+    reject: (error: Error) => void;
+};
+type DeferredPromise<T> = ReturnType<typeof deferredPromise<T>>;
+declare const sleep: (ms: number, { signal }?: {
+    signal?: AbortSignal;
+}) => Promise<void>;
+declare class Queue {
+    private readonly debounce?;
+    private promise;
+    constructor(debounce?: number | undefined);
+    enqueue<T, Args extends unknown[]>(fn: (...args: Args) => Promise<T>, ...args: Args): Promise<T>;
+}
+declare class RateLimiter<T, Args extends unknown[]> {
+    fn: (...args: Args) => Promise<T>;
+    debounce: number;
+    queues: Queue[];
+    index: number;
+    constructor(opts: {
+        fn: (...args: Args) => Promise<T>;
+        debounce: number;
+        maxConcurrency: number;
+    });
+    request(...args: Args): Promise<T>;
+}
+
+export { type DeferredPromise, Queue, RateLimiter, deferredPromise, sleep };

package/dist/async.d.ts

@@ -0,0 +1,29 @@
+declare const deferredPromise: <T>() => {
+    promise: Promise<T>;
+    resolve: (value: T) => void;
+    reject: (error: Error) => void;
+};
+type DeferredPromise<T> = ReturnType<typeof deferredPromise<T>>;
+declare const sleep: (ms: number, { signal }?: {
+    signal?: AbortSignal;
+}) => Promise<void>;
+declare class Queue {
+    private readonly debounce?;
+    private promise;
+    constructor(debounce?: number | undefined);
+    enqueue<T, Args extends unknown[]>(fn: (...args: Args) => Promise<T>, ...args: Args): Promise<T>;
+}
+declare class RateLimiter<T, Args extends unknown[]> {
+    fn: (...args: Args) => Promise<T>;
+    debounce: number;
+    queues: Queue[];
+    index: number;
+    constructor(opts: {
+        fn: (...args: Args) => Promise<T>;
+        debounce: number;
+        maxConcurrency: number;
+    });
+    request(...args: Args): Promise<T>;
+}
+
+export { type DeferredPromise, Queue, RateLimiter, deferredPromise, sleep };

package/dist/async.js

@@ -0,0 +1,61 @@
+// src/async.ts
+var deferredPromise = () => {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+};
+var sleep = (ms, { signal } = {}) => {
+  const deferred = deferredPromise();
+  const timeout = setTimeout(deferred.resolve, ms);
+  if (signal) {
+    const abort = () => {
+      clearTimeout(timeout);
+      deferred.resolve();
+    };
+    signal.addEventListener("abort", abort);
+    deferred.promise = deferred.promise.finally(() => {
+      signal.removeEventListener("abort", abort);
+    });
+  }
+  return deferred.promise;
+};
+var Queue = class {
+  constructor(debounce) {
+    this.debounce = debounce;
+  }
+  promise = Promise.resolve();
+  enqueue(fn, ...args) {
+    return new Promise((resolve, reject) => {
+      this.promise = this.promise.then(async () => {
+        const sleepPromise = this.debounce ? sleep(this.debounce) : Promise.resolve();
+        await Promise.all([fn(...args).then(resolve, reject), sleepPromise]);
+      });
+    });
+  }
+};
+var RateLimiter = class {
+  fn;
+  debounce;
+  queues;
+  index = 0;
+  constructor(opts) {
+    this.fn = opts.fn;
+    this.debounce = opts.debounce;
+    this.queues = Array.from({ length: opts.maxConcurrency }, () => new Queue(this.debounce));
+  }
+  request(...args) {
+    const nextIndex = this.index;
+    this.index = (this.index + 1) % this.queues.length;
+    return this.queues[nextIndex].enqueue(this.fn, ...args);
+  }
+};
+export {
+  Queue,
+  RateLimiter,
+  deferredPromise,
+  sleep
+};

package/dist/base58.cjs

@@ -0,0 +1,75 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/base58.ts
+var base58_exports = {};
+__export(base58_exports, {
+  decode: () => decode,
+  encode: () => encode
+});
+module.exports = __toCommonJS(base58_exports);
+
+// src/guard.ts
+var createIsGuard = (type) => (value) => typeof value === type;
+var isString = createIsGuard("string");
+var isNumber = createIsGuard("number");
+var isBigInt = createIsGuard("bigint");
+var isBoolean = createIsGuard("boolean");
+var isSymbol = createIsGuard("symbol");
+var isObject = createIsGuard("object");
+var isUndefined = createIsGuard("undefined");
+
+// src/bytes.ts
+var convertBase = (bytes, fromBase, toBase) => {
+  const result = [];
+  for (const byte of bytes) {
+    let carry = byte;
+    for (let i = 0; i < result.length; i += 1) {
+      carry += result[i] * fromBase;
+      result[i] = carry % toBase;
+      carry = Math.floor(carry / toBase);
+    }
+    while (carry !== 0) {
+      result.push(carry % toBase);
+      carry = Math.floor(carry / toBase);
+    }
+  }
+  let leadingZeros = 0;
+  while (bytes[leadingZeros] === 0) {
+    leadingZeros += 1;
+    result.push(0);
+  }
+  return result.reverse();
+};
+var encodeBytesWithCharset = (bytes, charset2) => convertBase(bytes, 256, charset2.length).map((charCode) => charset2.charAt(charCode)).join("");
+var decodeBytesWithCharset = (input, charset2) => {
+  const charMap = Object.fromEntries([...charset2].map((char, index) => [char, index]));
+  const bytes = input.split("").map((char) => charMap[char]);
+  return convertBase(bytes, charset2.length, 256);
+};
+
+// src/base58.ts
+var charset = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+var encode = (bytes) => encodeBytesWithCharset(bytes, charset);
+var decode = (input) => decodeBytesWithCharset(input, charset);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  decode,
+  encode
+});

package/dist/base58.d.cts

@@ -0,0 +1,4 @@
+declare const encode: (bytes: Uint8Array | number[]) => string;
+declare const decode: (input: string) => number[];
+
+export { decode, encode };

package/dist/base58.d.ts

@@ -0,0 +1,4 @@
+declare const encode: (bytes: Uint8Array | number[]) => string;
+declare const decode: (input: string) => number[];
+
+export { decode, encode };

package/dist/base58.js

@@ -0,0 +1,11 @@
+import {
+  decode,
+  encode
+} from "./chunk-MORKFLN4.js";
+import "./chunk-DGVZ5UDU.js";
+import "./chunk-NYJKCZRI.js";
+import "./chunk-CZNX6EUV.js";
+export {
+  decode,
+  encode
+};

package/dist/bytes.cjs

@@ -0,0 +1,94 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/bytes.ts
+var bytes_exports = {};
+__export(bytes_exports, {
+  bytesToHex: () => bytesToHex,
+  decodeBytesWithCharset: () => decodeBytesWithCharset,
+  encodeBytesWithCharset: () => encodeBytesWithCharset,
+  hexToBytes: () => hexToBytes
+});
+module.exports = __toCommonJS(bytes_exports);
+
+// src/guard.ts
+var createIsGuard = (type) => (value) => typeof value === type;
+var isString = createIsGuard("string");
+var isNumber = createIsGuard("number");
+var isBigInt = createIsGuard("bigint");
+var isBoolean = createIsGuard("boolean");
+var isSymbol = createIsGuard("symbol");
+var isObject = createIsGuard("object");
+var isUndefined = createIsGuard("undefined");
+
+// src/assertion.ts
+function assert(condition, message = "assertion failed", Constructor = Error) {
+  if (!condition) {
+    throw new Constructor(message);
+  }
+}
+
+// src/bytes.ts
+var bytesToHex = (input) => {
+  const bytes = new Uint8Array(input);
+  return `0x${Array.from(bytes).map((byte) => byte.toString(16).padStart(2, "0")).join("")}`;
+};
+var hexToBytes = (input) => {
+  assert(/^0x[\da-f]*$/i.test(input) && input.length % 2 === 0, "Invalid hex string");
+  const hex = input.slice(2);
+  const bytes = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < hex.length; i += 2) {
+    bytes[i / 2] = Number.parseInt(hex.slice(i, i + 2), 16);
+  }
+  return bytes;
+};
+var convertBase = (bytes, fromBase, toBase) => {
+  const result = [];
+  for (const byte of bytes) {
+    let carry = byte;
+    for (let i = 0; i < result.length; i += 1) {
+      carry += result[i] * fromBase;
+      result[i] = carry % toBase;
+      carry = Math.floor(carry / toBase);
+    }
+    while (carry !== 0) {
+      result.push(carry % toBase);
+      carry = Math.floor(carry / toBase);
+    }
+  }
+  let leadingZeros = 0;
+  while (bytes[leadingZeros] === 0) {
+    leadingZeros += 1;
+    result.push(0);
+  }
+  return result.reverse();
+};
+var encodeBytesWithCharset = (bytes, charset) => convertBase(bytes, 256, charset.length).map((charCode) => charset.charAt(charCode)).join("");
+var decodeBytesWithCharset = (input, charset) => {
+  const charMap = Object.fromEntries([...charset].map((char, index) => [char, index]));
+  const bytes = input.split("").map((char) => charMap[char]);
+  return convertBase(bytes, charset.length, 256);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  bytesToHex,
+  decodeBytesWithCharset,
+  encodeBytesWithCharset,
+  hexToBytes
+});

package/dist/bytes.d.cts

@@ -0,0 +1,8 @@
+import { HexString } from './types.cjs';
+
+declare const bytesToHex: (input: Uint8Array | number[]) => `0x${string}`;
+declare const hexToBytes: (input: HexString) => Uint8Array;
+declare const encodeBytesWithCharset: (bytes: Uint8Array | number[], charset: string) => string;
+declare const decodeBytesWithCharset: (input: string, charset: string) => number[];
+
+export { bytesToHex, decodeBytesWithCharset, encodeBytesWithCharset, hexToBytes };

package/dist/bytes.d.ts

@@ -0,0 +1,8 @@
+import { HexString } from './types.js';
+
+declare const bytesToHex: (input: Uint8Array | number[]) => `0x${string}`;
+declare const hexToBytes: (input: HexString) => Uint8Array;
+declare const encodeBytesWithCharset: (bytes: Uint8Array | number[], charset: string) => string;
+declare const decodeBytesWithCharset: (input: string, charset: string) => number[];
+
+export { bytesToHex, decodeBytesWithCharset, encodeBytesWithCharset, hexToBytes };

package/dist/bytes.js

@@ -0,0 +1,14 @@
+import {
+  bytesToHex,
+  decodeBytesWithCharset,
+  encodeBytesWithCharset,
+  hexToBytes
+} from "./chunk-DGVZ5UDU.js";
+import "./chunk-NYJKCZRI.js";
+import "./chunk-CZNX6EUV.js";
+export {
+  bytesToHex,
+  decodeBytesWithCharset,
+  encodeBytesWithCharset,
+  hexToBytes
+};

package/dist/chunk-CZNX6EUV.js

@@ -0,0 +1,23 @@
+// src/guard.ts
+var createIsGuard = (type) => (value) => typeof value === type;
+var isString = createIsGuard("string");
+var isNumber = createIsGuard("number");
+var isBigInt = createIsGuard("bigint");
+var isBoolean = createIsGuard("boolean");
+var isSymbol = createIsGuard("symbol");
+var isObject = createIsGuard("object");
+var isUndefined = createIsGuard("undefined");
+var isNotNullish = (value) => value != null;
+var isNullish = (value) => value == null;
+
+export {
+  isString,
+  isNumber,
+  isBigInt,
+  isBoolean,
+  isSymbol,
+  isObject,
+  isUndefined,
+  isNotNullish,
+  isNullish
+};

package/dist/chunk-DGVZ5UDU.js

@@ -0,0 +1,52 @@
+import {
+  assert
+} from "./chunk-NYJKCZRI.js";
+
+// src/bytes.ts
+var bytesToHex = (input) => {
+  const bytes = new Uint8Array(input);
+  return `0x${Array.from(bytes).map((byte) => byte.toString(16).padStart(2, "0")).join("")}`;
+};
+var hexToBytes = (input) => {
+  assert(/^0x[\da-f]*$/i.test(input) && input.length % 2 === 0, "Invalid hex string");
+  const hex = input.slice(2);
+  const bytes = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < hex.length; i += 2) {
+    bytes[i / 2] = Number.parseInt(hex.slice(i, i + 2), 16);
+  }
+  return bytes;
+};
+var convertBase = (bytes, fromBase, toBase) => {
+  const result = [];
+  for (const byte of bytes) {
+    let carry = byte;
+    for (let i = 0; i < result.length; i += 1) {
+      carry += result[i] * fromBase;
+      result[i] = carry % toBase;
+      carry = Math.floor(carry / toBase);
+    }
+    while (carry !== 0) {
+      result.push(carry % toBase);
+      carry = Math.floor(carry / toBase);
+    }
+  }
+  let leadingZeros = 0;
+  while (bytes[leadingZeros] === 0) {
+    leadingZeros += 1;
+    result.push(0);
+  }
+  return result.reverse();
+};
+var encodeBytesWithCharset = (bytes, charset) => convertBase(bytes, 256, charset.length).map((charCode) => charset.charAt(charCode)).join("");
+var decodeBytesWithCharset = (input, charset) => {
+  const charMap = Object.fromEntries([...charset].map((char, index) => [char, index]));
+  const bytes = input.split("").map((char) => charMap[char]);
+  return convertBase(bytes, charset.length, 256);
+};
+
+export {
+  bytesToHex,
+  hexToBytes,
+  encodeBytesWithCharset,
+  decodeBytesWithCharset
+};

package/dist/chunk-MORKFLN4.js

@@ -0,0 +1,14 @@
+import {
+  decodeBytesWithCharset,
+  encodeBytesWithCharset
+} from "./chunk-DGVZ5UDU.js";
+
+// src/base58.ts
+var charset = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+var encode = (bytes) => encodeBytesWithCharset(bytes, charset);
+var decode = (input) => decodeBytesWithCharset(input, charset);
+
+export {
+  encode,
+  decode
+};