@scelar/nodepod 1.0.1 → 1.0.2

package/dist/polyfills/stream.d.ts

@@ -0,0 +1,160 @@
+import { EventEmitter } from "./events";
+export interface Readable extends EventEmitter {
+    readable: boolean;
+    readableEnded: boolean;
+    readableFlowing: boolean | null;
+    destroyed: boolean;
+    closed: boolean;
+    errored: Error | null;
+    readableObjectMode: boolean;
+    readableHighWaterMark: number;
+    readableDidRead: boolean;
+    readableAborted: boolean;
+    _readableState: any;
+    _read(size: number): void;
+    _destroy(err: Error | null, cb: (err?: Error | null) => void): void;
+    readonly readableLength: number;
+    readonly readableEncoding: BufferEncoding | null;
+    _rawBind(evt: string | symbol, fn: (...args: unknown[]) => void): this;
+    on(evt: string | symbol, fn: (...args: any[]) => void): this;
+    addListener(evt: string | symbol, fn: (...args: any[]) => void): this;
+    once(evt: string | symbol, fn: (...args: any[]) => void): this;
+    push(chunk: any): boolean;
+    unshift(chunk: any): void;
+    read(amount?: number): any;
+    resume(): this;
+    pause(): this;
+    isPaused(): boolean;
+    pipe(target: any): any;
+    unpipe(target?: any): this;
+    setEncoding(enc: string): this;
+    close(cb?: (err?: Error | null) => void): void;
+    destroy(fault?: Error): this;
+    wrap(oldStream: EventEmitter): this;
+    [Symbol.asyncIterator](): AsyncIterableIterator<unknown>;
+}
+interface ReadableConstructor {
+    new (opts?: any): Readable;
+    (this: any, opts?: any): void;
+    prototype: any;
+    toWeb(readable: Readable): ReadableStream<Uint8Array>;
+    fromWeb(webStream: ReadableStream, opts?: any): Readable;
+    from(source: Iterable<unknown> | AsyncIterable<unknown>, opts?: any): Readable;
+}
+export declare const Readable: ReadableConstructor;
+export interface Writable extends EventEmitter {
+    writable: boolean;
+    writableEnded: boolean;
+    writableFinished: boolean;
+    writableNeedDrain: boolean;
+    destroyed: boolean;
+    closed: boolean;
+    errored: Error | null;
+    writableObjectMode: boolean;
+    writableHighWaterMark: number;
+    writableCorked: number;
+    _writableState: any;
+    _write(chunk: any, encoding: string, callback: (err?: Error | null) => void): void;
+    _writev?(chunks: Array<{
+        chunk: any;
+        encoding: string;
+    }>, callback: (err?: Error | null) => void): void;
+    _final(callback: (err?: Error | null) => void): void;
+    _destroy(err: Error | null, cb: (err?: Error | null) => void): void;
+    readonly writableLength: number;
+    write(chunk: any, encOrCb?: any, cb?: any): boolean;
+    end(chunkOrCb?: any, encOrCb?: any, cb?: any): this;
+    getBuffer(): Buffer;
+    getBufferAsString(enc?: BufferEncoding): string;
+    close(cb?: (err?: Error | null) => void): void;
+    destroy(fault?: Error): this;
+    cork(): void;
+    uncork(): void;
+    setDefaultEncoding(enc: string): this;
+}
+interface WritableConstructor {
+    new (opts?: any): Writable;
+    (this: any, opts?: any): void;
+    prototype: any;
+    toWeb(writable: Writable): WritableStream<Uint8Array>;
+    fromWeb(webStream: WritableStream, opts?: any): Writable;
+}
+export declare const Writable: WritableConstructor;
+export interface Duplex extends Readable {
+    writable: boolean;
+    writableEnded: boolean;
+    writableFinished: boolean;
+    writableNeedDrain: boolean;
+    writableObjectMode: boolean;
+    writableHighWaterMark: number;
+    writableCorked: number;
+    allowHalfOpen: boolean;
+    _writableState: any;
+    _write(chunk: any, encoding: string, callback: (err?: Error | null) => void): void;
+    _writev?(chunks: Array<{
+        chunk: any;
+        encoding: string;
+    }>, callback: (err?: Error | null) => void): void;
+    _final(callback: (err?: Error | null) => void): void;
+    readonly writableLength: number;
+    write(chunk: any, encOrCb?: any, cb?: any): boolean;
+    end(chunkOrCb?: any, encOrCb?: any, cb?: any): this;
+    cork(): void;
+    uncork(): void;
+    setDefaultEncoding(enc: string): this;
+}
+interface DuplexConstructor {
+    new (opts?: any): Duplex;
+    (this: any, opts?: any): void;
+    prototype: any;
+    from(source: any, opts?: any): Duplex;
+    toWeb(duplex: any): any;
+    fromWeb(source: any, opts?: any): any;
+}
+export declare const Duplex: DuplexConstructor;
+export interface PassThrough extends Duplex {
+}
+interface PassThroughConstructor {
+    new (opts?: any): PassThrough;
+    (this: any, opts?: any): void;
+    prototype: any;
+}
+export declare const PassThrough: PassThroughConstructor;
+export interface Transform extends Duplex {
+    _transform(chunk: any, encoding: string, done: (err?: Error | null, output?: any) => void): void;
+    _flush(done: (err?: Error | null, output?: any) => void): void;
+}
+interface TransformConstructor {
+    new (opts?: any): Transform;
+    (this: any, opts?: any): void;
+    prototype: any;
+}
+export declare const Transform: TransformConstructor;
+export interface Stream extends EventEmitter {
+    pipe(dest: any): any;
+}
+interface StreamConstructor {
+    new (): Stream;
+    (this: any): void;
+    prototype: any;
+}
+export declare const Stream: StreamConstructor;
+export declare function addAbortSignal(signal: AbortSignal, stream: any): any;
+export declare function pipeline(...args: unknown[]): unknown;
+export declare function finished(stream: unknown, optsOrCb?: {
+    error?: boolean;
+} | ((err?: Error) => void), cb?: (err?: Error) => void): () => void;
+export declare function getDefaultHighWaterMark(objectMode?: boolean): number;
+export declare function setDefaultHighWaterMark(objectMode: boolean, value: number): void;
+export declare const promises: {
+    pipeline: (...streams: unknown[]) => Promise<void>;
+    finished: (stream: unknown, opts?: {
+        error?: boolean;
+    }) => Promise<void>;
+};
+export declare function compose(..._streams: unknown[]): Duplex;
+export declare function isReadable(stream: unknown): boolean;
+export declare function isWritable(stream: unknown): boolean;
+export declare function isDisturbed(stream: unknown): boolean;
+export declare function isErrored(stream: unknown): boolean;
+export default Stream;

package/dist/polyfills/string_decoder.d.ts

@@ -0,0 +1,16 @@
+export interface StringDecoder {
+    encoding: string;
+    write(buf: Uint8Array | Buffer): string;
+    end(buf?: Uint8Array | Buffer): string;
+}
+export declare const StringDecoder: {
+    new (encoding?: string): StringDecoder;
+    prototype: any;
+};
+declare const _default: {
+    StringDecoder: {
+        new (encoding?: string): StringDecoder;
+        prototype: any;
+    };
+};
+export default _default;

package/dist/polyfills/tailwindcss-oxide.d.ts

@@ -0,0 +1,42 @@
+interface SourceEntry {
+    base: string;
+    pattern: string;
+    negated?: boolean;
+}
+interface ChangedContent {
+    file?: string;
+    content?: string;
+    extension: string;
+}
+export interface Scanner {
+    _sources: SourceEntry[];
+    _fileList: string[] | null;
+    _scannedCandidates: string[] | null;
+    _collectFiles(): string[];
+    scan(): string[];
+    scanFiles(changedContent: ChangedContent[]): string[];
+    getCandidatesWithPositions(changedContent: ChangedContent[]): Array<{
+        candidate: string;
+        position: number;
+    }>;
+    readonly files: string[];
+    readonly globs: Array<{
+        base: string;
+        pattern: string;
+    }>;
+    readonly normalizedSources: SourceEntry[];
+}
+interface ScannerConstructor {
+    new (opts?: {
+        sources?: SourceEntry[];
+    }): Scanner;
+    (this: any, opts?: {
+        sources?: SourceEntry[];
+    }): void;
+    prototype: any;
+}
+export declare const Scanner: ScannerConstructor;
+declare const _default: {
+    Scanner: ScannerConstructor;
+};
+export default _default;

package/dist/polyfills/test.d.ts

@@ -0,0 +1,60 @@
+export interface TestContext {
+    name: string;
+    signal: AbortSignal;
+    _controller: AbortController;
+    diagnostic(msg: string): void;
+    plan(_count: number): void;
+    todo(msg?: string): void;
+    skip(msg?: string): void;
+    abort(): void;
+}
+interface TestContextConstructor {
+    new (name: string): TestContext;
+    (this: any, name: string): void;
+    prototype: any;
+}
+export declare const TestContext: TestContextConstructor;
+type TestFn = (t: TestContext) => void | Promise<void>;
+type HookFn = () => void | Promise<void>;
+interface TestOpts {
+    name: string;
+    skip?: boolean;
+    todo?: boolean;
+    only?: boolean;
+}
+export declare function describe(name: string, fn: () => void | Promise<void>): void;
+export declare function describe(options: TestOpts, fn: () => void | Promise<void>): void;
+export declare function it(name: string, fn?: TestFn): void;
+export declare function it(options: TestOpts, fn?: TestFn): void;
+export { it as test };
+export declare function before(fn: HookFn): void;
+export declare function after(fn: HookFn): void;
+export declare function beforeEach(fn: HookFn): void;
+export declare function afterEach(fn: HookFn): void;
+export declare function skip(name?: string, _fn?: TestFn): void;
+export declare function todo(name?: string, _fn?: TestFn): void;
+export declare const mock: {
+    fn(impl?: Function): Function;
+    method(obj: Record<string, unknown>, methodName: string, impl?: Function): Function;
+    reset(): void;
+    restoreAll(): void;
+};
+declare const _default: {
+    describe: typeof describe;
+    it: typeof it;
+    test: typeof it;
+    before: typeof before;
+    after: typeof after;
+    beforeEach: typeof beforeEach;
+    afterEach: typeof afterEach;
+    skip: typeof skip;
+    todo: typeof todo;
+    mock: {
+        fn(impl?: Function): Function;
+        method(obj: Record<string, unknown>, methodName: string, impl?: Function): Function;
+        reset(): void;
+        restoreAll(): void;
+    };
+    TestContext: TestContextConstructor;
+};
+export default _default;

package/dist/polyfills/timers.d.ts

@@ -0,0 +1,23 @@
+export declare const setTimeout: typeof globalThis.setTimeout;
+export declare const setInterval: typeof globalThis.setInterval;
+export declare const setImmediate: (fn: (...args: unknown[]) => void, ...args: unknown[]) => NodeJS.Timeout;
+export declare const clearTimeout: typeof globalThis.clearTimeout;
+export declare const clearInterval: typeof globalThis.clearInterval;
+export declare const clearImmediate: typeof globalThis.clearTimeout;
+export declare const promises: {
+    setTimeout: (ms: number, value?: unknown) => Promise<unknown>;
+    setInterval: typeof globalThis.setInterval;
+    setImmediate: (value?: unknown) => Promise<unknown>;
+    scheduler: {
+        wait: (ms: number) => Promise<unknown>;
+    };
+};
+declare const _default: {
+    setTimeout: typeof globalThis.setTimeout;
+    setInterval: typeof globalThis.setInterval;
+    setImmediate: (fn: (...args: unknown[]) => void, ...args: unknown[]) => NodeJS.Timeout;
+    clearTimeout: typeof globalThis.clearTimeout;
+    clearInterval: typeof globalThis.clearInterval;
+    clearImmediate: typeof globalThis.clearTimeout;
+};
+export default _default;

package/dist/polyfills/tls.d.ts

@@ -0,0 +1,61 @@
+import { EventEmitter } from "./events";
+export interface TLSSocket extends EventEmitter {
+    authorized: boolean;
+    encrypted: boolean;
+    getPeerCertificate(_detailed?: boolean): object;
+    getCipher(): {
+        name: string;
+        version: string;
+    } | null;
+    getProtocol(): string | null;
+    setServername(_name: string): void;
+    renegotiate(_opts: unknown, _cb: (err: Error | null) => void): boolean;
+}
+export declare const TLSSocket: {
+    new (_sock?: unknown, _opts?: unknown): TLSSocket;
+    prototype: any;
+};
+export interface Server extends EventEmitter {
+    listen(..._args: unknown[]): this;
+    close(_cb?: (err?: Error) => void): this;
+    address(): {
+        port: number;
+        family: string;
+        address: string;
+    } | string | null;
+    getTicketKeys(): Uint8Array;
+    setTicketKeys(_keys: Uint8Array): void;
+    setSecureContext(_opts: unknown): void;
+}
+export declare const Server: {
+    new (_opts?: unknown, _handler?: (sock: TLSSocket) => void): Server;
+    prototype: any;
+};
+export declare function createServer(_opts?: unknown, _handler?: (sock: TLSSocket) => void): Server;
+export declare function connect(_opts: unknown, _cb?: () => void): TLSSocket;
+export declare function createSecureContext(_opts?: unknown): object;
+export type SecureContext = object;
+export declare const getCiphers: () => string[];
+export declare const DEFAULT_ECDH_CURVE = "auto";
+export declare const DEFAULT_MAX_VERSION = "TLSv1.3";
+export declare const DEFAULT_MIN_VERSION = "TLSv1.2";
+export declare const rootCertificates: string[];
+declare const _default: {
+    TLSSocket: {
+        new (_sock?: unknown, _opts?: unknown): TLSSocket;
+        prototype: any;
+    };
+    Server: {
+        new (_opts?: unknown, _handler?: (sock: TLSSocket) => void): Server;
+        prototype: any;
+    };
+    createServer: typeof createServer;
+    connect: typeof connect;
+    createSecureContext: typeof createSecureContext;
+    getCiphers: () => string[];
+    DEFAULT_ECDH_CURVE: string;
+    DEFAULT_MAX_VERSION: string;
+    DEFAULT_MIN_VERSION: string;
+    rootCertificates: string[];
+};
+export default _default;

package/dist/polyfills/trace_events.d.ts

@@ -0,0 +1,22 @@
+export interface Tracing {
+    readonly categories: string;
+    readonly enabled: boolean;
+    enable(): void;
+    disable(): void;
+}
+interface TracingConstructor {
+    new (categories: string[]): Tracing;
+    (this: any, categories: string[]): void;
+    prototype: any;
+}
+export declare const Tracing: TracingConstructor;
+export declare function createTracing(opts: {
+    categories: string[];
+}): Tracing;
+export declare function getEnabledCategories(): string | undefined;
+declare const _default: {
+    createTracing: typeof createTracing;
+    getEnabledCategories: typeof getEnabledCategories;
+    Tracing: TracingConstructor;
+};
+export default _default;

package/dist/polyfills/tty.d.ts

@@ -0,0 +1,38 @@
+export declare function isatty(_fd: number): boolean;
+export interface ReadStream {
+    isTTY: boolean;
+    isRaw: boolean;
+    setRawMode(_mode: boolean): this;
+}
+export declare const ReadStream: {
+    new (): ReadStream;
+    prototype: any;
+};
+export interface WriteStream {
+    isTTY: boolean;
+    columns: number;
+    rows: number;
+    getColorDepth(): number;
+    hasColors(count?: number): boolean;
+    getWindowSize(): [number, number];
+    clearLine(_dir: number, _cb?: () => void): boolean;
+    clearScreenDown(_cb?: () => void): boolean;
+    cursorTo(_x: number, _y?: number | (() => void), _cb?: () => void): boolean;
+    moveCursor(_dx: number, _dy: number, _cb?: () => void): boolean;
+}
+export declare const WriteStream: {
+    new (): WriteStream;
+    prototype: any;
+};
+declare const _default: {
+    isatty: typeof isatty;
+    ReadStream: {
+        new (): ReadStream;
+        prototype: any;
+    };
+    WriteStream: {
+        new (): WriteStream;
+        prototype: any;
+    };
+};
+export default _default;

package/dist/polyfills/url.d.ts

@@ -0,0 +1,55 @@
+export interface Url {
+    protocol?: string | null;
+    slashes?: boolean | null;
+    auth?: string | null;
+    host?: string | null;
+    port?: string | null;
+    hostname?: string | null;
+    hash?: string | null;
+    search?: string | null;
+    query?: string | Record<string, string | string[]> | null;
+    pathname?: string | null;
+    path?: string | null;
+    href?: string;
+}
+export declare function parse(raw: string, parseQuery?: boolean, _slashesHost?: boolean): Url;
+export declare function format(obj: Url): string;
+export declare function resolve(base: string, target: string): string;
+export declare const URL: {
+    new (url: string | URL, base?: string | URL): URL;
+    prototype: URL;
+    canParse(url: string | URL, base?: string | URL): boolean;
+    createObjectURL(obj: Blob | MediaSource): string;
+    parse(url: string | URL, base?: string | URL): URL | null;
+    revokeObjectURL(url: string): void;
+};
+export declare const URLSearchParams: {
+    new (init?: string[][] | Record<string, string> | string | URLSearchParams): URLSearchParams;
+    prototype: URLSearchParams;
+};
+export declare function fileURLToPath(input: string | URL): string;
+export declare function pathToFileURL(fsPath: string): URL;
+export declare function domainToASCII(domain: string): string;
+export declare function domainToUnicode(domain: string): string;
+declare const _default: {
+    parse: typeof parse;
+    format: typeof format;
+    resolve: typeof resolve;
+    URL: {
+        new (url: string | URL, base?: string | URL): URL;
+        prototype: URL;
+        canParse(url: string | URL, base?: string | URL): boolean;
+        createObjectURL(obj: Blob | MediaSource): string;
+        parse(url: string | URL, base?: string | URL): URL | null;
+        revokeObjectURL(url: string): void;
+    };
+    URLSearchParams: {
+        new (init?: string[][] | Record<string, string> | string | URLSearchParams): URLSearchParams;
+        prototype: URLSearchParams;
+    };
+    fileURLToPath: typeof fileURLToPath;
+    pathToFileURL: typeof pathToFileURL;
+    domainToASCII: typeof domainToASCII;
+    domainToUnicode: typeof domainToUnicode;
+};
+export default _default;

package/dist/polyfills/util.d.ts

@@ -0,0 +1,135 @@
+export declare function format(template: unknown, ...values: unknown[]): string;
+export declare function inspect(target: unknown, opts?: {
+    depth?: number;
+    colors?: boolean;
+}): string;
+export declare function inherits(child: Function, parent: Function): void;
+export declare function _extend(target: any, source: any): any;
+export declare function deprecate<T extends Function>(fn: T, message: string, code?: string): T;
+export declare function promisify<T>(fn: (...args: any[]) => void): (...args: any[]) => Promise<T>;
+export declare function callbackify<T>(fn: (...args: any[]) => Promise<T>): (...args: any[]) => void;
+export declare function isDeepStrictEqual(a: unknown, b: unknown): boolean;
+export declare function isArray(val: unknown): val is unknown[];
+export declare function isBoolean(val: unknown): val is boolean;
+export declare function isNull(val: unknown): val is null;
+export declare function isNullOrUndefined(val: unknown): val is null | undefined;
+export declare function isNumber(val: unknown): val is number;
+export declare function isString(val: unknown): val is string;
+export declare function isUndefined(val: unknown): val is undefined;
+export declare function isRegExp(val: unknown): val is RegExp;
+export declare function isObject(val: unknown): val is object;
+export declare function isDate(val: unknown): val is Date;
+export declare function isError(val: unknown): val is Error;
+export declare function isFunction(val: unknown): val is Function;
+export declare function isPrimitive(val: unknown): boolean;
+export declare function isBuffer(val: unknown): boolean;
+export declare function isPromise(val: unknown): val is Promise<unknown>;
+export declare function debuglog(section: string): (...args: unknown[]) => void;
+export declare const debug: typeof debuglog;
+export declare function stripVTControlCharacters(text: string): string;
+export declare const types: {
+    isArray: typeof isArray;
+    isBoolean: typeof isBoolean;
+    isNull: typeof isNull;
+    isNullOrUndefined: typeof isNullOrUndefined;
+    isNumber: typeof isNumber;
+    isString: typeof isString;
+    isUndefined: typeof isUndefined;
+    isRegExp: typeof isRegExp;
+    isObject: typeof isObject;
+    isDate: typeof isDate;
+    isError: typeof isError;
+    isFunction: typeof isFunction;
+    isPrimitive: typeof isPrimitive;
+    isBuffer: typeof isBuffer;
+    isPromise: typeof isPromise;
+};
+export declare function styleText(format: string | string[], text: string): string;
+interface ParseArgsOptionConfig {
+    type: "string" | "boolean";
+    short?: string;
+    multiple?: boolean;
+    default?: string | boolean | string[] | boolean[];
+}
+interface ParseArgsConfig {
+    args?: string[];
+    options?: Record<string, ParseArgsOptionConfig>;
+    strict?: boolean;
+    allowPositionals?: boolean;
+    tokens?: boolean;
+}
+interface ParseArgsResult {
+    values: Record<string, string | boolean | (string | boolean)[] | undefined>;
+    positionals: string[];
+    tokens?: Array<{
+        kind: string;
+        name?: string;
+        value?: string | boolean;
+        index: number;
+    }>;
+}
+export declare function parseArgs(config?: ParseArgsConfig): ParseArgsResult;
+export declare const TextEncoder: {
+    new (): TextEncoder;
+    prototype: TextEncoder;
+};
+export declare const TextDecoder: {
+    new (label?: string, options?: TextDecoderOptions): TextDecoder;
+    prototype: TextDecoder;
+};
+declare const _default: {
+    format: typeof format;
+    inspect: typeof inspect;
+    inherits: typeof inherits;
+    _extend: typeof _extend;
+    deprecate: typeof deprecate;
+    promisify: typeof promisify;
+    callbackify: typeof callbackify;
+    isDeepStrictEqual: typeof isDeepStrictEqual;
+    debuglog: typeof debuglog;
+    debug: typeof debuglog;
+    stripVTControlCharacters: typeof stripVTControlCharacters;
+    isArray: typeof isArray;
+    isBoolean: typeof isBoolean;
+    isNull: typeof isNull;
+    isNullOrUndefined: typeof isNullOrUndefined;
+    isNumber: typeof isNumber;
+    isString: typeof isString;
+    isUndefined: typeof isUndefined;
+    isRegExp: typeof isRegExp;
+    isObject: typeof isObject;
+    isDate: typeof isDate;
+    isError: typeof isError;
+    isFunction: typeof isFunction;
+    isPrimitive: typeof isPrimitive;
+    isBuffer: typeof isBuffer;
+    isPromise: typeof isPromise;
+    styleText: typeof styleText;
+    parseArgs: typeof parseArgs;
+    types: {
+        isArray: typeof isArray;
+        isBoolean: typeof isBoolean;
+        isNull: typeof isNull;
+        isNullOrUndefined: typeof isNullOrUndefined;
+        isNumber: typeof isNumber;
+        isString: typeof isString;
+        isUndefined: typeof isUndefined;
+        isRegExp: typeof isRegExp;
+        isObject: typeof isObject;
+        isDate: typeof isDate;
+        isError: typeof isError;
+        isFunction: typeof isFunction;
+        isPrimitive: typeof isPrimitive;
+        isBuffer: typeof isBuffer;
+        isPromise: typeof isPromise;
+    };
+    TextEncoder: {
+        new (): TextEncoder;
+        prototype: TextEncoder;
+    };
+    TextDecoder: {
+        new (label?: string, options?: TextDecoderOptions): TextDecoder;
+        prototype: TextDecoder;
+    };
+};
+export default _default;