@nimbus-sh/core 0.1.0

package/dist/substrate/lifo/node-compat/path.js

@@ -0,0 +1,49 @@
+import { normalize, isAbsolute, join, resolve, dirname, basename, extname, } from '../utils/path.js';
+export function relative(from, to) {
+    const fromParts = normalize(from).split('/').filter(Boolean);
+    const toParts = normalize(to).split('/').filter(Boolean);
+    let common = 0;
+    while (common < fromParts.length &&
+        common < toParts.length &&
+        fromParts[common] === toParts[common]) {
+        common++;
+    }
+    const ups = fromParts.length - common;
+    const rest = toParts.slice(common);
+    const parts = [...Array(ups).fill('..'), ...rest];
+    return parts.join('/') || '.';
+}
+export function parse(path) {
+    const root = isAbsolute(path) ? '/' : '';
+    const dir = dirname(path);
+    const base = basename(path);
+    const ext = extname(path);
+    const name = ext ? base.slice(0, -ext.length) : base;
+    return { root, dir, base, ext, name };
+}
+export function format(pathObj) {
+    const dir = pathObj.dir || pathObj.root || '';
+    const base = pathObj.base || ((pathObj.name || '') + (pathObj.ext || ''));
+    if (dir) {
+        return dir.endsWith('/') ? dir + base : dir + '/' + base;
+    }
+    return base;
+}
+export const sep = '/';
+export const delimiter = ':';
+export const posix = {
+    normalize, isAbsolute, join, resolve: (...args) => resolve('/', ...args),
+    dirname, basename, extname, relative, parse, format, sep, delimiter,
+};
+// Minimal win32 path — Lifo is posix-only but packages like vite reference win32.sep
+export const win32 = {
+    normalize, isAbsolute, join, resolve: (...args) => resolve('/', ...args),
+    dirname, basename, extname, relative, parse, format,
+    sep: '\\',
+    delimiter: ';',
+};
+export { normalize, isAbsolute, join, resolve, dirname, basename, extname };
+export default {
+    normalize, isAbsolute, join, resolve: (...args) => resolve('/', ...args),
+    dirname, basename, extname, relative, parse, format, sep, delimiter, posix, win32,
+};

package/dist/substrate/lifo/node-compat/process.d.ts

@@ -0,0 +1,127 @@
+import type { CommandOutputStream } from '../commands/types.js';
+export declare class ProcessExitError extends Error {
+    exitCode: number;
+    constructor(code: number);
+}
+export interface ProcessOptions {
+    argv: string[];
+    env: Record<string, string>;
+    cwd: string;
+    stdout: CommandOutputStream;
+    stderr: CommandOutputStream;
+}
+export declare function createProcess(opts: ProcessOptions): {
+    argv: string[];
+    argv0: string;
+    env: {
+        [x: string]: string;
+    };
+    cwd: () => string;
+    chdir: (_dir: string) => never;
+    exit: (code?: number) => never;
+    stdout: {
+        write: (data: string) => boolean;
+        isTTY: boolean;
+        fd: number;
+        bytesWritten: number;
+        columns: number;
+        on: () => void;
+        once: () => void;
+    };
+    stderr: {
+        write: (data: string) => boolean;
+        isTTY: boolean;
+        fd: number;
+        bytesWritten: number;
+        columns: number;
+        on: () => void;
+        once: () => void;
+    };
+    stdin: {
+        isTTY: boolean;
+        fd: number;
+        on: () => void;
+        once: () => void;
+        resume: () => void;
+        pause: () => void;
+        setEncoding: () => void;
+        read: () => null;
+    };
+    platform: string;
+    arch: string;
+    version: string;
+    versions: {
+        node: string;
+        lifo: string;
+    };
+    pid: number;
+    ppid: number;
+    title: string;
+    execPath: string;
+    hrtime: ((prev?: [number, number]) => [number, number]) & {
+        bigint: () => bigint;
+    };
+    nextTick: (fn: (...args: unknown[]) => void, ...args: unknown[]) => void;
+    memoryUsage: () => {
+        rss: number;
+        heapTotal: number;
+        heapUsed: number;
+        external: number;
+        arrayBuffers: number;
+    };
+    uptime: () => number;
+    release: {
+        name: string;
+    };
+    config: {};
+    emitWarning: (msg: string) => void;
+    getuid: () => number;
+    getgid: () => number;
+    geteuid: () => number;
+    getegid: () => number;
+    umask: (mask?: number) => number;
+    binding: (name: string) => {
+        errname: (code: number) => string;
+        UV_EOF: number;
+        os?: undefined;
+        fs?: undefined;
+        crypto?: undefined;
+    } | {
+        errname?: undefined;
+        UV_EOF?: undefined;
+        os?: undefined;
+        fs?: undefined;
+        crypto?: undefined;
+    } | {
+        os: {};
+        fs: {};
+        crypto: {};
+        errname?: undefined;
+        UV_EOF?: undefined;
+    };
+    on: (event: string, fn: (...args: unknown[]) => void) => /*elided*/ any;
+    addListener: (event: string, fn: (...args: unknown[]) => void) => /*elided*/ any;
+    once: (event: string, fn: (...args: unknown[]) => void) => /*elided*/ any;
+    off: (event: string, fn: (...args: unknown[]) => void) => /*elided*/ any;
+    removeListener: (event: string, fn: (...args: unknown[]) => void) => /*elided*/ any;
+    removeAllListeners: (event?: string) => /*elided*/ any;
+    listeners: (event: string) => ((...args: unknown[]) => void)[];
+    emit: (event: string, ...args: unknown[]) => boolean;
+    listenerCount: (event: string) => number;
+    setMaxListeners: () => /*elided*/ any;
+    getMaxListeners: () => number;
+    prependListener: (event: string, fn: (...args: unknown[]) => void) => /*elided*/ any;
+    rawListeners: (event: string) => ((...args: unknown[]) => void)[];
+    eventNames: () => string[];
+    allowedNodeEnvironmentFlags: Set<string>;
+    features: {
+        inspector: boolean;
+        debug: boolean;
+        uv: boolean;
+        tls_alpn: boolean;
+        tls_sni: boolean;
+        tls_ocsp: boolean;
+        tls: boolean;
+    };
+};
+//# sourceMappingURL=process.d.ts.map

package/dist/substrate/lifo/node-compat/process.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"process.d.ts","sourceRoot":"","sources":["../../../../src/substrate/lifo/node-compat/process.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAEhE,qBAAa,gBAAiB,SAAQ,KAAK;IACzC,QAAQ,EAAE,MAAM,CAAC;gBACL,IAAI,EAAE,MAAM;CAKzB;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC5B,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,mBAAmB,CAAC;IAC5B,MAAM,EAAE,mBAAmB,CAAC;CAC7B;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,cAAc;;;;;;;kBAShC,MAAM;;;sBAQJ,MAAM;;;;;;;;;sBASN,MAAM;;;;;;;;;;;;;;;;;;cAkBD,MAAM;UACZ,MAAM;;;;;;;;;;qBAWX,CAAC,MAAM,EAAE,MAAM,CAAC,KAAG,CAAC,MAAM,EAAE,MAAM,CAAC;sBAa7B,MAAM;;mBAGP,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,WAAW,OAAO,EAAE;;;;;;;;;;;;;uBAgB5C,MAAM;;;;;mBAMV,MAAM;oBAEL,MAAM;wBAGA,MAAM;;;;;;;;;;;;;;;;;;gBAShB,MAAM,MAAM,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI;yBAK/B,MAAM,MAAM,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI;kBAG/C,MAAM,MAAM,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI;iBAOzC,MAAM,MAAM,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI;4BAM7B,MAAM,MAAM,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI;iCACnC,MAAM;uBAKhB,MAAM,gBArIqB,OAAO,EAAE,KAAK,IAAI;kBAsIlD,MAAM,WAAW,OAAO,EAAE;2BAMjB,MAAM;;;6BAGJ,MAAM,MAAM,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI;0BAK3C,MAAM,gBApJkB,OAAO,EAAE,KAAK,IAAI;;;;;;;;;;;;EA4JnE"}

package/dist/substrate/lifo/node-compat/process.js

@@ -0,0 +1,173 @@
+export class ProcessExitError extends Error {
+    exitCode;
+    constructor(code) {
+        super(`process.exit(${code})`);
+        this.name = 'ProcessExitError';
+        this.exitCode = code;
+    }
+}
+export function createProcess(opts) {
+    const startTime = Date.now();
+    const listeners = {};
+    const proc = {
+        argv: ['/usr/bin/node', ...opts.argv],
+        argv0: 'node',
+        env: { ...opts.env },
+        cwd: () => opts.cwd,
+        chdir: (_dir) => { throw new Error('process.chdir() is not supported in Lifo'); },
+        exit: (code = 0) => {
+            if (code !== 0) {
+                opts.stderr.write(`[process.exit] code=${code}\n`);
+            }
+            throw new ProcessExitError(code);
+        },
+        stdout: {
+            write: (data) => { opts.stdout.write(data); return true; },
+            isTTY: false,
+            fd: 1,
+            bytesWritten: 0,
+            columns: 80,
+            on: () => { },
+            once: () => { },
+        },
+        stderr: {
+            write: (data) => { opts.stderr.write(data); return true; },
+            isTTY: false,
+            fd: 2,
+            bytesWritten: 0,
+            columns: 80,
+            on: () => { },
+            once: () => { },
+        },
+        stdin: {
+            isTTY: false,
+            fd: 0,
+            on: () => { },
+            once: () => { },
+            resume: () => { },
+            pause: () => { },
+            setEncoding: () => { },
+            read: () => null,
+        },
+        platform: 'linux',
+        arch: 'x64',
+        version: 'v22.14.0',
+        versions: {
+            node: '22.14.0',
+            lifo: '0.1.0',
+        },
+        pid: 1,
+        ppid: 0,
+        title: 'node',
+        execPath: '/usr/bin/node',
+        hrtime: Object.assign((prev) => {
+            const now = performance.now();
+            const sec = Math.floor(now / 1000);
+            const nano = Math.floor((now % 1000) * 1e6);
+            if (prev) {
+                let ds = sec - prev[0];
+                let dn = nano - prev[1];
+                if (dn < 0) {
+                    ds--;
+                    dn += 1e9;
+                }
+                return [ds, dn];
+            }
+            return [sec, nano];
+        }, {
+            bigint: () => BigInt(Math.floor(performance.now() * 1e6)),
+        }),
+        nextTick: (fn, ...args) => {
+            queueMicrotask(() => fn(...args));
+        },
+        memoryUsage: () => {
+            const m = performance.memory;
+            return {
+                rss: m?.usedJSHeapSize ?? 0,
+                heapTotal: m?.totalJSHeapSize ?? 0,
+                heapUsed: m?.usedJSHeapSize ?? 0,
+                external: 0,
+                arrayBuffers: 0,
+            };
+        },
+        uptime: () => (Date.now() - startTime) / 1000,
+        release: { name: 'node' },
+        config: {},
+        emitWarning: (msg) => { opts.stderr.write(`Warning: ${msg}\n`); },
+        // POSIX identity stubs (needed by many npm packages)
+        getuid: () => 1000,
+        getgid: () => 1000,
+        geteuid: () => 1000,
+        getegid: () => 1000,
+        umask: (mask) => mask ?? 0o22,
+        // process.binding() stub — low-level Node.js internal, used by execa/errname etc.
+        binding: (name) => {
+            if (name === 'uv') {
+                return {
+                    errname: (code) => `UV_UNKNOWN_${code}`,
+                    UV_EOF: -4095,
+                };
+            }
+            if (name === 'natives')
+                return {};
+            if (name === 'constants')
+                return { os: {}, fs: {}, crypto: {} };
+            return {};
+        },
+        // EventEmitter-like methods (many packages check for process.on('exit'))
+        on: (event, fn) => {
+            if (!listeners[event])
+                listeners[event] = [];
+            listeners[event].push(fn);
+            return proc;
+        },
+        addListener: (event, fn) => {
+            return proc.on(event, fn);
+        },
+        once: (event, fn) => {
+            const wrapped = (...args) => {
+                proc.removeListener(event, wrapped);
+                fn(...args);
+            };
+            return proc.on(event, wrapped);
+        },
+        off: (event, fn) => {
+            if (listeners[event]) {
+                listeners[event] = listeners[event].filter((f) => f !== fn);
+            }
+            return proc;
+        },
+        removeListener: (event, fn) => proc.off(event, fn),
+        removeAllListeners: (event) => {
+            if (event)
+                delete listeners[event];
+            else
+                Object.keys(listeners).forEach((k) => delete listeners[k]);
+            return proc;
+        },
+        listeners: (event) => listeners[event] ? [...listeners[event]] : [],
+        emit: (event, ...args) => {
+            const fns = listeners[event];
+            if (!fns || fns.length === 0)
+                return false;
+            for (const fn of [...fns])
+                fn(...args);
+            return true;
+        },
+        listenerCount: (event) => listeners[event]?.length ?? 0,
+        setMaxListeners: () => proc,
+        getMaxListeners: () => 10,
+        prependListener: (event, fn) => {
+            if (!listeners[event])
+                listeners[event] = [];
+            listeners[event].unshift(fn);
+            return proc;
+        },
+        rawListeners: (event) => listeners[event] ? [...listeners[event]] : [],
+        eventNames: () => Object.keys(listeners),
+        // Feature detection flags
+        allowedNodeEnvironmentFlags: new Set(),
+        features: { inspector: false, debug: false, uv: false, tls_alpn: false, tls_sni: false, tls_ocsp: false, tls: false },
+    };
+    return proc;
+}

package/dist/substrate/lifo/node-compat/readline.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Node.js `readline` module shim for Lifo.
+ *
+ * Provides Interface (createInterface), clearLine, clearScreenDown,
+ * cursorTo, moveCursor, and the promises API.
+ */
+import { EventEmitter } from './events.js';
+export interface InterfaceOptions {
+    input?: {
+        on?: (event: string, cb: (...args: unknown[]) => void) => void;
+    };
+    output?: {
+        write?: (data: string) => void;
+    };
+    prompt?: string;
+    terminal?: boolean;
+    historySize?: number;
+    completer?: (line: string) => [string[], string];
+    crlfDelay?: number;
+}
+export declare class Interface extends EventEmitter {
+    private _prompt;
+    private _output;
+    private _closed;
+    private _lines;
+    terminal: boolean;
+    constructor(opts?: InterfaceOptions);
+    setPrompt(prompt: string): void;
+    getPrompt(): string;
+    prompt(preserveCursor?: boolean): void;
+    write(data: string): void;
+    question(query: string, cb: (answer: string) => void): void;
+    question(query: string, options: {
+        signal?: AbortSignal;
+    }, cb: (answer: string) => void): void;
+    close(): void;
+    pause(): this;
+    resume(): this;
+    getCursorPos(): {
+        rows: number;
+        cols: number;
+    };
+    get closed(): boolean;
+    [Symbol.asyncIterator](): AsyncIterableIterator<string>;
+}
+export declare function createInterface(opts: InterfaceOptions): Interface;
+export declare function createInterface(input: InterfaceOptions['input'], output?: InterfaceOptions['output']): Interface;
+export declare function clearLine(stream: {
+    write?: (data: string) => void;
+}, dir: number, cb?: () => void): boolean;
+export declare function clearScreenDown(stream: {
+    write?: (data: string) => void;
+}, cb?: () => void): boolean;
+export declare function cursorTo(stream: {
+    write?: (data: string) => void;
+}, x: number, y?: number | (() => void), cb?: () => void): boolean;
+export declare function moveCursor(stream: {
+    write?: (data: string) => void;
+}, dx: number, dy: number, cb?: () => void): boolean;
+export declare function emitKeypressEvents(_stream: unknown): void;
+export declare const promises: {
+    createInterface: (opts: InterfaceOptions) => Interface & {
+        question: (query: string, options?: {
+            signal?: AbortSignal;
+        }) => Promise<string>;
+    };
+};
+declare const _default: {
+    Interface: typeof Interface;
+    createInterface: typeof createInterface;
+    clearLine: typeof clearLine;
+    clearScreenDown: typeof clearScreenDown;
+    cursorTo: typeof cursorTo;
+    moveCursor: typeof moveCursor;
+    emitKeypressEvents: typeof emitKeypressEvents;
+    promises: {
+        createInterface: (opts: InterfaceOptions) => Interface & {
+            question: (query: string, options?: {
+                signal?: AbortSignal;
+            }) => Promise<string>;
+        };
+    };
+};
+export default _default;
+//# sourceMappingURL=readline.d.ts.map

package/dist/substrate/lifo/node-compat/readline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"readline.d.ts","sourceRoot":"","sources":["../../../../src/substrate/lifo/node-compat/readline.ts"],"names":[],"mappings":"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"}

package/dist/substrate/lifo/node-compat/readline.js

@@ -0,0 +1,205 @@
+/**
+ * Node.js `readline` module shim for Lifo.
+ *
+ * Provides Interface (createInterface), clearLine, clearScreenDown,
+ * cursorTo, moveCursor, and the promises API.
+ */
+import { EventEmitter } from './events.js';
+export class Interface extends EventEmitter {
+    _prompt;
+    _output;
+    _closed = false;
+    _lines = [];
+    terminal;
+    constructor(opts = {}) {
+        super();
+        this._prompt = opts.prompt ?? '> ';
+        this._output = opts.output;
+        this.terminal = opts.terminal ?? false;
+        // Listen for data on input if provided
+        if (opts.input?.on) {
+            opts.input.on('data', (chunk) => {
+                if (this._closed)
+                    return;
+                const lines = String(chunk).split(/\r?\n/);
+                for (const line of lines) {
+                    if (line !== '') {
+                        this._lines.push(line);
+                        this.emit('line', line);
+                    }
+                }
+            });
+            opts.input.on('end', () => {
+                if (!this._closed)
+                    this.close();
+            });
+        }
+    }
+    setPrompt(prompt) {
+        this._prompt = prompt;
+    }
+    getPrompt() {
+        return this._prompt;
+    }
+    prompt(preserveCursor = false) {
+        if (this._closed)
+            return;
+        void preserveCursor;
+        this._output?.write?.(this._prompt);
+    }
+    write(data) {
+        if (this._closed)
+            return;
+        const lines = data.split(/\r?\n/);
+        for (const line of lines) {
+            if (line !== '') {
+                this._lines.push(line);
+                this.emit('line', line);
+            }
+        }
+    }
+    question(query, optionsOrCb, cb) {
+        if (this._closed)
+            return;
+        const callback = typeof optionsOrCb === 'function' ? optionsOrCb : cb;
+        this._output?.write?.(query);
+        // Answer comes from next line event
+        this.once('line', (line) => callback(line));
+    }
+    close() {
+        if (this._closed)
+            return;
+        this._closed = true;
+        this.emit('close');
+    }
+    pause() {
+        this.emit('pause');
+        return this;
+    }
+    resume() {
+        this.emit('resume');
+        return this;
+    }
+    getCursorPos() {
+        return { rows: 0, cols: 0 };
+    }
+    get closed() {
+        return this._closed;
+    }
+    [Symbol.asyncIterator]() {
+        const iface = this;
+        const queue = [];
+        let resolveNext = null;
+        iface.on('line', (line) => {
+            if (resolveNext) {
+                const r = resolveNext;
+                resolveNext = null;
+                r({ value: line, done: false });
+            }
+            else {
+                queue.push(line);
+            }
+        });
+        iface.on('close', () => {
+            if (resolveNext) {
+                const r = resolveNext;
+                resolveNext = null;
+                r({ value: undefined, done: true });
+            }
+        });
+        return {
+            next() {
+                if (queue.length > 0) {
+                    return Promise.resolve({ value: queue.shift(), done: false });
+                }
+                if (iface._closed) {
+                    return Promise.resolve({ value: undefined, done: true });
+                }
+                return new Promise((resolve) => { resolveNext = resolve; });
+            },
+            return() {
+                iface.close();
+                return Promise.resolve({ value: undefined, done: true });
+            },
+            throw(err) {
+                iface.close();
+                return Promise.reject(err);
+            },
+            [Symbol.asyncIterator]() { return this; },
+        };
+    }
+}
+export function createInterface(inputOrOpts, output) {
+    if (inputOrOpts && typeof inputOrOpts === 'object' && ('input' in inputOrOpts || 'output' in inputOrOpts || 'prompt' in inputOrOpts)) {
+        return new Interface(inputOrOpts);
+    }
+    return new Interface({ input: inputOrOpts, output });
+}
+export function clearLine(stream, dir, cb) {
+    const mode = dir < 0 ? 1 : dir > 0 ? 0 : 2;
+    stream.write?.(`\x1b[${mode}K`);
+    cb?.();
+    return true;
+}
+export function clearScreenDown(stream, cb) {
+    stream.write?.('\x1b[0J');
+    cb?.();
+    return true;
+}
+export function cursorTo(stream, x, y, cb) {
+    if (typeof y === 'function') {
+        cb = y;
+        y = undefined;
+    }
+    const col = Math.max(0, Math.floor(Number(x) || 0)) + 1;
+    if (y === undefined) {
+        stream.write?.(`\x1b[${col}G`);
+    }
+    else {
+        const row = Math.max(0, Math.floor(Number(y) || 0)) + 1;
+        stream.write?.(`\x1b[${row};${col}H`);
+    }
+    cb?.();
+    return true;
+}
+export function moveCursor(stream, dx, dy, cb) {
+    const x = Math.trunc(Number(dx) || 0);
+    const y = Math.trunc(Number(dy) || 0);
+    if (x < 0)
+        stream.write?.(`\x1b[${-x}D`);
+    else if (x > 0)
+        stream.write?.(`\x1b[${x}C`);
+    if (y < 0)
+        stream.write?.(`\x1b[${-y}A`);
+    else if (y > 0)
+        stream.write?.(`\x1b[${y}B`);
+    cb?.();
+    return true;
+}
+export function emitKeypressEvents(_stream) {
+    // no-op
+}
+// readline/promises API
+export const promises = {
+    createInterface: (opts) => {
+        const iface = createInterface(opts);
+        const promiseIface = iface;
+        const originalQuestion = iface.question.bind(iface);
+        promiseIface.question = (query, _options) => {
+            return new Promise((resolve) => {
+                originalQuestion(query, (answer) => resolve(answer));
+            });
+        };
+        return promiseIface;
+    },
+};
+export default {
+    Interface,
+    createInterface,
+    clearLine,
+    clearScreenDown,
+    cursorTo,
+    moveCursor,
+    emitKeypressEvents,
+    promises,
+};

package/dist/substrate/lifo/node-compat/rimraf.d.ts

@@ -0,0 +1,30 @@
+/**
+ * `rimraf` npm package shim for Lifo.
+ *
+ * Provides the rimraf(path, [opts], cb) callback API, rimraf.sync(path),
+ * and the modern rimraf v4+ promise-based API, all backed by the VFS
+ * fs shim's recursive rmdir.
+ */
+import type { VFS } from '../kernel/vfs/index.js';
+export interface RimrafOptions {
+    glob?: boolean | object;
+    maxRetries?: number;
+    retryDelay?: number;
+    filter?: (path: string) => boolean;
+}
+export declare function createRimraf(vfs: VFS, cwd: string): {
+    (p: string, optsOrCb?: RimrafOptions | ((err: Error | null) => void), cb?: (err: Error | null) => void): void;
+    sync: (p: string) => void;
+    rimraf: (p: string) => Promise<void>;
+    rimrafSync: (p: string) => void;
+    native: (p: string) => Promise<void>;
+    nativeSync: (p: string) => void;
+    manual: (p: string) => Promise<void>;
+    manualSync: (p: string) => void;
+    windows: (p: string) => Promise<void>;
+    windowsSync: (p: string) => void;
+    moveRemove: (p: string) => Promise<void>;
+    moveRemoveSync: (p: string) => void;
+    default: /*elided*/ any;
+};
+//# sourceMappingURL=rimraf.d.ts.map

package/dist/substrate/lifo/node-compat/rimraf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rimraf.d.ts","sourceRoot":"","sources":["../../../../src/substrate/lifo/node-compat/rimraf.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,wBAAwB,CAAC;AAGlD,MAAM,WAAW,aAAa;IAC5B,IAAI,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;IACxB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC;CACpC;AAED,wBAAgB,YAAY,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,MAAM;QAyB7B,MAAM,aAAa,aAAa,GAAG,CAAC,CAAC,GAAG,EAAE,KAAK,GAAG,IAAI,KAAK,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,KAAK,GAAG,IAAI,KAAK,IAAI,GAAG,IAAI;cAxBrG,MAAM,KAAG,IAAI;gBAYZ,MAAM,KAAG,OAAO,CAAC,IAAI,CAAC;oBAZvB,MAAM,KAAG,IAAI;gBAYZ,MAAM,KAAG,OAAO,CAAC,IAAI,CAAC;oBAZvB,MAAM,KAAG,IAAI;gBAYZ,MAAM,KAAG,OAAO,CAAC,IAAI,CAAC;oBAZvB,MAAM,KAAG,IAAI;iBAYZ,MAAM,KAAG,OAAO,CAAC,IAAI,CAAC;qBAZvB,MAAM,KAAG,IAAI;oBAYZ,MAAM,KAAG,OAAO,CAAC,IAAI,CAAC;wBAZvB,MAAM,KAAG,IAAI;;EA4DrC"}