@yorozu/utils 0.3.0 → 0.3.1

package/arrays/u8/pool.d.ts

@@ -1,10 +1,14 @@
 export declare class BufferPool {
-    #private;
     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;

package/async/async-interval.d.ts

@@ -1,8 +1,16 @@
+import * as timers from "./timers";
 export declare class AsyncInterval {
-    #private;
+    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

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

package/async/async-queue.d.ts

@@ -1,8 +1,11 @@
 import { Deque } from '../structures';
+import { Deferred } from './deferred';
 export declare class AsyncQueue<T> {
-    #private;
     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;
@@ -15,4 +18,5 @@ export declare class AsyncQueue<T> {
     next(): T | undefined;
     nextOrWait(): Promise<T | undefined>;
     [Symbol.asyncIterator](): AsyncIterableIterator<T>;
+    protected _wakeProducerIfNeeded(): void;
 }

package/async/async-resource.d.ts

@@ -1,4 +1,7 @@
+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;
@@ -20,9 +23,13 @@ export interface AsyncResourceOptions<T> {
     onError?: (err: unknown, ctx: AsyncResourceContext<T>) => void;
 }
 export declare class AsyncResource<T> {
-    #private;
     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;
@@ -30,4 +37,5 @@ export declare class AsyncResource<T> {
     get(): Promise<T | null>;
     getCached(): T | null;
     destroy(): void;
+    protected _clearTimer(): void;
 }

package/async/condition-variable.d.ts

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

package/async/deferred.d.ts

@@ -5,7 +5,6 @@ export declare class Deferred<T = void> {
     constructor();
 }
 export declare class DeferredTracked<T = void> {
-    #private;
     readonly promise: Promise<T>;
     readonly status: {
         type: "pending";
@@ -16,6 +15,8 @@ export declare class DeferredTracked<T = void> {
         type: "rejected";
         reason: unknown;
     };
+    protected _resolve: (value: T) => void;
+    protected _reject: (reason: unknown) => void;
     constructor();
     get result(): T | undefined;
     get error(): unknown | undefined;

package/async/emitter.d.ts

@@ -1,5 +1,6 @@
 export declare class Emitter<T> {
-    #private;
+    protected _listeners: ((value: T) => void)[];
+    protected _emit: (value: T) => void;
     get length(): number;
     add(listener: (value: T) => void): void;
     forwardTo(emitter: Emitter<T>): void;
@@ -8,4 +9,7 @@ export declare class Emitter<T> {
     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/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/index.d.ts

@@ -6,3 +6,4 @@ export * from './misc';
 export * from './async';
 export * from './structures';
 export * from './types';
+export * from './compress';