@haneullabs/bcs 0.1.0 → 2.0.3

package/dist/cjs/bcs.d.ts

@@ -1,175 +0,0 @@
-import type { BcsTypeOptions } from './bcs-type.js';
-import { BcsEnum, BcsStruct, BcsTuple, BcsType } from './bcs-type.js';
-import type { EnumInputShape, EnumOutputShape, InferBcsInput, InferBcsType, JoinString } from './types.js';
-declare function fixedArray<T extends BcsType<any>, Name extends string = string>(size: number, type: T, options?: BcsTypeOptions<InferBcsType<T>[], Iterable<InferBcsInput<T>> & {
-    length: number;
-}, Name>): BcsType<InferBcsType<T>[], Iterable<InferBcsInput<T>> & {
-    length: number;
-}, Name>;
-declare function fixedArray<T, Input, Name extends string = string>(size: number, type: BcsType<T, Input>, options?: BcsTypeOptions<T[], Iterable<Input> & {
-    length: number;
-}, Name>): BcsType<T[], Iterable<Input> & {
-    length: number;
-}, Name>;
-declare function option<T extends BcsType<any>>(type: T): BcsType<InferBcsType<T> | null, InferBcsInput<T> | null | undefined, `Option<${T['name']}>`>;
-declare function option<T, Input, Name extends string = string>(type: BcsType<T, Input, Name>): BcsType<T | null, Input | null | undefined>;
-declare function vector<T extends BcsType<any>, Name extends string = `vector<${T['name']}>`>(type: T, options?: BcsTypeOptions<InferBcsType<T>[], Iterable<InferBcsInput<T>> & {
-    length: number;
-}, Name>): BcsType<InferBcsType<T>[], Iterable<InferBcsInput<T>> & {
-    length: number;
-}, Name>;
-declare function vector<T, Input, Name extends string = string>(type: BcsType<T, Input, Name>, options?: BcsTypeOptions<T[], Iterable<Input> & {
-    length: number;
-}, `vector<${Name}>`>): BcsType<T[], Iterable<Input> & {
-    length: number;
-}, `vector<${Name}>`>;
-declare function map<K extends BcsType<any>, V extends BcsType<any>>(keyType: K, valueType: V): BcsType<Map<InferBcsType<K>, InferBcsType<V>>, Map<InferBcsInput<K>, InferBcsInput<V>>, `Map<${K['name']}, ${V['name']}>`>;
-declare function map<K, V, InputK = K, InputV = V>(keyType: BcsType<K, InputK>, valueType: BcsType<V, InputV>): BcsType<Map<K, V>, Map<InputK, InputV>, `Map<${string}, ${string}>`>;
-export declare const bcs: {
-    /**
-     * Creates a BcsType that can be used to read and write an 8-bit unsigned integer.
-     * @example
-     * bcs.u8().serialize(255).toBytes() // Uint8Array [ 255 ]
-     */
-    u8(options?: BcsTypeOptions<number>): BcsType<number, number, "u8">;
-    /**
-     * Creates a BcsType that can be used to read and write a 16-bit unsigned integer.
-     * @example
-     * bcs.u16().serialize(65535).toBytes() // Uint8Array [ 255, 255 ]
-     */
-    u16(options?: BcsTypeOptions<number>): BcsType<number, number, "u16">;
-    /**
-     * Creates a BcsType that can be used to read and write a 32-bit unsigned integer.
-     * @example
-     * bcs.u32().serialize(4294967295).toBytes() // Uint8Array [ 255, 255, 255, 255 ]
-     */
-    u32(options?: BcsTypeOptions<number>): BcsType<number, number, "u32">;
-    /**
-     * Creates a BcsType that can be used to read and write a 64-bit unsigned integer.
-     * @example
-     * bcs.u64().serialize(1).toBytes() // Uint8Array [ 1, 0, 0, 0, 0, 0, 0, 0 ]
-     */
-    u64(options?: BcsTypeOptions<string, number | bigint | string>): BcsType<string, string | number | bigint, "u64">;
-    /**
-     * Creates a BcsType that can be used to read and write a 128-bit unsigned integer.
-     * @example
-     * bcs.u128().serialize(1).toBytes() // Uint8Array [ 1, ..., 0 ]
-     */
-    u128(options?: BcsTypeOptions<string, number | bigint | string>): BcsType<string, string | number | bigint, "u128">;
-    /**
-     * Creates a BcsType that can be used to read and write a 256-bit unsigned integer.
-     * @example
-     * bcs.u256().serialize(1).toBytes() // Uint8Array [ 1, ..., 0 ]
-     */
-    u256(options?: BcsTypeOptions<string, number | bigint | string>): BcsType<string, string | number | bigint, "u256">;
-    /**
-     * Creates a BcsType that can be used to read and write boolean values.
-     * @example
-     * bcs.bool().serialize(true).toBytes() // Uint8Array [ 1 ]
-     */
-    bool(options?: BcsTypeOptions<boolean>): BcsType<boolean, boolean, "bool">;
-    /**
-     * Creates a BcsType that can be used to read and write unsigned LEB encoded integers
-     * @example
-     *
-     */
-    uleb128(options?: BcsTypeOptions<number>): BcsType<number, number, string>;
-    /**
-     * Creates a BcsType representing a fixed length byte array
-     * @param size The number of bytes this types represents
-     * @example
-     * bcs.bytes(3).serialize(new Uint8Array([1, 2, 3])).toBytes() // Uint8Array [1, 2, 3]
-     */
-    bytes<T extends number>(size: T, options?: BcsTypeOptions<Uint8Array, Iterable<number>>): BcsType<Uint8Array<ArrayBufferLike>, Iterable<number>, `bytes[${T}]`>;
-    /**
-     * Creates a BcsType representing a variable length byte array
-     *
-     * @example
-     * bcs.byteVector().serialize([1, 2, 3]).toBytes() // Uint8Array [3, 1, 2, 3]
-     */
-    byteVector(options?: BcsTypeOptions<Uint8Array, Iterable<number>>): BcsType<Uint8Array<ArrayBufferLike>, Iterable<number>, "vector<u8>">;
-    /**
-     * Creates a BcsType that can ser/de string values.  Strings will be UTF-8 encoded
-     * @example
-     * bcs.string().serialize('a').toBytes() // Uint8Array [ 1, 97 ]
-     */
-    string(options?: BcsTypeOptions<string>): BcsType<string, string, "string">;
-    /**
-     * Creates a BcsType that represents a fixed length array of a given type
-     * @param size The number of elements in the array
-     * @param type The BcsType of each element in the array
-     * @example
-     * bcs.fixedArray(3, bcs.u8()).serialize([1, 2, 3]).toBytes() // Uint8Array [ 1, 2, 3 ]
-     */
-    fixedArray: typeof fixedArray;
-    /**
-     * Creates a BcsType representing an optional value
-     * @param type The BcsType of the optional value
-     * @example
-     * bcs.option(bcs.u8()).serialize(null).toBytes() // Uint8Array [ 0 ]
-     * bcs.option(bcs.u8()).serialize(1).toBytes() // Uint8Array [ 1, 1 ]
-     */
-    option: typeof option;
-    /**
-     * Creates a BcsType representing a variable length vector of a given type
-     * @param type The BcsType of each element in the vector
-     *
-     * @example
-     * bcs.vector(bcs.u8()).toBytes([1, 2, 3]) // Uint8Array [ 3, 1, 2, 3 ]
-     */
-    vector: typeof vector;
-    /**
-     * Creates a BcsType representing a tuple of a given set of types
-     * @param types The BcsTypes for each element in the tuple
-     *
-     * @example
-     * const tuple = bcs.tuple([bcs.u8(), bcs.string(), bcs.bool()])
-     * tuple.serialize([1, 'a', true]).toBytes() // Uint8Array [ 1, 1, 97, 1 ]
-     */
-    tuple<const T extends readonly BcsType<any, any>[], const Name extends string = `(${JoinString<{ [K in keyof T]: T[K] extends BcsType<any, any, infer T_1 extends string> ? T_1 : never; }, ", ">})`>(fields: T, options?: BcsTypeOptions<{ -readonly [K_1 in keyof T]: T[K_1] extends BcsType<infer T_1, any> ? T_1 : never; }, { [K_1 in keyof T]: T[K_1] extends BcsType<any, infer T_1> ? T_1 : never; }, Name>): BcsTuple<T, Name>;
-    /**
-     * Creates a BcsType representing a struct of a given set of fields
-     * @param name The name of the struct
-     * @param fields The fields of the struct. The order of the fields affects how data is serialized and deserialized
-     *
-     * @example
-     * const struct = bcs.struct('MyStruct', {
-     *  a: bcs.u8(),
-     *  b: bcs.string(),
-     * })
-     * struct.serialize({ a: 1, b: 'a' }).toBytes() // Uint8Array [ 1, 1, 97 ]
-     */
-    struct<T extends Record<string, BcsType<any>>, const Name extends string = string>(name: Name, fields: T, options?: Omit<BcsTypeOptions<{ [K in keyof T]: T[K] extends BcsType<infer U, any> ? U : never; }, { [K in keyof T]: T[K] extends BcsType<any, infer U> ? U : never; }>, "name">): BcsStruct<T, string>;
-    /**
-     * Creates a BcsType representing an enum of a given set of options
-     * @param name The name of the enum
-     * @param values The values of the enum. The order of the values affects how data is serialized and deserialized.
-     * null can be used to represent a variant with no data.
-     *
-     * @example
-     * const enum = bcs.enum('MyEnum', {
-     *   A: bcs.u8(),
-     *   B: bcs.string(),
-     *   C: null,
-     * })
-     * enum.serialize({ A: 1 }).toBytes() // Uint8Array [ 0, 1 ]
-     * enum.serialize({ B: 'a' }).toBytes() // Uint8Array [ 1, 1, 97 ]
-     * enum.serialize({ C: true }).toBytes() // Uint8Array [ 2 ]
-     */
-    enum<T extends Record<string, BcsType<any> | null>, const Name extends string = string>(name: Name, fields: T, options?: Omit<BcsTypeOptions<EnumOutputShape<{ [K in keyof T]: T[K] extends BcsType<infer U, any, any> ? U : true; }>, EnumInputShape<{ [K in keyof T]: T[K] extends BcsType<any, infer U, any> ? U : boolean | object | null; }>, Name>, "name">): BcsEnum<T, Name>;
-    /**
-     * Creates a BcsType representing a map of a given key and value type
-     * @param keyType The BcsType of the key
-     * @param valueType The BcsType of the value
-     * @example
-     * const map = bcs.map(bcs.u8(), bcs.string())
-     * map.serialize(new Map([[2, 'a']])).toBytes() // Uint8Array [ 1, 2, 1, 97 ]
-     */
-    map: typeof map;
-    /**
-     * Creates a BcsType that wraps another BcsType which is lazily evaluated. This is useful for creating recursive types.
-     * @param cb A callback that returns the BcsType
-     */
-    lazy<T extends BcsType<any>>(cb: () => T): T;
-};
-export {};

package/dist/cjs/bcs.js

@@ -1,406 +0,0 @@
-"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);
-var bcs_exports = {};
-__export(bcs_exports, {
-  bcs: () => bcs
-});
-module.exports = __toCommonJS(bcs_exports);
-var import_bcs_type = require("./bcs-type.js");
-var import_uleb = require("./uleb.js");
-function fixedArray(size, type, options) {
-  return new import_bcs_type.BcsType({
-    read: (reader) => {
-      const result = new Array(size);
-      for (let i = 0; i < size; i++) {
-        result[i] = type.read(reader);
-      }
-      return result;
-    },
-    write: (value, writer) => {
-      for (const item of value) {
-        type.write(item, writer);
-      }
-    },
-    ...options,
-    name: options?.name ?? `${type.name}[${size}]`,
-    validate: (value) => {
-      options?.validate?.(value);
-      if (!value || typeof value !== "object" || !("length" in value)) {
-        throw new TypeError(`Expected array, found ${typeof value}`);
-      }
-      if (value.length !== size) {
-        throw new TypeError(`Expected array of length ${size}, found ${value.length}`);
-      }
-    }
-  });
-}
-function option(type) {
-  return bcs.enum(`Option<${type.name}>`, {
-    None: null,
-    Some: type
-  }).transform({
-    input: (value) => {
-      if (value == null) {
-        return { None: true };
-      }
-      return { Some: value };
-    },
-    output: (value) => {
-      if (value.$kind === "Some") {
-        return value.Some;
-      }
-      return null;
-    }
-  });
-}
-function vector(type, options) {
-  return new import_bcs_type.BcsType({
-    read: (reader) => {
-      const length = reader.readULEB();
-      const result = new Array(length);
-      for (let i = 0; i < length; i++) {
-        result[i] = type.read(reader);
-      }
-      return result;
-    },
-    write: (value, writer) => {
-      writer.writeULEB(value.length);
-      for (const item of value) {
-        type.write(item, writer);
-      }
-    },
-    ...options,
-    name: options?.name ?? `vector<${type.name}>`,
-    validate: (value) => {
-      options?.validate?.(value);
-      if (!value || typeof value !== "object" || !("length" in value)) {
-        throw new TypeError(`Expected array, found ${typeof value}`);
-      }
-    }
-  });
-}
-function map(keyType, valueType) {
-  return bcs.vector(bcs.tuple([keyType, valueType])).transform({
-    name: `Map<${keyType.name}, ${valueType.name}>`,
-    input: (value) => {
-      return [...value.entries()];
-    },
-    output: (value) => {
-      const result = /* @__PURE__ */ new Map();
-      for (const [key, val] of value) {
-        result.set(key, val);
-      }
-      return result;
-    }
-  });
-}
-const bcs = {
-  /**
-   * Creates a BcsType that can be used to read and write an 8-bit unsigned integer.
-   * @example
-   * bcs.u8().serialize(255).toBytes() // Uint8Array [ 255 ]
-   */
-  u8(options) {
-    return (0, import_bcs_type.uIntBcsType)({
-      readMethod: "read8",
-      writeMethod: "write8",
-      size: 1,
-      maxValue: 2 ** 8 - 1,
-      ...options,
-      name: options?.name ?? "u8"
-    });
-  },
-  /**
-   * Creates a BcsType that can be used to read and write a 16-bit unsigned integer.
-   * @example
-   * bcs.u16().serialize(65535).toBytes() // Uint8Array [ 255, 255 ]
-   */
-  u16(options) {
-    return (0, import_bcs_type.uIntBcsType)({
-      readMethod: "read16",
-      writeMethod: "write16",
-      size: 2,
-      maxValue: 2 ** 16 - 1,
-      ...options,
-      name: options?.name ?? "u16"
-    });
-  },
-  /**
-   * Creates a BcsType that can be used to read and write a 32-bit unsigned integer.
-   * @example
-   * bcs.u32().serialize(4294967295).toBytes() // Uint8Array [ 255, 255, 255, 255 ]
-   */
-  u32(options) {
-    return (0, import_bcs_type.uIntBcsType)({
-      readMethod: "read32",
-      writeMethod: "write32",
-      size: 4,
-      maxValue: 2 ** 32 - 1,
-      ...options,
-      name: options?.name ?? "u32"
-    });
-  },
-  /**
-   * Creates a BcsType that can be used to read and write a 64-bit unsigned integer.
-   * @example
-   * bcs.u64().serialize(1).toBytes() // Uint8Array [ 1, 0, 0, 0, 0, 0, 0, 0 ]
-   */
-  u64(options) {
-    return (0, import_bcs_type.bigUIntBcsType)({
-      readMethod: "read64",
-      writeMethod: "write64",
-      size: 8,
-      maxValue: 2n ** 64n - 1n,
-      ...options,
-      name: options?.name ?? "u64"
-    });
-  },
-  /**
-   * Creates a BcsType that can be used to read and write a 128-bit unsigned integer.
-   * @example
-   * bcs.u128().serialize(1).toBytes() // Uint8Array [ 1, ..., 0 ]
-   */
-  u128(options) {
-    return (0, import_bcs_type.bigUIntBcsType)({
-      readMethod: "read128",
-      writeMethod: "write128",
-      size: 16,
-      maxValue: 2n ** 128n - 1n,
-      ...options,
-      name: options?.name ?? "u128"
-    });
-  },
-  /**
-   * Creates a BcsType that can be used to read and write a 256-bit unsigned integer.
-   * @example
-   * bcs.u256().serialize(1).toBytes() // Uint8Array [ 1, ..., 0 ]
-   */
-  u256(options) {
-    return (0, import_bcs_type.bigUIntBcsType)({
-      readMethod: "read256",
-      writeMethod: "write256",
-      size: 32,
-      maxValue: 2n ** 256n - 1n,
-      ...options,
-      name: options?.name ?? "u256"
-    });
-  },
-  /**
-   * Creates a BcsType that can be used to read and write boolean values.
-   * @example
-   * bcs.bool().serialize(true).toBytes() // Uint8Array [ 1 ]
-   */
-  bool(options) {
-    return (0, import_bcs_type.fixedSizeBcsType)({
-      size: 1,
-      read: (reader) => reader.read8() === 1,
-      write: (value, writer) => writer.write8(value ? 1 : 0),
-      ...options,
-      name: options?.name ?? "bool",
-      validate: (value) => {
-        options?.validate?.(value);
-        if (typeof value !== "boolean") {
-          throw new TypeError(`Expected boolean, found ${typeof value}`);
-        }
-      }
-    });
-  },
-  /**
-   * Creates a BcsType that can be used to read and write unsigned LEB encoded integers
-   * @example
-   *
-   */
-  uleb128(options) {
-    return (0, import_bcs_type.dynamicSizeBcsType)({
-      read: (reader) => reader.readULEB(),
-      serialize: (value) => {
-        return Uint8Array.from((0, import_uleb.ulebEncode)(value));
-      },
-      ...options,
-      name: options?.name ?? "uleb128"
-    });
-  },
-  /**
-   * Creates a BcsType representing a fixed length byte array
-   * @param size The number of bytes this types represents
-   * @example
-   * bcs.bytes(3).serialize(new Uint8Array([1, 2, 3])).toBytes() // Uint8Array [1, 2, 3]
-   */
-  bytes(size, options) {
-    return (0, import_bcs_type.fixedSizeBcsType)({
-      size,
-      read: (reader) => reader.readBytes(size),
-      write: (value, writer) => {
-        writer.writeBytes(new Uint8Array(value));
-      },
-      ...options,
-      name: options?.name ?? `bytes[${size}]`,
-      validate: (value) => {
-        options?.validate?.(value);
-        if (!value || typeof value !== "object" || !("length" in value)) {
-          throw new TypeError(`Expected array, found ${typeof value}`);
-        }
-        if (value.length !== size) {
-          throw new TypeError(`Expected array of length ${size}, found ${value.length}`);
-        }
-      }
-    });
-  },
-  /**
-   * Creates a BcsType representing a variable length byte array
-   *
-   * @example
-   * bcs.byteVector().serialize([1, 2, 3]).toBytes() // Uint8Array [3, 1, 2, 3]
-   */
-  byteVector(options) {
-    return new import_bcs_type.BcsType({
-      read: (reader) => {
-        const length = reader.readULEB();
-        return reader.readBytes(length);
-      },
-      write: (value, writer) => {
-        const array = new Uint8Array(value);
-        writer.writeULEB(array.length);
-        writer.writeBytes(array);
-      },
-      ...options,
-      name: options?.name ?? "vector<u8>",
-      serializedSize: (value) => {
-        const length = "length" in value ? value.length : null;
-        return length == null ? null : (0, import_uleb.ulebEncode)(length).length + length;
-      },
-      validate: (value) => {
-        options?.validate?.(value);
-        if (!value || typeof value !== "object" || !("length" in value)) {
-          throw new TypeError(`Expected array, found ${typeof value}`);
-        }
-      }
-    });
-  },
-  /**
-   * Creates a BcsType that can ser/de string values.  Strings will be UTF-8 encoded
-   * @example
-   * bcs.string().serialize('a').toBytes() // Uint8Array [ 1, 97 ]
-   */
-  string(options) {
-    return (0, import_bcs_type.stringLikeBcsType)({
-      toBytes: (value) => new TextEncoder().encode(value),
-      fromBytes: (bytes) => new TextDecoder().decode(bytes),
-      ...options,
-      name: options?.name ?? "string"
-    });
-  },
-  /**
-   * Creates a BcsType that represents a fixed length array of a given type
-   * @param size The number of elements in the array
-   * @param type The BcsType of each element in the array
-   * @example
-   * bcs.fixedArray(3, bcs.u8()).serialize([1, 2, 3]).toBytes() // Uint8Array [ 1, 2, 3 ]
-   */
-  fixedArray,
-  /**
-   * Creates a BcsType representing an optional value
-   * @param type The BcsType of the optional value
-   * @example
-   * bcs.option(bcs.u8()).serialize(null).toBytes() // Uint8Array [ 0 ]
-   * bcs.option(bcs.u8()).serialize(1).toBytes() // Uint8Array [ 1, 1 ]
-   */
-  option,
-  /**
-   * Creates a BcsType representing a variable length vector of a given type
-   * @param type The BcsType of each element in the vector
-   *
-   * @example
-   * bcs.vector(bcs.u8()).toBytes([1, 2, 3]) // Uint8Array [ 3, 1, 2, 3 ]
-   */
-  vector,
-  /**
-   * Creates a BcsType representing a tuple of a given set of types
-   * @param types The BcsTypes for each element in the tuple
-   *
-   * @example
-   * const tuple = bcs.tuple([bcs.u8(), bcs.string(), bcs.bool()])
-   * tuple.serialize([1, 'a', true]).toBytes() // Uint8Array [ 1, 1, 97, 1 ]
-   */
-  tuple(fields, options) {
-    return new import_bcs_type.BcsTuple({
-      fields,
-      ...options
-    });
-  },
-  /**
-   * Creates a BcsType representing a struct of a given set of fields
-   * @param name The name of the struct
-   * @param fields The fields of the struct. The order of the fields affects how data is serialized and deserialized
-   *
-   * @example
-   * const struct = bcs.struct('MyStruct', {
-   *  a: bcs.u8(),
-   *  b: bcs.string(),
-   * })
-   * struct.serialize({ a: 1, b: 'a' }).toBytes() // Uint8Array [ 1, 1, 97 ]
-   */
-  struct(name, fields, options) {
-    return new import_bcs_type.BcsStruct({
-      name,
-      fields,
-      ...options
-    });
-  },
-  /**
-   * Creates a BcsType representing an enum of a given set of options
-   * @param name The name of the enum
-   * @param values The values of the enum. The order of the values affects how data is serialized and deserialized.
-   * null can be used to represent a variant with no data.
-   *
-   * @example
-   * const enum = bcs.enum('MyEnum', {
-   *   A: bcs.u8(),
-   *   B: bcs.string(),
-   *   C: null,
-   * })
-   * enum.serialize({ A: 1 }).toBytes() // Uint8Array [ 0, 1 ]
-   * enum.serialize({ B: 'a' }).toBytes() // Uint8Array [ 1, 1, 97 ]
-   * enum.serialize({ C: true }).toBytes() // Uint8Array [ 2 ]
-   */
-  enum(name, fields, options) {
-    return new import_bcs_type.BcsEnum({
-      name,
-      fields,
-      ...options
-    });
-  },
-  /**
-   * Creates a BcsType representing a map of a given key and value type
-   * @param keyType The BcsType of the key
-   * @param valueType The BcsType of the value
-   * @example
-   * const map = bcs.map(bcs.u8(), bcs.string())
-   * map.serialize(new Map([[2, 'a']])).toBytes() // Uint8Array [ 1, 2, 1, 97 ]
-   */
-  map,
-  /**
-   * Creates a BcsType that wraps another BcsType which is lazily evaluated. This is useful for creating recursive types.
-   * @param cb A callback that returns the BcsType
-   */
-  lazy(cb) {
-    return (0, import_bcs_type.lazyBcsType)(cb);
-  }
-};
-//# sourceMappingURL=bcs.js.map

package/dist/cjs/bcs.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/bcs.ts"],
-  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { BcsTypeOptions } from './bcs-type.js';\nimport {\n\tBcsEnum,\n\tBcsStruct,\n\tBcsTuple,\n\tBcsType,\n\tbigUIntBcsType,\n\tdynamicSizeBcsType,\n\tfixedSizeBcsType,\n\tlazyBcsType,\n\tstringLikeBcsType,\n\tuIntBcsType,\n} from './bcs-type.js';\nimport type {\n\tEnumInputShape,\n\tEnumOutputShape,\n\tInferBcsInput,\n\tInferBcsType,\n\tJoinString,\n} from './types.js';\nimport { ulebEncode } from './uleb.js';\n\nfunction fixedArray<T extends BcsType<any>, Name extends string = string>(\n\tsize: number,\n\ttype: T,\n\toptions?: BcsTypeOptions<\n\t\tInferBcsType<T>[],\n\t\tIterable<InferBcsInput<T>> & { length: number },\n\t\tName\n\t>,\n): BcsType<InferBcsType<T>[], Iterable<InferBcsInput<T>> & { length: number }, Name>;\nfunction fixedArray<T, Input, Name extends string = string>(\n\tsize: number,\n\ttype: BcsType<T, Input>,\n\toptions?: BcsTypeOptions<T[], Iterable<Input> & { length: number }, Name>,\n): BcsType<T[], Iterable<Input> & { length: number }, Name>;\nfunction fixedArray<T extends BcsType<any>, Name extends string = `${T['name']}[${number}]`>(\n\tsize: number,\n\ttype: T,\n\toptions?: BcsTypeOptions<\n\t\tInferBcsType<T>[],\n\t\tIterable<InferBcsInput<T>> & { length: number },\n\t\tName\n\t>,\n): BcsType<InferBcsType<T>[], Iterable<InferBcsInput<T>> & { length: number }, Name> {\n\treturn new BcsType<InferBcsType<T>[], Iterable<InferBcsInput<T>> & { length: number }, Name>({\n\t\tread: (reader) => {\n\t\t\tconst result: InferBcsType<T>[] = new Array(size);\n\t\t\tfor (let i = 0; i < size; i++) {\n\t\t\t\tresult[i] = type.read(reader);\n\t\t\t}\n\t\t\treturn result;\n\t\t},\n\t\twrite: (value, writer) => {\n\t\t\tfor (const item of value) {\n\t\t\t\ttype.write(item, writer);\n\t\t\t}\n\t\t},\n\t\t...options,\n\t\tname: (options?.name ?? `${type.name}[${size}]`) as Name,\n\t\tvalidate: (value) => {\n\t\t\toptions?.validate?.(value);\n\t\t\tif (!value || typeof value !== 'object' || !('length' in value)) {\n\t\t\t\tthrow new TypeError(`Expected array, found ${typeof value}`);\n\t\t\t}\n\t\t\tif (value.length !== size) {\n\t\t\t\tthrow new TypeError(`Expected array of length ${size}, found ${value.length}`);\n\t\t\t}\n\t\t},\n\t});\n}\n\nfunction option<T extends BcsType<any>>(\n\ttype: T,\n): BcsType<InferBcsType<T> | null, InferBcsInput<T> | null | undefined, `Option<${T['name']}>`>;\nfunction option<T, Input, Name extends string = string>(\n\ttype: BcsType<T, Input, Name>,\n): BcsType<T | null, Input | null | undefined>;\nfunction option<T extends BcsType<any>>(\n\ttype: T,\n): BcsType<InferBcsType<T> | null, InferBcsInput<T> | null | undefined, `Option<${T['name']}>`> {\n\treturn bcs\n\t\t.enum(`Option<${type.name}>`, {\n\t\t\tNone: null,\n\t\t\tSome: type,\n\t\t})\n\t\t.transform({\n\t\t\tinput: (value: InferBcsInput<T> | null | undefined) => {\n\t\t\t\tif (value == null) {\n\t\t\t\t\treturn { None: true };\n\t\t\t\t}\n\n\t\t\t\treturn { Some: value };\n\t\t\t},\n\t\t\toutput: (value) => {\n\t\t\t\tif (value.$kind === 'Some') {\n\t\t\t\t\treturn value.Some as InferBcsType<T>;\n\t\t\t\t}\n\n\t\t\t\treturn null;\n\t\t\t},\n\t\t});\n}\n\nfunction vector<T extends BcsType<any>, Name extends string = `vector<${T['name']}>`>(\n\ttype: T,\n\toptions?: BcsTypeOptions<\n\t\tInferBcsType<T>[],\n\t\tIterable<InferBcsInput<T>> & { length: number },\n\t\tName\n\t>,\n): BcsType<InferBcsType<T>[], Iterable<InferBcsInput<T>> & { length: number }, Name>;\nfunction vector<T, Input, Name extends string = string>(\n\ttype: BcsType<T, Input, Name>,\n\toptions?: BcsTypeOptions<T[], Iterable<Input> & { length: number }, `vector<${Name}>`>,\n): BcsType<T[], Iterable<Input> & { length: number }, `vector<${Name}>`>;\nfunction vector<T extends BcsType<any>, Name extends string = `vector<${T['name']}>`>(\n\ttype: T,\n\toptions?: BcsTypeOptions<\n\t\tInferBcsType<T>[],\n\t\tIterable<InferBcsInput<T>> & { length: number },\n\t\tName\n\t>,\n): BcsType<InferBcsType<T>[], Iterable<InferBcsInput<T>> & { length: number }, Name> {\n\treturn new BcsType<InferBcsType<T>[], Iterable<InferBcsInput<T>> & { length: number }, Name>({\n\t\tread: (reader) => {\n\t\t\tconst length = reader.readULEB();\n\t\t\tconst result: InferBcsType<T>[] = new Array(length);\n\t\t\tfor (let i = 0; i < length; i++) {\n\t\t\t\tresult[i] = type.read(reader);\n\t\t\t}\n\t\t\treturn result;\n\t\t},\n\t\twrite: (value, writer) => {\n\t\t\twriter.writeULEB(value.length);\n\t\t\tfor (const item of value) {\n\t\t\t\ttype.write(item, writer);\n\t\t\t}\n\t\t},\n\t\t...options,\n\t\tname: (options?.name ?? `vector<${type.name}>`) as Name,\n\t\tvalidate: (value) => {\n\t\t\toptions?.validate?.(value);\n\t\t\tif (!value || typeof value !== 'object' || !('length' in value)) {\n\t\t\t\tthrow new TypeError(`Expected array, found ${typeof value}`);\n\t\t\t}\n\t\t},\n\t});\n}\n\nfunction map<K extends BcsType<any>, V extends BcsType<any>>(\n\tkeyType: K,\n\tvalueType: V,\n): BcsType<\n\tMap<InferBcsType<K>, InferBcsType<V>>,\n\tMap<InferBcsInput<K>, InferBcsInput<V>>,\n\t`Map<${K['name']}, ${V['name']}>`\n>;\nfunction map<K, V, InputK = K, InputV = V>(\n\tkeyType: BcsType<K, InputK>,\n\tvalueType: BcsType<V, InputV>,\n): BcsType<Map<K, V>, Map<InputK, InputV>, `Map<${string}, ${string}>`>;\nfunction map<K extends BcsType<any>, V extends BcsType<any>>(\n\tkeyType: K,\n\tvalueType: V,\n): BcsType<\n\tMap<InferBcsType<K>, InferBcsType<V>>,\n\tMap<InferBcsInput<K>, InferBcsInput<V>>,\n\t`Map<${K['name']}, ${V['name']}>`\n> {\n\treturn bcs.vector(bcs.tuple([keyType, valueType])).transform({\n\t\tname: `Map<${keyType.name}, ${valueType.name}>`,\n\t\tinput: (value: Map<InferBcsInput<K>, InferBcsInput<V>>) => {\n\t\t\treturn [...value.entries()];\n\t\t},\n\t\toutput: (value) => {\n\t\t\tconst result = new Map<InferBcsType<K>, InferBcsType<V>>();\n\t\t\tfor (const [key, val] of value) {\n\t\t\t\tresult.set(key, val);\n\t\t\t}\n\t\t\treturn result;\n\t\t},\n\t});\n}\n\nexport const bcs = {\n\t/**\n\t * Creates a BcsType that can be used to read and write an 8-bit unsigned integer.\n\t * @example\n\t * bcs.u8().serialize(255).toBytes() // Uint8Array [ 255 ]\n\t */\n\tu8(options?: BcsTypeOptions<number>) {\n\t\treturn uIntBcsType({\n\t\t\treadMethod: 'read8',\n\t\t\twriteMethod: 'write8',\n\t\t\tsize: 1,\n\t\t\tmaxValue: 2 ** 8 - 1,\n\t\t\t...options,\n\t\t\tname: (options?.name ?? 'u8') as 'u8',\n\t\t});\n\t},\n\n\t/**\n\t * Creates a BcsType that can be used to read and write a 16-bit unsigned integer.\n\t * @example\n\t * bcs.u16().serialize(65535).toBytes() // Uint8Array [ 255, 255 ]\n\t */\n\tu16(options?: BcsTypeOptions<number>) {\n\t\treturn uIntBcsType({\n\t\t\treadMethod: 'read16',\n\t\t\twriteMethod: 'write16',\n\t\t\tsize: 2,\n\t\t\tmaxValue: 2 ** 16 - 1,\n\t\t\t...options,\n\t\t\tname: (options?.name ?? 'u16') as 'u16',\n\t\t});\n\t},\n\n\t/**\n\t * Creates a BcsType that can be used to read and write a 32-bit unsigned integer.\n\t * @example\n\t * bcs.u32().serialize(4294967295).toBytes() // Uint8Array [ 255, 255, 255, 255 ]\n\t */\n\tu32(options?: BcsTypeOptions<number>) {\n\t\treturn uIntBcsType({\n\t\t\treadMethod: 'read32',\n\t\t\twriteMethod: 'write32',\n\t\t\tsize: 4,\n\t\t\tmaxValue: 2 ** 32 - 1,\n\t\t\t...options,\n\t\t\tname: (options?.name ?? 'u32') as 'u32',\n\t\t});\n\t},\n\n\t/**\n\t * Creates a BcsType that can be used to read and write a 64-bit unsigned integer.\n\t * @example\n\t * bcs.u64().serialize(1).toBytes() // Uint8Array [ 1, 0, 0, 0, 0, 0, 0, 0 ]\n\t */\n\tu64(options?: BcsTypeOptions<string, number | bigint | string>) {\n\t\treturn bigUIntBcsType({\n\t\t\treadMethod: 'read64',\n\t\t\twriteMethod: 'write64',\n\t\t\tsize: 8,\n\t\t\tmaxValue: 2n ** 64n - 1n,\n\t\t\t...options,\n\t\t\tname: (options?.name ?? 'u64') as 'u64',\n\t\t});\n\t},\n\n\t/**\n\t * Creates a BcsType that can be used to read and write a 128-bit unsigned integer.\n\t * @example\n\t * bcs.u128().serialize(1).toBytes() // Uint8Array [ 1, ..., 0 ]\n\t */\n\tu128(options?: BcsTypeOptions<string, number | bigint | string>) {\n\t\treturn bigUIntBcsType({\n\t\t\treadMethod: 'read128',\n\t\t\twriteMethod: 'write128',\n\t\t\tsize: 16,\n\t\t\tmaxValue: 2n ** 128n - 1n,\n\t\t\t...options,\n\t\t\tname: (options?.name ?? 'u128') as 'u128',\n\t\t});\n\t},\n\n\t/**\n\t * Creates a BcsType that can be used to read and write a 256-bit unsigned integer.\n\t * @example\n\t * bcs.u256().serialize(1).toBytes() // Uint8Array [ 1, ..., 0 ]\n\t */\n\tu256(options?: BcsTypeOptions<string, number | bigint | string>) {\n\t\treturn bigUIntBcsType({\n\t\t\treadMethod: 'read256',\n\t\t\twriteMethod: 'write256',\n\t\t\tsize: 32,\n\t\t\tmaxValue: 2n ** 256n - 1n,\n\t\t\t...options,\n\t\t\tname: (options?.name ?? 'u256') as 'u256',\n\t\t});\n\t},\n\n\t/**\n\t * Creates a BcsType that can be used to read and write boolean values.\n\t * @example\n\t * bcs.bool().serialize(true).toBytes() // Uint8Array [ 1 ]\n\t */\n\tbool(options?: BcsTypeOptions<boolean>) {\n\t\treturn fixedSizeBcsType({\n\t\t\tsize: 1,\n\t\t\tread: (reader) => reader.read8() === 1,\n\t\t\twrite: (value, writer) => writer.write8(value ? 1 : 0),\n\t\t\t...options,\n\t\t\tname: (options?.name ?? 'bool') as 'bool',\n\t\t\tvalidate: (value) => {\n\t\t\t\toptions?.validate?.(value);\n\t\t\t\tif (typeof value !== 'boolean') {\n\t\t\t\t\tthrow new TypeError(`Expected boolean, found ${typeof value}`);\n\t\t\t\t}\n\t\t\t},\n\t\t});\n\t},\n\n\t/**\n\t * Creates a BcsType that can be used to read and write unsigned LEB encoded integers\n\t * @example\n\t *\n\t */\n\tuleb128(options?: BcsTypeOptions<number>) {\n\t\treturn dynamicSizeBcsType({\n\t\t\tread: (reader) => reader.readULEB(),\n\t\t\tserialize: (value) => {\n\t\t\t\treturn Uint8Array.from(ulebEncode(value));\n\t\t\t},\n\t\t\t...options,\n\t\t\tname: (options?.name ?? 'uleb128') as 'uleb128',\n\t\t});\n\t},\n\n\t/**\n\t * Creates a BcsType representing a fixed length byte array\n\t * @param size The number of bytes this types represents\n\t * @example\n\t * bcs.bytes(3).serialize(new Uint8Array([1, 2, 3])).toBytes() // Uint8Array [1, 2, 3]\n\t */\n\tbytes<T extends number>(size: T, options?: BcsTypeOptions<Uint8Array, Iterable<number>>) {\n\t\treturn fixedSizeBcsType<Uint8Array, Iterable<number>, `bytes[${T}]`>({\n\t\t\tsize,\n\t\t\tread: (reader) => reader.readBytes(size),\n\t\t\twrite: (value, writer) => {\n\t\t\t\twriter.writeBytes(new Uint8Array(value));\n\t\t\t},\n\t\t\t...options,\n\t\t\tname: (options?.name ?? `bytes[${size}]`) as `bytes[${T}]`,\n\t\t\tvalidate: (value) => {\n\t\t\t\toptions?.validate?.(value);\n\t\t\t\tif (!value || typeof value !== 'object' || !('length' in value)) {\n\t\t\t\t\tthrow new TypeError(`Expected array, found ${typeof value}`);\n\t\t\t\t}\n\t\t\t\tif (value.length !== size) {\n\t\t\t\t\tthrow new TypeError(`Expected array of length ${size}, found ${value.length}`);\n\t\t\t\t}\n\t\t\t},\n\t\t});\n\t},\n\n\t/**\n\t * Creates a BcsType representing a variable length byte array\n\t *\n\t * @example\n\t * bcs.byteVector().serialize([1, 2, 3]).toBytes() // Uint8Array [3, 1, 2, 3]\n\t */\n\tbyteVector(options?: BcsTypeOptions<Uint8Array, Iterable<number>>) {\n\t\treturn new BcsType<Uint8Array, Iterable<number>, 'vector<u8>'>({\n\t\t\tread: (reader) => {\n\t\t\t\tconst length = reader.readULEB();\n\n\t\t\t\treturn reader.readBytes(length);\n\t\t\t},\n\t\t\twrite: (value, writer) => {\n\t\t\t\tconst array = new Uint8Array(value);\n\t\t\t\twriter.writeULEB(array.length);\n\t\t\t\twriter.writeBytes(array);\n\t\t\t},\n\t\t\t...options,\n\t\t\tname: (options?.name ?? 'vector<u8>') as 'vector<u8>',\n\t\t\tserializedSize: (value) => {\n\t\t\t\tconst length = 'length' in value ? (value.length as number) : null;\n\t\t\t\treturn length == null ? null : ulebEncode(length).length + length;\n\t\t\t},\n\t\t\tvalidate: (value) => {\n\t\t\t\toptions?.validate?.(value);\n\t\t\t\tif (!value || typeof value !== 'object' || !('length' in value)) {\n\t\t\t\t\tthrow new TypeError(`Expected array, found ${typeof value}`);\n\t\t\t\t}\n\t\t\t},\n\t\t});\n\t},\n\n\t/**\n\t * Creates a BcsType that can ser/de string values.  Strings will be UTF-8 encoded\n\t * @example\n\t * bcs.string().serialize('a').toBytes() // Uint8Array [ 1, 97 ]\n\t */\n\tstring(options?: BcsTypeOptions<string>) {\n\t\treturn stringLikeBcsType({\n\t\t\ttoBytes: (value) => new TextEncoder().encode(value),\n\t\t\tfromBytes: (bytes) => new TextDecoder().decode(bytes),\n\t\t\t...options,\n\t\t\tname: (options?.name ?? 'string') as 'string',\n\t\t});\n\t},\n\t/**\n\t * Creates a BcsType that represents a fixed length array of a given type\n\t * @param size The number of elements in the array\n\t * @param type The BcsType of each element in the array\n\t * @example\n\t * bcs.fixedArray(3, bcs.u8()).serialize([1, 2, 3]).toBytes() // Uint8Array [ 1, 2, 3 ]\n\t */\n\tfixedArray,\n\n\t/**\n\t * Creates a BcsType representing an optional value\n\t * @param type The BcsType of the optional value\n\t * @example\n\t * bcs.option(bcs.u8()).serialize(null).toBytes() // Uint8Array [ 0 ]\n\t * bcs.option(bcs.u8()).serialize(1).toBytes() // Uint8Array [ 1, 1 ]\n\t */\n\toption,\n\n\t/**\n\t * Creates a BcsType representing a variable length vector of a given type\n\t * @param type The BcsType of each element in the vector\n\t *\n\t * @example\n\t * bcs.vector(bcs.u8()).toBytes([1, 2, 3]) // Uint8Array [ 3, 1, 2, 3 ]\n\t */\n\tvector,\n\n\t/**\n\t * Creates a BcsType representing a tuple of a given set of types\n\t * @param types The BcsTypes for each element in the tuple\n\t *\n\t * @example\n\t * const tuple = bcs.tuple([bcs.u8(), bcs.string(), bcs.bool()])\n\t * tuple.serialize([1, 'a', true]).toBytes() // Uint8Array [ 1, 1, 97, 1 ]\n\t */\n\ttuple<\n\t\tconst T extends readonly BcsType<any, any>[],\n\t\tconst Name extends string =\n\t\t\t`(${JoinString<{ [K in keyof T]: T[K] extends BcsType<any, any, infer T> ? T : never }, ', '>})`,\n\t>(\n\t\tfields: T,\n\t\toptions?: BcsTypeOptions<\n\t\t\t{\n\t\t\t\t-readonly [K in keyof T]: T[K] extends BcsType<infer T, any> ? T : never;\n\t\t\t},\n\t\t\t{\n\t\t\t\t[K in keyof T]: T[K] extends BcsType<any, infer T> ? T : never;\n\t\t\t},\n\t\t\tName\n\t\t>,\n\t) {\n\t\treturn new BcsTuple<T, Name>({\n\t\t\tfields,\n\t\t\t...options,\n\t\t});\n\t},\n\n\t/**\n\t * Creates a BcsType representing a struct of a given set of fields\n\t * @param name The name of the struct\n\t * @param fields The fields of the struct. The order of the fields affects how data is serialized and deserialized\n\t *\n\t * @example\n\t * const struct = bcs.struct('MyStruct', {\n\t *  a: bcs.u8(),\n\t *  b: bcs.string(),\n\t * })\n\t * struct.serialize({ a: 1, b: 'a' }).toBytes() // Uint8Array [ 1, 1, 97 ]\n\t */\n\tstruct<T extends Record<string, BcsType<any>>, const Name extends string = string>(\n\t\tname: Name,\n\t\tfields: T,\n\t\toptions?: Omit<\n\t\t\tBcsTypeOptions<\n\t\t\t\t{\n\t\t\t\t\t[K in keyof T]: T[K] extends BcsType<infer U, any> ? U : never;\n\t\t\t\t},\n\t\t\t\t{\n\t\t\t\t\t[K in keyof T]: T[K] extends BcsType<any, infer U> ? U : never;\n\t\t\t\t}\n\t\t\t>,\n\t\t\t'name'\n\t\t>,\n\t) {\n\t\treturn new BcsStruct<T>({\n\t\t\tname,\n\t\t\tfields,\n\t\t\t...options,\n\t\t});\n\t},\n\n\t/**\n\t * Creates a BcsType representing an enum of a given set of options\n\t * @param name The name of the enum\n\t * @param values The values of the enum. The order of the values affects how data is serialized and deserialized.\n\t * null can be used to represent a variant with no data.\n\t *\n\t * @example\n\t * const enum = bcs.enum('MyEnum', {\n\t *   A: bcs.u8(),\n\t *   B: bcs.string(),\n\t *   C: null,\n\t * })\n\t * enum.serialize({ A: 1 }).toBytes() // Uint8Array [ 0, 1 ]\n\t * enum.serialize({ B: 'a' }).toBytes() // Uint8Array [ 1, 1, 97 ]\n\t * enum.serialize({ C: true }).toBytes() // Uint8Array [ 2 ]\n\t */\n\tenum<T extends Record<string, BcsType<any> | null>, const Name extends string = string>(\n\t\tname: Name,\n\t\tfields: T,\n\t\toptions?: Omit<\n\t\t\tBcsTypeOptions<\n\t\t\t\tEnumOutputShape<{\n\t\t\t\t\t[K in keyof T]: T[K] extends BcsType<infer U, any, any> ? U : true;\n\t\t\t\t}>,\n\t\t\t\tEnumInputShape<{\n\t\t\t\t\t[K in keyof T]: T[K] extends BcsType<any, infer U, any> ? U : boolean | object | null;\n\t\t\t\t}>,\n\t\t\t\tName\n\t\t\t>,\n\t\t\t'name'\n\t\t>,\n\t) {\n\t\treturn new BcsEnum<T, Name>({\n\t\t\tname,\n\t\t\tfields,\n\t\t\t...options,\n\t\t});\n\t},\n\n\t/**\n\t * Creates a BcsType representing a map of a given key and value type\n\t * @param keyType The BcsType of the key\n\t * @param valueType The BcsType of the value\n\t * @example\n\t * const map = bcs.map(bcs.u8(), bcs.string())\n\t * map.serialize(new Map([[2, 'a']])).toBytes() // Uint8Array [ 1, 2, 1, 97 ]\n\t */\n\tmap,\n\n\t/**\n\t * Creates a BcsType that wraps another BcsType which is lazily evaluated. This is useful for creating recursive types.\n\t * @param cb A callback that returns the BcsType\n\t */\n\tlazy<T extends BcsType<any>>(cb: () => T): T {\n\t\treturn lazyBcsType(cb) as T;\n\t},\n};\n"],
-  "mappings": "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",
-  "names": []
-}

package/dist/cjs/index.d.ts

@@ -1,22 +0,0 @@
-import { toBase58, fromBase58, toBase64, fromBase64, toHex, fromHex } from '@haneullabs/utils';
-import type { BcsTypeOptions } from './bcs-type.js';
-import { BcsType, BcsStruct, BcsEnum, BcsTuple, isSerializedBcs, SerializedBcs } from './bcs-type.js';
-import { bcs } from './bcs.js';
-import { BcsReader } from './reader.js';
-import type { EnumInputShape, EnumOutputShape, EnumOutputShapeWithKeys, InferBcsInput, InferBcsType } from './types.js';
-import { decodeStr, encodeStr, splitGenericParameters } from './utils.js';
-import type { BcsWriterOptions } from './writer.js';
-import { BcsWriter } from './writer.js';
-export { bcs, BcsType, BcsStruct, BcsEnum, BcsTuple, type BcsTypeOptions, SerializedBcs, isSerializedBcs, toBase58, fromBase58, toBase64, fromBase64, toHex, fromHex, encodeStr, decodeStr, splitGenericParameters, BcsReader, BcsWriter, type BcsWriterOptions, type InferBcsInput, type InferBcsType, type EnumOutputShape, type EnumInputShape, type EnumOutputShapeWithKeys, };
-/** @deprecated use toBase58 instead */
-export declare const toB58: (buffer: Uint8Array) => string;
-/** @deprecated use fromBase58 instead */
-export declare const fromB58: (str: string) => Uint8Array<ArrayBuffer>;
-/** @deprecated use toBase64 instead */
-export declare const toB64: typeof toBase64;
-/** @deprecated use fromBase64 instead */
-export declare const fromB64: typeof fromBase64;
-/** @deprecated use toHex instead */
-export declare const toHEX: typeof toHex;
-/** @deprecated use fromHex instead */
-export declare const fromHEX: typeof fromHex;