@yorozu/utils 0.1.4 → 0.3.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ivan
+
+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/arrays/index.d.ts

@@ -0,0 +1,4 @@
+import * as typed from "./typed";
+import * as u8 from "./u8";
+export * from './typed/types';
+export { typed, u8 };

package/arrays/typed/compare.d.ts

@@ -0,0 +1,3 @@
+import { TypedArray } from './types';
+export declare function compare<T extends TypedArray>(a: T, b: T): -1 | 0 | 1;
+export declare function equal<T extends TypedArray>(a: T, b: T): boolean;

package/arrays/typed/find.d.ts

@@ -0,0 +1,10 @@
+import { TypedArray } from './types';
+export declare function indexOf(haystack: Exclude<TypedArray, BigInt64Array | BigUint64Array>, needle: number, start?: number): number;
+export declare function indexOf(haystack: BigInt64Array | BigUint64Array, needle: bigint, start?: number): number;
+export declare function lastIndexOf(haystack: Exclude<TypedArray, BigInt64Array | BigUint64Array>, needle: number, start?: number): number;
+export declare function lastIndexOf(haystack: BigInt64Array | BigUint64Array, needle: bigint, start?: number): number;
+export declare function indexOfArray<T extends TypedArray>(haystack: T, needle: T, start?: number): number;
+export declare function lastIndexOfArray<T extends TypedArray>(haystack: T, needle: T, start?: number): number;
+export declare function includes(haystack: Exclude<TypedArray, BigInt64Array | BigUint64Array>, needle: number): boolean;
+export declare function includes(haystack: BigInt64Array | BigUint64Array, needle: bigint): boolean;
+export declare function includesArray<T extends TypedArray>(haystack: T, needle: T): boolean;

package/arrays/typed/index.d.ts

@@ -0,0 +1,4 @@
+export * from './compare';
+export * from './find';
+export * from './misc';
+export * from './types';

package/arrays/typed/misc.d.ts

@@ -0,0 +1,10 @@
+import { TypedArray } from './types';
+export declare function toDataView(buf: TypedArray): DataView;
+export declare function view<R extends TypedArray>(ctor: {
+    new (buffer: ArrayBufferLike, byteOffset: number, byteLength: number): R;
+    BYTES_PER_ELEMENT: number;
+}, buf: ArrayBufferView): R;
+export declare function getPlatformByteOrder(): "little" | "big";
+export declare namespace getPlatformByteOrder {
+    var _cachedByteOrder: boolean | null;
+}

package/arrays/typed/types.d.ts

@@ -0,0 +1,2 @@
+import { AnyToNever } from '../../types';
+export type TypedArray = Uint8Array | Uint16Array | Uint32Array | Int8Array | Int16Array | Int32Array | Float32Array | Float64Array | AnyToNever<BigInt64Array> | AnyToNever<BigUint64Array>;

package/arrays/u8/concat.d.ts

@@ -0,0 +1,3 @@
+export declare function concat(bufs: Array<Uint8Array>): Uint8Array;
+export declare function concat2(a: ArrayLike<number>, b: ArrayLike<number>): Uint8Array;
+export declare function concat3(a: ArrayLike<number>, b: ArrayLike<number>, c: ArrayLike<number>): Uint8Array;

package/arrays/u8/index.d.ts

@@ -0,0 +1,6 @@
+export * from './concat';
+export * from './misc';
+export * from './pool';
+export * from './reverse';
+export * from './swap';
+export * from './xor';

package/arrays/u8/misc.d.ts

@@ -0,0 +1,3 @@
+export declare const empty: Uint8Array;
+export declare function clone(buf: Uint8Array): Uint8Array;
+export declare function readNthBit(byte: number, bit: number): number;

package/arrays/u8/pool.d.ts

@@ -0,0 +1,15 @@
+export declare class BufferPool {
+    readonly size: number;
+    readonly maxAllocSize: number;
+    protected _pool: ArrayBuffer;
+    protected _offset: number;
+    constructor(size?: number);
+    protected get _remaining(): number;
+    allocate(size: number): Uint8Array;
+    reset(): void;
+    protected _reallocate(): void;
+    protected _align(): void;
+}
+export declare function setDefaultPool(size: number): void;
+export declare function allocate(size: number): Uint8Array;
+export declare function allocateWith(init: ArrayLike<number>): Uint8Array;

package/arrays/u8/reverse.d.ts

@@ -0,0 +1,2 @@
+export declare function reverse(buffer: Uint8Array): void;
+export declare function toReversed(buffer: ArrayLike<number>): Uint8Array;

package/arrays/u8/swap.d.ts

@@ -0,0 +1,4 @@
+export declare function swap16(buf: Uint8Array): void;
+export declare function swap32(buf: Uint8Array): void;
+export declare function swap64(buf: Uint8Array): void;
+export declare function swapNibbles(buf: Uint8Array): void;

package/arrays/u8/xor.d.ts

@@ -0,0 +1,2 @@
+export declare function xor(data: Uint8Array, key: Uint8Array): Uint8Array;
+export declare function xorInPlace(data: Uint8Array, key: Uint8Array): void;

package/async/async-interval.d.ts

@@ -0,0 +1,16 @@
+import * as timers from "./timers";
+export declare class AsyncInterval {
+    protected _handler: (abortSignal: AbortSignal) => Promise<void>;
+    protected _interval: number;
+    protected _timer?: timers.Timer;
+    protected _onError: (err: unknown) => void;
+    protected _stopped: boolean;
+    protected _generation: number;
+    protected _abortController: AbortController;
+    constructor(handler: (abortSignal: AbortSignal) => Promise<void>, interval: number);
+    start(after?: number): void;
+    startNow(): void;
+    stop(): void;
+    onError(handler: (err: unknown) => void): void;
+    protected _onTimeout: (generation: number) => void;
+}

package/async/async-lock.d.ts

@@ -0,0 +1,10 @@
+import { NoneToVoidFunction } from '../types';
+import { Deque } from '../structures';
+type LockInfo = [Promise<void>, NoneToVoidFunction];
+export declare class AsyncLock {
+    protected _queue: Deque<LockInfo>;
+    acquire(): Promise<void>;
+    release(): void;
+    with<T>(func: () => Promise<T>): Promise<T>;
+}
+export {};

package/async/async-queue.d.ts

@@ -0,0 +1,22 @@
+import { Deque } from '../structures';
+import { Deferred } from './deferred';
+export declare class AsyncQueue<T> {
+    readonly queue: Deque<T>;
+    readonly maxSize: number | undefined;
+    protected _consumerWaiters: Deque<Deferred<T | undefined>>;
+    protected _producerWaiters: Deque<Deferred<void>>;
+    protected _ended: boolean;
+    constructor(from?: ArrayLike<T> | Deque<T>, maxSize?: number);
+    get length(): number;
+    get isFull(): boolean;
+    get remainingCapacity(): number;
+    get ended(): boolean;
+    enqueue(item: T): Promise<void>;
+    tryEnqueue(item: T): boolean;
+    end(): void;
+    peek(): T | undefined;
+    next(): T | undefined;
+    nextOrWait(): Promise<T | undefined>;
+    [Symbol.asyncIterator](): AsyncIterableIterator<T>;
+    protected _wakeProducerIfNeeded(): void;
+}

package/async/async-resource.d.ts

@@ -0,0 +1,41 @@
+import { UnsafeMutate } from '../types';
+import { Deferred } from './deferred';
+import { Emitter } from './emitter';
+import * as timers from "./timers";
+export interface AsyncResourceContext<T> {
+    readonly current: T | null;
+    readonly currentFetchedAt: number;
+    readonly currentExpiresAt: number;
+    readonly isBackground: boolean;
+    readonly abort: AbortSignal | null;
+}
+export interface AsyncResourceOptions<T> {
+    autoReload?: boolean;
+    autoReloadAfter?: number;
+    /** @deprecated Use `autoReloadAfter`. */
+    authReloadAfter?: number;
+    swr?: boolean;
+    swrValidator?: (ctx: AsyncResourceContext<T>) => boolean;
+    fetcher: (ctx: AsyncResourceContext<T>) => Promise<{
+        data: T;
+        expiresIn: number;
+    }>;
+    onError?: (err: unknown, ctx: AsyncResourceContext<T>) => void;
+}
+export declare class AsyncResource<T> {
+    readonly options: AsyncResourceOptions<T>;
+    readonly onUpdated: Emitter<AsyncResourceContext<T>>;
+    protected _abort?: AbortController;
+    protected _ctx: UnsafeMutate<AsyncResourceContext<T>>;
+    protected _updating?: Deferred<void>;
+    protected _timeout?: timers.Timer;
+    protected _destroyed: boolean;
+    constructor(options: AsyncResourceOptions<T>);
+    get isStale(): boolean;
+    setData(data: T, expiresIn: number): void;
+    update(force?: boolean): Promise<void>;
+    get(): Promise<T | null>;
+    getCached(): T | null;
+    destroy(): void;
+    protected _clearTimer(): void;
+}

package/async/condition-variable.d.ts

@@ -0,0 +1,6 @@
+import { NoneToVoidFunction } from '../types';
+export declare class ConditionVariable {
+    protected _resolvers: Array<NoneToVoidFunction>;
+    wait(): Promise<void>;
+    notify(): void;
+}

package/async/deferred.d.ts

@@ -0,0 +1,25 @@
+export declare class Deferred<T = void> {
+    readonly resolve: (value: T) => void;
+    readonly reject: (reason: unknown) => void;
+    readonly promise: Promise<T>;
+    constructor();
+}
+export declare class DeferredTracked<T = void> {
+    readonly promise: Promise<T>;
+    readonly status: {
+        type: "pending";
+    } | {
+        type: "fulfilled";
+        value: T;
+    } | {
+        type: "rejected";
+        reason: unknown;
+    };
+    protected _resolve: (value: T) => void;
+    protected _reject: (reason: unknown) => void;
+    constructor();
+    get result(): T | undefined;
+    get error(): unknown | undefined;
+    resolve(value: T): void;
+    reject(reason: unknown): void;
+}

package/async/emitter.d.ts

@@ -0,0 +1,15 @@
+export declare class Emitter<T> {
+    protected _listeners: ((value: T) => void)[];
+    protected _emit: (value: T) => void;
+    get length(): number;
+    add(listener: (value: T) => void): void;
+    forwardTo(emitter: Emitter<T>): void;
+    remove(listener: (value: T) => void): void;
+    emit(value: T): void;
+    once(listener: (value: T) => void): void;
+    listeners(): readonly ((value: T) => void)[];
+    clear(): void;
+    protected _emitFew: (value: T) => void;
+    protected _emitAll: (value: T) => void;
+    protected _updateEmit: () => void;
+}

package/async/index.d.ts

@@ -0,0 +1,11 @@
+import * as timers from "./timers";
+export * from './async-interval';
+export * from './async-lock';
+export * from './async-queue';
+export * from './async-resource';
+export * from './condition-variable';
+export * from './deferred';
+export * from './emitter';
+export * from './pool';
+export * from './sleep';
+export { timers };

package/async/pool.d.ts

@@ -0,0 +1,19 @@
+import { MaybePromise } from '../types';
+export interface AsyncPoolOptions<T> {
+    limit?: number;
+    signal?: AbortSignal;
+    onErrorStrategy?: (item: T, index: number, error: unknown) => MaybePromise<"ignore" | "collect" | "throw">;
+}
+declare class ErrorInfo<T> {
+    readonly item: T;
+    readonly index: number;
+    readonly error: unknown;
+    constructor(item: T, index: number, error: unknown);
+}
+export declare class AggregateError<T> extends Error {
+    readonly errors: Array<ErrorInfo<T>>;
+    constructor(errors: Array<ErrorInfo<T>>);
+}
+export declare function asyncPool<T>(iterable: Iterable<T> | AsyncIterable<T>, executor: (item: T, index: number) => MaybePromise<T | void>, options?: AsyncPoolOptions<T>): Promise<void>;
+export declare function parallelMap<T, R>(iterable: Iterable<T> | AsyncIterable<T>, executor: (item: T, index: number) => MaybePromise<R>, options?: AsyncPoolOptions<T>): Promise<Array<R>>;
+export {};

package/async/sleep.d.ts

@@ -0,0 +1 @@
+export declare function sleep(ms: number, signal?: AbortSignal): Promise<void>;

package/async/timers.d.ts

@@ -0,0 +1,8 @@
+import { Brand } from '../types/brand';
+export type Timer = Brand<object, "Timer">;
+export type Interval = Brand<object, "Interval">;
+declare const setTimeoutWrap: <T extends (...args: any[]) => any>(fn: T, ms: number, ...args: Parameters<T>) => Timer;
+declare const setIntervalWrap: <T extends (...args: any[]) => any>(fn: T, ms: number, ...args: Parameters<T>) => Interval;
+declare const clearTimeoutWrap: (timer?: Timer) => void;
+declare const clearIntervalWrap: (timer?: Interval) => void;
+export { clearIntervalWrap as clearInterval, clearTimeoutWrap as clearTimeout, setIntervalWrap as setInterval, setTimeoutWrap as setTimeout, };

package/bigint/bytes.d.ts

@@ -0,0 +1,2 @@
+export declare function toBytes(value: bigint, length?: number, le?: boolean): Uint8Array;
+export declare function fromBytes(buffer: Uint8Array, le?: boolean): bigint;

package/bigint/index.d.ts

@@ -0,0 +1,2 @@
+export * from './bytes';
+export * from './math';

package/bigint/math.d.ts

@@ -0,0 +1,10 @@
+export declare function bitLength(n: bigint): number;
+export declare function twoMultiplicity(n: bigint): bigint;
+export declare function min2(a: bigint, b: bigint): bigint;
+export declare function min(...args: Array<bigint>): bigint;
+export declare function max2(a: bigint, b: bigint): bigint;
+export declare function max(...args: Array<bigint>): bigint;
+export declare function abs(a: bigint): bigint;
+export declare function euclideanGcd(a: bigint, b: bigint): bigint;
+export declare function modPowBinary(base: bigint, exp: bigint, mod: bigint): bigint;
+export declare function modInv(a: bigint, n: bigint): bigint;

package/compress/bits.d.ts

@@ -0,0 +1,5 @@
+export declare function readBits(data: Uint8Array, bitPos: number, mask: number): number;
+export declare function readBits16(data: Uint8Array, bitPos: number): number;
+export declare function writeBits(data: Uint8Array, bitPos: number, value: number): void;
+export declare function writeBits16(data: Uint8Array, bitPos: number, value: number): void;
+export declare function byteCeil(bitPos: number): number;

package/compress/checksum.d.ts

@@ -0,0 +1,15 @@
+export declare class Crc32 {
+    protected _c: number;
+    constructor(seed?: number);
+    update(data: Uint8Array): this;
+    digest(): number;
+}
+export declare function crc32(data: Uint8Array, seed?: number): number;
+export declare class Adler32 {
+    protected _a: number;
+    protected _b: number;
+    constructor(seed?: number);
+    update(data: Uint8Array): this;
+    digest(): number;
+}
+export declare function adler32(data: Uint8Array, seed?: number): number;

package/compress/compress.d.ts

@@ -0,0 +1,3 @@
+export { compress as deflate, Compressor as Deflate } from './deflate';
+export { compress as gzip, Compressor as Gzip } from './gzip';
+export { compress as zlib, Compressor as Zlib } from './zlib';

package/compress/decompress.d.ts

@@ -0,0 +1,4 @@
+export { decompress as auto } from './detect';
+export { decompress as deflate, Decompressor as Deflate } from './inflate';
+export { decompress as gzip, Decompressor as Gzip } from './gzip';
+export { decompress as zlib, Decompressor as Zlib } from './zlib';

package/compress/deflate.d.ts

@@ -0,0 +1,22 @@
+import { CompressOptions } from './types';
+export type DeflateState = {
+    head?: Uint16Array;
+    prev?: Uint16Array;
+    index?: number;
+    end?: number;
+    wait?: number;
+    remainder?: number;
+    last: number;
+};
+export declare function deflateWithOptions(data: Uint8Array, options: CompressOptions, pre: number, post: number, state?: DeflateState): Uint8Array;
+export declare function compress(data: Uint8Array, options?: CompressOptions): Uint8Array;
+export declare class Compressor {
+    protected _options: CompressOptions;
+    protected _state: DeflateState;
+    protected _buffer: Uint8Array;
+    protected _done: boolean;
+    constructor(options?: CompressOptions);
+    protected _emit(final: boolean): Uint8Array;
+    push(chunk: Uint8Array, final?: boolean): Uint8Array;
+    flush(sync?: boolean): Uint8Array;
+}

package/compress/detect.d.ts

@@ -0,0 +1,2 @@
+import { DecompressOptions } from './types';
+export declare function decompress(data: Uint8Array, options?: DecompressOptions): Uint8Array;

package/compress/errors.d.ts

@@ -0,0 +1,24 @@
+export declare class FlateError extends Error {
+    constructor(message: string, options?: ErrorOptions);
+}
+export declare class UnexpectedEofError extends FlateError {
+    constructor(options?: ErrorOptions);
+}
+export declare class InvalidBlockTypeError extends FlateError {
+    constructor(options?: ErrorOptions);
+}
+export declare class InvalidLengthLiteralError extends FlateError {
+    constructor(options?: ErrorOptions);
+}
+export declare class InvalidDistanceError extends FlateError {
+    constructor(options?: ErrorOptions);
+}
+export declare class InvalidHeaderError extends FlateError {
+    constructor(message?: string, options?: ErrorOptions);
+}
+export declare class StreamFinishedError extends FlateError {
+    constructor(options?: ErrorOptions);
+}
+export declare class ChecksumMismatchError extends FlateError {
+    constructor(options?: ErrorOptions);
+}

package/compress/gzip.d.ts

@@ -0,0 +1,31 @@
+import { Crc32 } from './checksum';
+import { Compressor as RawCompressor } from './deflate';
+import { InflateState } from './inflate';
+import { DecompressOptions, GzipCompressOptions } from './types';
+export declare function gzipHeaderLength(data: Uint8Array): number;
+export declare function compress(data: Uint8Array, options?: GzipCompressOptions): Uint8Array;
+export declare function decompress(data: Uint8Array, options?: DecompressOptions): Uint8Array;
+export declare class Compressor {
+    protected _inner: RawCompressor;
+    protected _options: GzipCompressOptions;
+    protected _crc: Crc32;
+    protected _length: number;
+    protected _header: boolean;
+    protected _done: boolean;
+    constructor(options?: GzipCompressOptions);
+    protected _wrap(raw: Uint8Array, final: boolean): Uint8Array;
+    push(chunk: Uint8Array, final?: boolean): Uint8Array;
+    flush(sync?: boolean): Uint8Array;
+}
+export declare class Decompressor {
+    protected _pending: Uint8Array;
+    protected _needHeader: boolean;
+    protected _state: InflateState;
+    protected _window: Uint8Array;
+    protected _crc: Crc32;
+    protected _length: number;
+    protected _check: boolean;
+    protected _done: boolean;
+    constructor(options?: DecompressOptions);
+    push(chunk: Uint8Array, final?: boolean): Uint8Array;
+}

package/compress/huffman.d.ts

@@ -0,0 +1,6 @@
+export declare function buildEncodeMap(lengths: Uint8Array, maxBits: number): Uint16Array;
+export declare function buildDecodeMap(lengths: Uint8Array, maxBits: number): Uint16Array;
+export declare function buildLengthLimitedTree(freqs: Uint16Array, maxBits: number): {
+    lengths: Uint8Array;
+    maxBits: number;
+};

package/compress/index.d.ts

@@ -0,0 +1,5 @@
+export { adler32, Adler32, crc32, Crc32 } from './checksum';
+export * as compress from './compress';
+export * as decompress from './decompress';
+export { ChecksumMismatchError, FlateError, InvalidBlockTypeError, InvalidDistanceError, InvalidHeaderError, InvalidLengthLiteralError, StreamFinishedError, UnexpectedEofError, } from './errors';
+export type { CompressOptions, DecompressOptions, GzipCompressOptions } from './types';

package/compress/inflate.d.ts

@@ -0,0 +1,21 @@
+import { DecompressOptions } from './types';
+export type InflateState = {
+    lengthMap?: Uint16Array;
+    distanceMap?: Uint16Array;
+    lengthBits?: number;
+    distanceBits?: number;
+    final?: number;
+    bitPos?: number;
+    outputLength?: number;
+    mode: number;
+};
+export declare function inflateRaw(data: Uint8Array, state: InflateState, buf?: Uint8Array, dictionary?: Uint8Array): Uint8Array;
+export declare function decompress(data: Uint8Array, options?: DecompressOptions): Uint8Array;
+export declare class Decompressor {
+    protected _state: InflateState;
+    protected _window: Uint8Array;
+    protected _pending: Uint8Array;
+    protected _done: boolean;
+    constructor(options?: DecompressOptions);
+    push(chunk: Uint8Array, final?: boolean): Uint8Array;
+}

package/compress/types.d.ts

@@ -0,0 +1,14 @@
+export interface CompressOptions {
+    level?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
+    mem?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12;
+    dictionary?: Uint8Array;
+}
+export interface DecompressOptions {
+    dictionary?: Uint8Array;
+    out?: Uint8Array;
+    check?: boolean;
+}
+export interface GzipCompressOptions extends CompressOptions {
+    mtime?: Date | string | number;
+    filename?: string;
+}

package/compress/zlib.d.ts

@@ -0,0 +1,30 @@
+import { Adler32 } from './checksum';
+import { Compressor as RawCompressor } from './deflate';
+import { InflateState } from './inflate';
+import { CompressOptions, DecompressOptions } from './types';
+export declare function zlibHeaderLength(data: Uint8Array, dictionary?: Uint8Array): number;
+export declare function compress(data: Uint8Array, options?: CompressOptions): Uint8Array;
+export declare function decompress(data: Uint8Array, options?: DecompressOptions): Uint8Array;
+export declare class Compressor {
+    protected _inner: RawCompressor;
+    protected _options: CompressOptions;
+    protected _sum: Adler32;
+    protected _header: boolean;
+    protected _done: boolean;
+    constructor(options?: CompressOptions);
+    protected _wrap(raw: Uint8Array, final: boolean): Uint8Array;
+    push(chunk: Uint8Array, final?: boolean): Uint8Array;
+    flush(sync?: boolean): Uint8Array;
+}
+export declare class Decompressor {
+    protected _pending: Uint8Array;
+    protected _header: boolean;
+    protected _state: InflateState;
+    protected _window: Uint8Array;
+    protected _sum: Adler32;
+    protected _dictionary?: Uint8Array;
+    protected _check: boolean;
+    protected _done: boolean;
+    constructor(options?: DecompressOptions);
+    push(chunk: Uint8Array, final?: boolean): Uint8Array;
+}

package/encoding/base64.d.ts

@@ -0,0 +1,6 @@
+export declare const lookup: Map<number, number>;
+export declare const encodeLookup: Map<number, number>;
+export declare function decode(data: string, url?: boolean): Uint8Array;
+export declare function encode(bytes: Uint8Array, url?: boolean): string;
+export declare function encodedLength(n: number): number;
+export declare function decodedLength(n: number): number;

package/encoding/hex.d.ts

@@ -0,0 +1,4 @@
+export declare function encode(buf: Uint8Array): string;
+export declare function decode(data: string): Uint8Array;
+export declare function encodedLength(n: number): number;
+export declare function decodedLength(n: number): number;

package/encoding/index.d.ts

@@ -0,0 +1,4 @@
+import * as base64 from "./base64";
+import * as hex from "./hex";
+import * as utf8 from "./utf8";
+export { base64, hex, utf8 };

package/encoding/utf8.d.ts

@@ -0,0 +1,3 @@
+export declare const encoder: TextEncoder;
+export declare const decoder: TextDecoder;
+export declare function encodedLength(data: string): number;

package/index.d.ts

@@ -0,0 +1,9 @@
+export * from './arrays';
+export * from './bigint';
+export * from './encoding';
+export * from './iterate';
+export * from './misc';
+export * from './async';
+export * from './structures';
+export * from './types';
+export * from './compress';