@scelar/nodepod 1.0.1 → 1.0.2

package/dist/polyfills/v8.d.ts

@@ -0,0 +1,97 @@
+export declare function getHeapStatistics(): {
+    total_heap_size: number;
+    total_heap_size_executable: number;
+    total_physical_size: number;
+    total_available_size: number;
+    used_heap_size: number;
+    heap_size_limit: number;
+    malloced_memory: number;
+    peak_malloced_memory: number;
+    does_zap_garbage: number;
+    number_of_native_contexts: number;
+    number_of_detached_contexts: number;
+};
+export declare function getHeapSpaceStatistics(): unknown[];
+export declare function getHeapCodeStatistics(): {
+    code_and_metadata_size: number;
+    bytecode_and_metadata_size: number;
+    external_script_source_size: number;
+};
+export declare function getHeapSnapshot(): null;
+export declare function writeHeapSnapshot(): string;
+export declare function setFlagsFromString(_flags: string): void;
+export declare function takeCoverage(): void;
+export declare function stopCoverage(): void;
+export declare function cachedDataVersionTag(): number;
+export declare function serialize(value: unknown): Uint8Array;
+export declare function deserialize(bytes: Uint8Array): unknown;
+export interface Serializer {
+    writeHeader(): void;
+    writeValue(_v: unknown): void;
+    releaseBuffer(): Uint8Array;
+}
+export declare const Serializer: {
+    new (): Serializer;
+    prototype: any;
+};
+export interface Deserializer {
+    readHeader(): boolean;
+    readValue(): unknown;
+}
+export declare const Deserializer: {
+    new (_buf: Uint8Array): Deserializer;
+    prototype: any;
+};
+export interface DefaultSerializer extends Serializer {
+}
+export declare const DefaultSerializer: {
+    new (): DefaultSerializer;
+    prototype: any;
+};
+export interface DefaultDeserializer extends Deserializer {
+}
+export declare const DefaultDeserializer: {
+    new (_buf: Uint8Array): DefaultDeserializer;
+    prototype: any;
+};
+export declare function promiseHooks(): {
+    onInit: () => void;
+    onSettled: () => void;
+    onBefore: () => void;
+    onAfter: () => void;
+    createHook: () => {
+        enable: () => void;
+        disable: () => void;
+    };
+};
+declare const _default: {
+    getHeapStatistics: typeof getHeapStatistics;
+    getHeapSpaceStatistics: typeof getHeapSpaceStatistics;
+    getHeapCodeStatistics: typeof getHeapCodeStatistics;
+    getHeapSnapshot: typeof getHeapSnapshot;
+    writeHeapSnapshot: typeof writeHeapSnapshot;
+    setFlagsFromString: typeof setFlagsFromString;
+    takeCoverage: typeof takeCoverage;
+    stopCoverage: typeof stopCoverage;
+    cachedDataVersionTag: typeof cachedDataVersionTag;
+    serialize: typeof serialize;
+    deserialize: typeof deserialize;
+    Serializer: {
+        new (): Serializer;
+        prototype: any;
+    };
+    Deserializer: {
+        new (_buf: Uint8Array): Deserializer;
+        prototype: any;
+    };
+    DefaultSerializer: {
+        new (): DefaultSerializer;
+        prototype: any;
+    };
+    DefaultDeserializer: {
+        new (_buf: Uint8Array): DefaultDeserializer;
+        prototype: any;
+    };
+    promiseHooks: typeof promiseHooks;
+};
+export default _default;

package/dist/polyfills/vm.d.ts

@@ -0,0 +1,66 @@
+export interface Script {
+    runInThisContext(_opts?: object): unknown;
+    runInNewContext(ctx?: object, _opts?: object): unknown;
+    runInContext(ctx: object, _opts?: object): unknown;
+    createCachedData(): Uint8Array;
+}
+export declare const Script: {
+    new (src: string, _opts?: object): Script;
+    prototype: any;
+};
+export declare function createContext(sandbox?: object, _opts?: object): object;
+export declare function isContext(_box: object): boolean;
+export declare function runInThisContext(code: string, _opts?: object): unknown;
+export declare function runInNewContext(code: string, ctx?: object, _opts?: object): unknown;
+export declare function runInContext(code: string, ctx: object, _opts?: object): unknown;
+export declare function compileFunction(body: string, params?: string[], _opts?: object): Function;
+export interface Module {
+    link(_linker: unknown): Promise<void>;
+    evaluate(_opts?: object): Promise<unknown>;
+    readonly status: string;
+    readonly identifier: string;
+    readonly context: object;
+    readonly namespace: object;
+}
+export declare const Module: {
+    new (_code: string, _opts?: object): Module;
+    prototype: any;
+};
+export interface SourceTextModule extends Module {
+}
+export declare const SourceTextModule: {
+    new (_code: string, _opts?: object): SourceTextModule;
+    prototype: any;
+};
+export interface SyntheticModule extends Module {
+    setExport(_name: string, _value: unknown): void;
+}
+export declare const SyntheticModule: {
+    new (_code: string, _opts?: object): SyntheticModule;
+    prototype: any;
+};
+declare const _default: {
+    Script: {
+        new (src: string, _opts?: object): Script;
+        prototype: any;
+    };
+    createContext: typeof createContext;
+    isContext: typeof isContext;
+    runInThisContext: typeof runInThisContext;
+    runInNewContext: typeof runInNewContext;
+    runInContext: typeof runInContext;
+    compileFunction: typeof compileFunction;
+    Module: {
+        new (_code: string, _opts?: object): Module;
+        prototype: any;
+    };
+    SourceTextModule: {
+        new (_code: string, _opts?: object): SourceTextModule;
+        prototype: any;
+    };
+    SyntheticModule: {
+        new (_code: string, _opts?: object): SyntheticModule;
+        prototype: any;
+    };
+};
+export default _default;

package/dist/polyfills/volume-registry.d.ts

@@ -0,0 +1,3 @@
+import type { MemoryVolume } from "../memory-volume";
+export declare function setSharedVolume(vol: MemoryVolume): void;
+export declare function getSharedVolume(): MemoryVolume | null;

package/dist/polyfills/wasi.d.ts

@@ -0,0 +1,16 @@
+export interface WASI {
+    readonly wasiImport: Record<string, Function>;
+    start(_instance: object): number;
+    initialize(_instance: object): void;
+    getImportObject(): Record<string, Record<string, Function>>;
+}
+interface WASIConstructor {
+    new (_options?: object): WASI;
+    (this: any, _options?: object): void;
+    prototype: any;
+}
+export declare const WASI: WASIConstructor;
+declare const _default: {
+    WASI: WASIConstructor;
+};
+export default _default;

package/dist/polyfills/worker_threads.d.ts

@@ -0,0 +1,111 @@
+import { EventEmitter } from "./events";
+export declare let isMainThread: boolean;
+export declare let parentPort: MessagePort | null;
+export declare let workerData: unknown;
+export declare let threadId: number;
+export type WorkerThreadForkFn = (modulePath: string, opts: {
+    workerData: unknown;
+    threadId: number;
+    isEval?: boolean;
+    cwd: string;
+    env: Record<string, string>;
+    onMessage: (data: unknown) => void;
+    onError: (err: Error) => void;
+    onExit: (code: number) => void;
+    onStdout?: (data: string) => void;
+    onStderr?: (data: string) => void;
+}) => {
+    postMessage: (data: unknown) => void;
+    terminate: () => void;
+    requestId: number;
+};
+export declare function setWorkerThreadForkCallback(fn: WorkerThreadForkFn): void;
+export interface MessagePort extends EventEmitter {
+    postMessage(_val: unknown, _transfer?: unknown[]): void;
+    start(): void;
+    close(): void;
+    ref(): void;
+    unref(): void;
+}
+interface MessagePortConstructor {
+    new (): MessagePort;
+    (this: any): void;
+    prototype: any;
+}
+export declare const MessagePort: MessagePortConstructor;
+export interface MessageChannel {
+    port1: MessagePort;
+    port2: MessagePort;
+}
+interface MessageChannelConstructor {
+    new (): MessageChannel;
+    (this: any): void;
+    prototype: any;
+}
+export declare const MessageChannel: MessageChannelConstructor;
+export interface Worker extends EventEmitter {
+    threadId: number;
+    resourceLimits: object;
+    _handle: ReturnType<WorkerThreadForkFn> | null;
+    _terminated: boolean;
+    _isReffed: boolean;
+    postMessage(value: unknown, _transferListOrOptions?: unknown): void;
+    terminate(): Promise<number>;
+    ref(): this;
+    unref(): this;
+    getHeapSnapshot(): Promise<unknown>;
+}
+interface WorkerConstructor {
+    new (script: string | URL, opts?: {
+        workerData?: unknown;
+        eval?: boolean;
+        env?: Record<string, string> | symbol;
+        argv?: string[];
+        execArgv?: string[];
+        resourceLimits?: Record<string, number>;
+        name?: string;
+        transferList?: unknown[];
+    }): Worker;
+    (this: any, script: string | URL, opts?: any): void;
+    prototype: any;
+}
+export declare const Worker: WorkerConstructor;
+export interface BroadcastChannel extends EventEmitter {
+    name: string;
+    postMessage(_msg: unknown): void;
+    close(): void;
+    ref(): void;
+    unref(): void;
+}
+interface BroadcastChannelConstructor {
+    new (label: string): BroadcastChannel;
+    (this: any, label: string): void;
+    prototype: any;
+}
+export declare const BroadcastChannel: BroadcastChannelConstructor;
+export declare function moveMessagePortToContext(port: MessagePort, _ctx: unknown): MessagePort;
+export declare function receiveMessageOnPort(_port: MessagePort): {
+    message: unknown;
+} | undefined;
+export declare const SHARE_ENV: unique symbol;
+export declare function markAsUntransferable(_obj: unknown): void;
+export declare function getEnvironmentData(_key: unknown): unknown;
+export declare function setEnvironmentData(_key: unknown, _val: unknown): void;
+declare const _default: {
+    isMainThread: boolean;
+    parentPort: null;
+    workerData: unknown;
+    threadId: number;
+    Worker: WorkerConstructor;
+    MessageChannel: MessageChannelConstructor;
+    MessagePort: MessagePortConstructor;
+    BroadcastChannel: BroadcastChannelConstructor;
+    moveMessagePortToContext: typeof moveMessagePortToContext;
+    receiveMessageOnPort: typeof receiveMessageOnPort;
+    SHARE_ENV: symbol;
+    markAsUntransferable: typeof markAsUntransferable;
+    getEnvironmentData: typeof getEnvironmentData;
+    setEnvironmentData: typeof setEnvironmentData;
+    setWorkerThreadForkCallback: typeof setWorkerThreadForkCallback;
+};
+export default _default;

package/dist/polyfills/ws.d.ts

@@ -0,0 +1,92 @@
+import type { TcpSocket } from "./net";
+type Handler = (...args: unknown[]) => void;
+interface TinyEmitter {
+    _listeners: Map<string, Set<Handler>>;
+    on(evt: string, fn: Handler): this;
+    off(evt: string, fn: Handler): this;
+    emit(evt: string, ...args: unknown[]): void;
+}
+interface TinyEmitterConstructor {
+    new (): TinyEmitter;
+    (this: any): void;
+    prototype: any;
+}
+declare const TinyEmitter: TinyEmitterConstructor;
+export declare const CONNECTING = 0;
+export declare const OPEN = 1;
+export declare const CLOSING = 2;
+export declare const CLOSED = 3;
+export interface WebSocket extends TinyEmitter {
+    readonly CONNECTING: number;
+    readonly OPEN: number;
+    readonly CLOSING: number;
+    readonly CLOSED: number;
+    readyState: number;
+    url: string;
+    protocol: string;
+    extensions: string;
+    bufferedAmount: number;
+    binaryType: 'blob' | 'arraybuffer';
+    _uid: string;
+    _boundServer: WebSocketServer | null;
+    _native: globalThis.WebSocket | null;
+    _tcpSocket: TcpSocket | null;
+    _tcpInboundBuf: Uint8Array;
+    onopen: ((ev: Event) => void) | null;
+    onclose: ((ev: CloseEvent) => void) | null;
+    onerror: ((ev: Event) => void) | null;
+    onmessage: ((ev: MessageEvent) => void) | null;
+    _open(): void;
+    _openNative(): void;
+    send(payload: string | ArrayBuffer | Uint8Array): void;
+    close(code?: number, reason?: string): void;
+    ping(): void;
+    pong(): void;
+    terminate(): void;
+    _bindServer(srv: WebSocketServer): void;
+    _deliverMessage(data: unknown): void;
+}
+interface WebSocketConstructor {
+    new (address: string, protocols?: string | string[]): WebSocket;
+    (this: any, address: string, protocols?: string | string[]): void;
+    prototype: any;
+    readonly CONNECTING: number;
+    readonly OPEN: number;
+    readonly CLOSING: number;
+    readonly CLOSED: number;
+}
+export declare const WebSocket: WebSocketConstructor;
+export interface ServerConfig {
+    host?: string;
+    port?: number;
+    server?: unknown;
+    noServer?: boolean;
+    path?: string;
+    clientTracking?: boolean;
+    perMessageDeflate?: boolean | object;
+    maxPayload?: number;
+}
+export interface WebSocketServer extends TinyEmitter {
+    clients: Set<WebSocket>;
+    options: ServerConfig;
+    _route: string;
+    _channelCb: ((ev: MessageEvent) => void) | null;
+    _listen(): void;
+    _injectClientPayload(source: WebSocket, data: unknown): void;
+    handleUpgrade(req: unknown, socket: unknown, head: unknown, done: (ws: WebSocket, req: unknown) => void): void;
+    close(done?: () => void): void;
+    address(): {
+        port: number;
+        family: string;
+        address: string;
+    } | null;
+}
+interface WebSocketServerConstructor {
+    new (opts?: ServerConfig): WebSocketServer;
+    (this: any, opts?: ServerConfig): void;
+    prototype: any;
+}
+export declare const WebSocketServer: WebSocketServerConstructor;
+export declare const Server: WebSocketServerConstructor;
+export declare const createWebSocketStream: () => never;
+export default WebSocket;

package/dist/polyfills/zlib.d.ts

@@ -0,0 +1,278 @@
+import { Transform } from "./stream";
+import pako from "pako";
+type CompressCallback = (err: Error | null, result: Buffer) => void;
+export declare function gzip(input: Buffer | string, cb: CompressCallback): void;
+export declare function gunzip(input: Buffer, cb: CompressCallback): void;
+export declare function deflate(input: Buffer | string, cb: CompressCallback): void;
+export declare function inflate(input: Buffer, cb: CompressCallback): void;
+export declare function deflateRaw(input: Buffer | string, cb: CompressCallback): void;
+export declare function inflateRaw(input: Buffer, cb: CompressCallback): void;
+export declare function brotliCompress(input: Buffer | string, optsOrCb: unknown, cb?: CompressCallback): void;
+export declare function brotliDecompress(input: Buffer, optsOrCb: unknown, cb?: CompressCallback): void;
+export declare function gzipSync(input: Buffer | string): Buffer;
+export declare function gunzipSync(input: Buffer): Buffer;
+export declare function deflateSync(input: Buffer | string): Buffer;
+export declare function inflateSync(input: Buffer): Buffer;
+export declare function deflateRawSync(input: Buffer | string): Buffer;
+export declare function inflateRawSync(input: Buffer): Buffer;
+export declare function brotliCompressSync(input: Buffer | string, _opts?: unknown): Buffer;
+export declare function brotliDecompressSync(input: Buffer, _opts?: unknown): Buffer;
+export interface ZlibTransform extends Transform {
+    _opts: any;
+    bytesWritten: number;
+    _handle: {
+        close: () => void;
+    };
+    close(cb?: () => void): void;
+    flush(cb?: (err: Error | null) => void): void;
+    reset(): void;
+    params(_level: number, _strategy: number, cb?: (err: Error | null) => void): void;
+    _processChunk(chunk: Buffer | Uint8Array, flushFlag: number): Buffer | null;
+}
+export interface Gzip extends ZlibTransform {
+    _engine: pako.Deflate;
+}
+interface GzipConstructor {
+    new (opts?: any): Gzip;
+    (this: any, opts?: any): void;
+    prototype: any;
+}
+export declare const Gzip: GzipConstructor;
+export interface Gunzip extends ZlibTransform {
+    _engine: pako.Inflate;
+}
+interface GunzipConstructor {
+    new (opts?: any): Gunzip;
+    (this: any, opts?: any): void;
+    prototype: any;
+}
+export declare const Gunzip: GunzipConstructor;
+export interface Deflate extends ZlibTransform {
+    _engine: pako.Deflate;
+}
+interface DeflateConstructor {
+    new (opts?: any): Deflate;
+    (this: any, opts?: any): void;
+    prototype: any;
+}
+export declare const Deflate: DeflateConstructor;
+export interface Inflate extends ZlibTransform {
+    _engine: pako.Inflate;
+}
+interface InflateConstructor {
+    new (opts?: any): Inflate;
+    (this: any, opts?: any): void;
+    prototype: any;
+}
+export declare const Inflate: InflateConstructor;
+export interface DeflateRaw extends ZlibTransform {
+    _engine: pako.Deflate;
+}
+interface DeflateRawConstructor {
+    new (opts?: any): DeflateRaw;
+    (this: any, opts?: any): void;
+    prototype: any;
+}
+export declare const DeflateRaw: DeflateRawConstructor;
+export interface InflateRaw extends ZlibTransform {
+    _engine: pako.Inflate;
+}
+interface InflateRawConstructor {
+    new (opts?: any): InflateRaw;
+    (this: any, opts?: any): void;
+    prototype: any;
+}
+export declare const InflateRaw: InflateRawConstructor;
+export interface Unzip extends ZlibTransform {
+    _engine: pako.Inflate | null;
+}
+interface UnzipConstructor {
+    new (opts?: any): Unzip;
+    (this: any, opts?: any): void;
+    prototype: any;
+}
+export declare const Unzip: UnzipConstructor;
+export interface BrotliCompressStream extends ZlibTransform {
+}
+interface BrotliCompressStreamConstructor {
+    new (opts?: any): BrotliCompressStream;
+    (this: any, opts?: any): void;
+    prototype: any;
+}
+export declare const BrotliCompressStream: BrotliCompressStreamConstructor;
+export interface BrotliDecompressStream extends ZlibTransform {
+}
+interface BrotliDecompressStreamConstructor {
+    new (opts?: any): BrotliDecompressStream;
+    (this: any, opts?: any): void;
+    prototype: any;
+}
+export declare const BrotliDecompressStream: BrotliDecompressStreamConstructor;
+export declare const BrotliCompress: BrotliCompressStreamConstructor;
+export declare const BrotliDecompress: BrotliDecompressStreamConstructor;
+export declare function createGzip(opts?: any): Gzip;
+export declare function createGunzip(opts?: any): Gunzip;
+export declare function createDeflate(opts?: any): Deflate;
+export declare function createInflate(opts?: any): Inflate;
+export declare function createDeflateRaw(opts?: any): DeflateRaw;
+export declare function createInflateRaw(opts?: any): InflateRaw;
+export declare function createUnzip(opts?: any): Unzip;
+export declare function createBrotliCompress(opts?: any): BrotliCompressStream;
+export declare function createBrotliDecompress(opts?: any): BrotliDecompressStream;
+export declare const constants: {
+    Z_NO_FLUSH: number;
+    Z_PARTIAL_FLUSH: number;
+    Z_SYNC_FLUSH: number;
+    Z_FULL_FLUSH: number;
+    Z_FINISH: number;
+    Z_BLOCK: number;
+    Z_OK: number;
+    Z_STREAM_END: number;
+    Z_NEED_DICT: number;
+    Z_ERRNO: number;
+    Z_STREAM_ERROR: number;
+    Z_DATA_ERROR: number;
+    Z_MEM_ERROR: number;
+    Z_BUF_ERROR: number;
+    Z_VERSION_ERROR: number;
+    Z_NO_COMPRESSION: number;
+    Z_BEST_SPEED: number;
+    Z_BEST_COMPRESSION: number;
+    Z_DEFAULT_COMPRESSION: number;
+    Z_FILTERED: number;
+    Z_HUFFMAN_ONLY: number;
+    Z_RLE: number;
+    Z_FIXED: number;
+    Z_DEFAULT_STRATEGY: number;
+    ZLIB_VERNUM: number;
+    Z_MIN_WINDOWBITS: number;
+    Z_MAX_WINDOWBITS: number;
+    Z_DEFAULT_WINDOWBITS: number;
+    Z_MIN_CHUNK: number;
+    Z_MAX_CHUNK: number;
+    Z_DEFAULT_CHUNK: number;
+    Z_MIN_MEMLEVEL: number;
+    Z_MAX_MEMLEVEL: number;
+    Z_DEFAULT_MEMLEVEL: number;
+    Z_MIN_LEVEL: number;
+    Z_MAX_LEVEL: number;
+    Z_DEFAULT_LEVEL: number;
+    BROTLI_DECODE: number;
+    BROTLI_ENCODE: number;
+    BROTLI_OPERATION_PROCESS: number;
+    BROTLI_OPERATION_FLUSH: number;
+    BROTLI_OPERATION_FINISH: number;
+    BROTLI_OPERATION_EMIT_METADATA: number;
+    BROTLI_PARAM_MODE: number;
+    BROTLI_MODE_GENERIC: number;
+    BROTLI_MODE_TEXT: number;
+    BROTLI_MODE_FONT: number;
+    BROTLI_PARAM_QUALITY: number;
+    BROTLI_MIN_QUALITY: number;
+    BROTLI_MAX_QUALITY: number;
+    BROTLI_DEFAULT_QUALITY: number;
+    BROTLI_PARAM_LGWIN: number;
+    BROTLI_MIN_WINDOW_BITS: number;
+    BROTLI_MAX_WINDOW_BITS: number;
+    BROTLI_DEFAULT_WINDOW: number;
+    BROTLI_PARAM_LGBLOCK: number;
+    BROTLI_MIN_INPUT_BLOCK_BITS: number;
+    BROTLI_MAX_INPUT_BLOCK_BITS: number;
+};
+declare const _default: {
+    gzip: typeof gzip;
+    gunzip: typeof gunzip;
+    deflate: typeof deflate;
+    inflate: typeof inflate;
+    deflateRaw: typeof deflateRaw;
+    inflateRaw: typeof inflateRaw;
+    brotliCompress: typeof brotliCompress;
+    brotliDecompress: typeof brotliDecompress;
+    gzipSync: typeof gzipSync;
+    gunzipSync: typeof gunzipSync;
+    deflateSync: typeof deflateSync;
+    inflateSync: typeof inflateSync;
+    deflateRawSync: typeof deflateRawSync;
+    inflateRawSync: typeof inflateRawSync;
+    brotliCompressSync: typeof brotliCompressSync;
+    brotliDecompressSync: typeof brotliDecompressSync;
+    Gzip: GzipConstructor;
+    Gunzip: GunzipConstructor;
+    Deflate: DeflateConstructor;
+    Inflate: InflateConstructor;
+    DeflateRaw: DeflateRawConstructor;
+    InflateRaw: InflateRawConstructor;
+    Unzip: UnzipConstructor;
+    BrotliCompress: BrotliCompressStreamConstructor;
+    BrotliDecompress: BrotliDecompressStreamConstructor;
+    createGzip: typeof createGzip;
+    createGunzip: typeof createGunzip;
+    createDeflate: typeof createDeflate;
+    createInflate: typeof createInflate;
+    createDeflateRaw: typeof createDeflateRaw;
+    createInflateRaw: typeof createInflateRaw;
+    createUnzip: typeof createUnzip;
+    createBrotliCompress: typeof createBrotliCompress;
+    createBrotliDecompress: typeof createBrotliDecompress;
+    constants: {
+        Z_NO_FLUSH: number;
+        Z_PARTIAL_FLUSH: number;
+        Z_SYNC_FLUSH: number;
+        Z_FULL_FLUSH: number;
+        Z_FINISH: number;
+        Z_BLOCK: number;
+        Z_OK: number;
+        Z_STREAM_END: number;
+        Z_NEED_DICT: number;
+        Z_ERRNO: number;
+        Z_STREAM_ERROR: number;
+        Z_DATA_ERROR: number;
+        Z_MEM_ERROR: number;
+        Z_BUF_ERROR: number;
+        Z_VERSION_ERROR: number;
+        Z_NO_COMPRESSION: number;
+        Z_BEST_SPEED: number;
+        Z_BEST_COMPRESSION: number;
+        Z_DEFAULT_COMPRESSION: number;
+        Z_FILTERED: number;
+        Z_HUFFMAN_ONLY: number;
+        Z_RLE: number;
+        Z_FIXED: number;
+        Z_DEFAULT_STRATEGY: number;
+        ZLIB_VERNUM: number;
+        Z_MIN_WINDOWBITS: number;
+        Z_MAX_WINDOWBITS: number;
+        Z_DEFAULT_WINDOWBITS: number;
+        Z_MIN_CHUNK: number;
+        Z_MAX_CHUNK: number;
+        Z_DEFAULT_CHUNK: number;
+        Z_MIN_MEMLEVEL: number;
+        Z_MAX_MEMLEVEL: number;
+        Z_DEFAULT_MEMLEVEL: number;
+        Z_MIN_LEVEL: number;
+        Z_MAX_LEVEL: number;
+        Z_DEFAULT_LEVEL: number;
+        BROTLI_DECODE: number;
+        BROTLI_ENCODE: number;
+        BROTLI_OPERATION_PROCESS: number;
+        BROTLI_OPERATION_FLUSH: number;
+        BROTLI_OPERATION_FINISH: number;
+        BROTLI_OPERATION_EMIT_METADATA: number;
+        BROTLI_PARAM_MODE: number;
+        BROTLI_MODE_GENERIC: number;
+        BROTLI_MODE_TEXT: number;
+        BROTLI_MODE_FONT: number;
+        BROTLI_PARAM_QUALITY: number;
+        BROTLI_MIN_QUALITY: number;
+        BROTLI_MAX_QUALITY: number;
+        BROTLI_DEFAULT_QUALITY: number;
+        BROTLI_PARAM_LGWIN: number;
+        BROTLI_MIN_WINDOW_BITS: number;
+        BROTLI_MAX_WINDOW_BITS: number;
+        BROTLI_DEFAULT_WINDOW: number;
+        BROTLI_PARAM_LGBLOCK: number;
+        BROTLI_MIN_INPUT_BLOCK_BITS: number;
+        BROTLI_MAX_INPUT_BLOCK_BITS: number;
+    };
+};
+export default _default;