@nimbus-sh/core 0.1.0

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

@@ -0,0 +1,291 @@
+import { createFs } from './fs.js';
+import pathModule from './path.js';
+import { createOs } from './os.js';
+import { createProcess } from './process.js';
+import { EventEmitter } from './events.js';
+import { Buffer } from './buffer.js';
+import * as utilModule from './util.js';
+import { createHttp } from './http.js';
+import { createChildProcess } from './child_process.js';
+import * as streamModule from './stream.js';
+import * as urlModule from './url.js';
+import * as timersModule from './timers.js';
+import * as cryptoModule from './crypto.js';
+import * as zlibModule from './zlib.js';
+import * as stringDecoderModule from './string_decoder.js';
+import * as ttyModule from './tty.js';
+import * as dnsModule from './dns.js';
+import { createModuleShim } from './module.js';
+import * as readlineModule from './readline.js';
+import { createRimraf } from './rimraf.js';
+import { createEsbuild } from './esbuild.js';
+export function createModuleMap(ctx) {
+    const map = {
+        fs: () => createFs(ctx.vfs, ctx.cwd),
+        'fs/promises': () => createFs(ctx.vfs, ctx.cwd).promises,
+        path: () => pathModule,
+        os: () => createOs(ctx.env),
+        process: () => createProcess({
+            argv: ctx.argv,
+            env: ctx.env,
+            cwd: ctx.cwd,
+            stdout: ctx.stdout,
+            stderr: ctx.stderr,
+        }),
+        events: () => {
+            // Node.js CJS: require('events') returns the EventEmitter constructor itself
+            const mod = EventEmitter;
+            mod.EventEmitter = EventEmitter;
+            mod.default = EventEmitter;
+            return mod;
+        },
+        buffer: () => ({ Buffer }),
+        util: () => utilModule,
+        http: () => createHttp(ctx.portRegistry, 'http:', ctx.routeLoopback),
+        https: () => createHttp(ctx.portRegistry, 'https:', ctx.routeLoopback),
+        child_process: () => createChildProcess(ctx.executeCapture),
+        stream: () => {
+            // Node.js CJS: require('stream') returns the Stream base class with
+            // .Readable, .Writable, .Duplex, .PassThrough, .Stream attached
+            const Stream = EventEmitter;
+            Stream.Stream = Stream;
+            Stream.Readable = streamModule.Readable;
+            Stream.Writable = streamModule.Writable;
+            Stream.Duplex = streamModule.Duplex;
+            Stream.PassThrough = streamModule.PassThrough;
+            Stream.default = Stream;
+            return Stream;
+        },
+        url: () => urlModule,
+        timers: () => timersModule,
+        crypto: () => cryptoModule,
+        zlib: () => zlibModule,
+        string_decoder: () => stringDecoderModule,
+        tty: () => ttyModule,
+        dns: () => dnsModule,
+        'dns/promises': () => dnsModule.promises,
+        readline: () => readlineModule,
+        'readline/promises': () => readlineModule.promises,
+        constants: () => {
+            const fs = createFs(ctx.vfs, ctx.cwd);
+            const os = createOs(ctx.env);
+            return { ...os.constants, ...fs.constants };
+        },
+        querystring: () => ({
+            parse: (str) => {
+                const out = {};
+                new URLSearchParams(str).forEach((value, key) => {
+                    out[key] = value;
+                });
+                return out;
+            },
+            stringify: (obj) => new URLSearchParams(obj).toString(),
+            escape: encodeURIComponent,
+            unescape: decodeURIComponent,
+        }),
+        assert: () => {
+            const assert = (value, message) => {
+                if (!value)
+                    throw new Error(message || 'AssertionError');
+            };
+            assert.ok = assert;
+            assert.equal = (a, b, msg) => { if (a != b)
+                throw new Error(msg || `${a} != ${b}`); };
+            assert.strictEqual = (a, b, msg) => { if (a !== b)
+                throw new Error(msg || `${a} !== ${b}`); };
+            assert.notEqual = (a, b, msg) => { if (a == b)
+                throw new Error(msg || `${a} == ${b}`); };
+            assert.notStrictEqual = (a, b, msg) => { if (a === b)
+                throw new Error(msg || `${a} === ${b}`); };
+            assert.deepStrictEqual = (a, b, msg) => {
+                if (JSON.stringify(a) !== JSON.stringify(b))
+                    throw new Error(msg || 'deepStrictEqual failed');
+            };
+            assert.throws = (fn, msg) => {
+                try {
+                    fn();
+                    throw new Error(msg || 'Expected function to throw');
+                }
+                catch (e) {
+                    if (e instanceof Error && e.message === (msg || 'Expected function to throw'))
+                        throw e;
+                }
+            };
+            return assert;
+        },
+        // v8 — stub (vite side-effect imports it)
+        v8: () => ({
+            getHeapStatistics: () => ({
+                total_heap_size: 0, used_heap_size: 0, heap_size_limit: 0,
+                total_physical_size: 0, total_available_size: 0,
+                malloced_memory: 0, peak_malloced_memory: 0,
+            }),
+            serialize: (v) => new Uint8Array(0),
+            deserialize: () => undefined,
+        }),
+        // perf_hooks — vite uses { performance } which is a browser global
+        perf_hooks: () => ({
+            performance,
+            PerformanceObserver: typeof PerformanceObserver === 'undefined'
+                ? class PerformanceObserver {
+                    observe() { }
+                    disconnect() { }
+                }
+                : PerformanceObserver,
+        }),
+        // net — stub (vite imports it but only uses it for actual TCP in server mode)
+        net: () => ({
+            createServer: () => {
+                const s = new EventEmitter();
+                s.listen = (_port, _host, cb) => { cb?.(); return s; };
+                s.close = (cb) => { cb?.(); return s; };
+                s.address = () => ({ port: 0, family: 'IPv4', address: '127.0.0.1' });
+                s.unref = () => s;
+                s.ref = () => s;
+                return s;
+            },
+            createConnection: () => {
+                const s = new EventEmitter();
+                s.write = () => true;
+                s.end = () => s;
+                s.destroy = () => s;
+                s.connect = () => s;
+                s.unref = () => s;
+                s.ref = () => s;
+                s.setTimeout = () => s;
+                s.setNoDelay = () => s;
+                s.setKeepAlive = () => s;
+                return s;
+            },
+            connect: (...args) => {
+                const s = new EventEmitter();
+                s.write = () => true;
+                s.end = () => s;
+                s.destroy = () => s;
+                s.unref = () => s;
+                s.ref = () => s;
+                s.setTimeout = () => s;
+                s.setNoDelay = () => s;
+                s.setKeepAlive = () => s;
+                // call connection callback if provided
+                const cb = typeof args[args.length - 1] === 'function' ? args[args.length - 1] : null;
+                if (cb)
+                    queueMicrotask(cb);
+                return s;
+            },
+            Socket: class Socket extends EventEmitter {
+                write() { return true; }
+                end() { return this; }
+                destroy() { return this; }
+                connect() { return this; }
+                unref() { return this; }
+                ref() { return this; }
+                setTimeout() { return this; }
+                setNoDelay() { return this; }
+                setKeepAlive() { return this; }
+            },
+            Server: class Server extends EventEmitter {
+                listen(_port, _host, cb) { cb?.(); return this; }
+                close(cb) { cb?.(); return this; }
+                address() { return { port: 0, family: 'IPv4', address: '127.0.0.1' }; }
+                unref() { return this; }
+                ref() { return this; }
+            },
+            isIP: (s) => /^\d+\.\d+\.\d+\.\d+$/.test(s) ? 4 : /^[0-9a-f:]+$/i.test(s) ? 6 : 0,
+            isIPv4: (s) => /^\d+\.\d+\.\d+\.\d+$/.test(s),
+            isIPv6: (s) => /^[0-9a-f:]+$/i.test(s),
+        }),
+        // tls — stub
+        tls: () => ({
+            createServer: () => {
+                const s = new EventEmitter();
+                s.listen = (_port, _host, cb) => { cb?.(); return s; };
+                s.close = (cb) => { cb?.(); return s; };
+                s.address = () => ({ port: 0, family: 'IPv4', address: '127.0.0.1' });
+                return s;
+            },
+            connect: () => {
+                const s = new EventEmitter();
+                s.write = () => true;
+                s.end = () => s;
+                s.destroy = () => s;
+                s.encrypted = true;
+                return s;
+            },
+            TLSSocket: class TLSSocket extends EventEmitter {
+            },
+            SERVER_METHODS: [],
+        }),
+        // worker_threads — stub (vite uses it for thread pool but can fall back)
+        worker_threads: () => ({
+            isMainThread: true,
+            parentPort: null,
+            workerData: null,
+            Worker: class Worker extends EventEmitter {
+                constructor() { super(); }
+                postMessage() { }
+                terminate() { return Promise.resolve(0); }
+            },
+            threadId: 0,
+        }),
+        // http2 — stub (vite imports it for HTTP/2 server but falls back to HTTP/1.1)
+        http2: () => ({
+            createServer: () => {
+                const s = new EventEmitter();
+                s.listen = (_port, _host, cb) => { cb?.(); return s; };
+                s.close = (cb) => { cb?.(); return s; };
+                s.setTimeout = () => s;
+                return s;
+            },
+            createSecureServer: () => {
+                const s = new EventEmitter();
+                s.listen = (_port, _host, cb) => { cb?.(); return s; };
+                s.close = (cb) => { cb?.(); return s; };
+                s.setTimeout = () => s;
+                return s;
+            },
+            connect: () => {
+                const s = new EventEmitter();
+                s.close = () => { };
+                s.destroy = () => { };
+                return s;
+            },
+            constants: {
+                HTTP2_HEADER_PATH: ':path',
+                HTTP2_HEADER_METHOD: ':method',
+                HTTP2_HEADER_STATUS: ':status',
+                HTTP2_HEADER_CONTENT_TYPE: 'content-type',
+                HTTP_STATUS_OK: 200,
+                HTTP_STATUS_INTERNAL_SERVER_ERROR: 500,
+            },
+            sensitiveHeaders: Symbol('nodejs.http2.sensitiveHeaders'),
+            getDefaultSettings: () => ({}),
+            getPackedSettings: () => Buffer.alloc(0),
+            getUnpackedSettings: () => ({}),
+        }),
+        // inspector — stub (vite only uses it in --profile mode)
+        inspector: () => ({
+            Session: class Session extends EventEmitter {
+                connect() { }
+                disconnect() { }
+                post(_method, _params, cb) {
+                    if (typeof _params === 'function') {
+                        _params();
+                        return;
+                    }
+                    cb?.();
+                }
+            },
+            open: () => { },
+            close: () => { },
+            url: () => undefined,
+        }),
+    };
+    // module shim needs access to the map itself for createRequire
+    map.module = () => createModuleShim(map);
+    // npm package shims
+    map.rimraf = () => createRimraf(ctx.vfs, ctx.cwd);
+    map.esbuild = () => createEsbuild();
+    return map;
+}
+export { ProcessExitError } from './process.js';

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

@@ -0,0 +1,55 @@
+/**
+ * Node.js `module` shim for Lifo.
+ *
+ * Provides the commonly used APIs from the `node:module` built-in:
+ * - Module class with id, filename, exports, paths, require, etc.
+ * - createRequire() — returns a require-like function backed by the module map
+ * - builtinModules — list of shimmed built-in module names
+ * - isBuiltin() — check if a module name is a built-in
+ */
+/** All built-in module names available in the Lifo node-compat layer */
+export declare const builtinModules: string[];
+/**
+ * Check whether a specifier refers to a Node.js built-in module.
+ * Handles both bare names ("fs") and the "node:" prefix ("node:fs").
+ */
+export declare function isBuiltin(specifier: string): boolean;
+export type RequireFunction = ((id: string) => unknown) & {
+    resolve: (id: string) => string;
+    cache: Record<string, unknown>;
+};
+/**
+ * Factory for createRequire — needs the module map from index.ts at runtime.
+ * Called from createModuleMap() so it has access to the lazily-built map.
+ */
+export declare function makeCreateRequire(moduleMap: Record<string, () => unknown>): (filename: string | URL) => RequireFunction;
+/**
+ * Minimal Module class matching the shape code typically expects.
+ */
+export declare class Module {
+    id: string;
+    filename: string;
+    exports: unknown;
+    parent: Module | null;
+    children: Module[];
+    loaded: boolean;
+    paths: string[];
+    constructor(id?: string, parent?: Module | null);
+    require(_id: string): unknown;
+    static builtinModules: string[];
+    static isBuiltin: typeof isBuiltin;
+    static createRequire: (filename: string | URL) => RequireFunction;
+    static _resolveFilename(request: string): string;
+    static _cache: Record<string, unknown>;
+}
+/**
+ * Create the full module shim object with createRequire bound to a module map.
+ */
+export declare function createModuleShim(moduleMap: Record<string, () => unknown>): {
+    Module: typeof Module;
+    builtinModules: string[];
+    isBuiltin: typeof isBuiltin;
+    createRequire: (filename: string | URL) => RequireFunction;
+    default: typeof Module;
+};
+//# sourceMappingURL=module.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../../../src/substrate/lifo/node-compat/module.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,wEAAwE;AACxE,eAAO,MAAM,cAAc,EAAE,MAAM,EA+BlC,CAAC;AAEF;;;GAGG;AACH,wBAAgB,SAAS,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAGpD;AAED,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC,GAAG;IACxD,OAAO,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,MAAM,CAAC;IAChC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAChC,CAAC;AAEF;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,OAAO,CAAC,GACvC,CAAC,QAAQ,EAAE,MAAM,GAAG,GAAG,KAAK,eAAe,CA4B7C;AAED;;GAEG;AACH,qBAAa,MAAM;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,MAAM,EAAE,OAAO,CAAC;IAChB,KAAK,EAAE,MAAM,EAAE,CAAC;gBAEJ,EAAE,SAAK,EAAE,MAAM,GAAE,MAAM,GAAG,IAAW;IAUjD,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAI7B,MAAM,CAAC,cAAc,WAAkB;IACvC,MAAM,CAAC,SAAS,mBAAa;IAE7B,MAAM,CAAC,aAAa,EAAE,CAAC,QAAQ,EAAE,MAAM,GAAG,GAAG,KAAK,eAAe,CAAC;IAElE,MAAM,CAAC,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM;IAIhD,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAM;CAC7C;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,OAAO,CAAC;;;;8BAvE3D,MAAM,GAAG,GAAG,KAAK,eAAe;;EAmF7C"}

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

@@ -0,0 +1,124 @@
+/**
+ * Node.js `module` shim for Lifo.
+ *
+ * Provides the commonly used APIs from the `node:module` built-in:
+ * - Module class with id, filename, exports, paths, require, etc.
+ * - createRequire() — returns a require-like function backed by the module map
+ * - builtinModules — list of shimmed built-in module names
+ * - isBuiltin() — check if a module name is a built-in
+ */
+/** All built-in module names available in the Lifo node-compat layer */
+export const builtinModules = [
+    'assert',
+    'buffer',
+    'child_process',
+    'console',
+    'constants',
+    'crypto',
+    'dns',
+    'dns/promises',
+    'events',
+    'fs',
+    'fs/promises',
+    'http',
+    'https',
+    'module',
+    'net',
+    'os',
+    'path',
+    'process',
+    'querystring',
+    'readline',
+    'stream',
+    'string_decoder',
+    'timers',
+    'tls',
+    'tty',
+    'url',
+    'util',
+    'vm',
+    'worker_threads',
+    'zlib',
+];
+/**
+ * Check whether a specifier refers to a Node.js built-in module.
+ * Handles both bare names ("fs") and the "node:" prefix ("node:fs").
+ */
+export function isBuiltin(specifier) {
+    const name = specifier.startsWith('node:') ? specifier.slice(5) : specifier;
+    return builtinModules.includes(name);
+}
+/**
+ * Factory for createRequire — needs the module map from index.ts at runtime.
+ * Called from createModuleMap() so it has access to the lazily-built map.
+ */
+export function makeCreateRequire(moduleMap) {
+    return function createRequire(_filename) {
+        const cache = {};
+        const req = function require(id) {
+            const name = id.startsWith('node:') ? id.slice(5) : id;
+            if (cache[name])
+                return cache[name];
+            if (moduleMap[name]) {
+                const mod = moduleMap[name]();
+                cache[name] = mod;
+                return mod;
+            }
+            throw new Error(`Cannot find module '${id}'`);
+        };
+        req.resolve = (id) => {
+            const name = id.startsWith('node:') ? id.slice(5) : id;
+            if (moduleMap[name])
+                return name;
+            throw new Error(`Cannot find module '${id}'`);
+        };
+        req.cache = cache;
+        return req;
+    };
+}
+/**
+ * Minimal Module class matching the shape code typically expects.
+ */
+export class Module {
+    id;
+    filename;
+    exports;
+    parent;
+    children;
+    loaded;
+    paths;
+    constructor(id = '', parent = null) {
+        this.id = id;
+        this.filename = id;
+        this.exports = {};
+        this.parent = parent;
+        this.children = [];
+        this.loaded = false;
+        this.paths = [];
+    }
+    require(_id) {
+        throw new Error('Module.require() is not supported — use createRequire() instead');
+    }
+    static builtinModules = builtinModules;
+    static isBuiltin = isBuiltin;
+    // createRequire is attached dynamically in createModuleShim()
+    static createRequire;
+    static _resolveFilename(request) {
+        return request;
+    }
+    static _cache = {};
+}
+/**
+ * Create the full module shim object with createRequire bound to a module map.
+ */
+export function createModuleShim(moduleMap) {
+    const createRequire = makeCreateRequire(moduleMap);
+    Module.createRequire = createRequire;
+    return {
+        Module,
+        builtinModules,
+        isBuiltin,
+        createRequire,
+        default: Module,
+    };
+}

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

@@ -0,0 +1,39 @@
+export declare function createOs(env: Record<string, string>): {
+    arch: () => string;
+    platform: () => string;
+    type: () => string;
+    release: () => string;
+    hostname: () => string;
+    homedir: () => string;
+    tmpdir: () => string;
+    cpus: () => {
+        model: string;
+        speed: number;
+        times: {
+            user: number;
+            nice: number;
+            sys: number;
+            idle: number;
+            irq: number;
+        };
+    }[];
+    totalmem: () => number;
+    freemem: () => number;
+    uptime: () => number;
+    loadavg: () => number[];
+    networkInterfaces: () => {};
+    userInfo: () => {
+        uid: number;
+        gid: number;
+        username: string;
+        homedir: string;
+        shell: string;
+    };
+    EOL: string;
+    endianness: () => "LE";
+    constants: {
+        signals: Record<string, number>;
+        errno: Record<string, number>;
+    };
+};
+//# sourceMappingURL=os.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"os.d.ts","sourceRoot":"","sources":["../../../../src/substrate/lifo/node-compat/os.ts"],"names":[],"mappings":"AAAA,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAqC9B,IAAI;;iBAEL,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;eACxB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;;EAGxC"}

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

@@ -0,0 +1,45 @@
+export function createOs(env) {
+    return {
+        arch: () => 'wasm',
+        platform: () => 'lifo',
+        type: () => 'Lifo',
+        release: () => '0.1.0',
+        hostname: () => env.HOSTNAME || 'lifo',
+        homedir: () => env.HOME || '/home/user',
+        tmpdir: () => '/tmp',
+        cpus: () => {
+            const count = navigator.hardwareConcurrency || 4;
+            return Array.from({ length: count }, () => ({
+                model: 'Browser CPU',
+                speed: 2400,
+                times: { user: 0, nice: 0, sys: 0, idle: 0, irq: 0 },
+            }));
+        },
+        totalmem: () => {
+            const m = performance.memory;
+            return m?.jsHeapSizeLimit ?? 4 * 1024 * 1024 * 1024;
+        },
+        freemem: () => {
+            const m = performance.memory;
+            if (m)
+                return m.jsHeapSizeLimit - m.usedJSHeapSize;
+            return 2 * 1024 * 1024 * 1024;
+        },
+        uptime: () => Math.floor(performance.now() / 1000),
+        loadavg: () => [0, 0, 0],
+        networkInterfaces: () => ({}),
+        userInfo: () => ({
+            uid: 1000,
+            gid: 1000,
+            username: env.USER || 'user',
+            homedir: env.HOME || '/home/user',
+            shell: env.SHELL || '/bin/sh',
+        }),
+        EOL: '\n',
+        endianness: () => 'LE',
+        constants: {
+            signals: {},
+            errno: {},
+        },
+    };
+}

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

@@ -0,0 +1,86 @@
+import { normalize, isAbsolute, join, resolve, dirname, basename, extname } from '../utils/path.js';
+export declare function relative(from: string, to: string): string;
+export interface ParsedPath {
+    root: string;
+    dir: string;
+    base: string;
+    ext: string;
+    name: string;
+}
+export declare function parse(path: string): ParsedPath;
+export declare function format(pathObj: Partial<ParsedPath>): string;
+export declare const sep = "/";
+export declare const delimiter = ":";
+export declare const posix: {
+    normalize: typeof normalize;
+    isAbsolute: typeof isAbsolute;
+    join: typeof join;
+    resolve: (...args: string[]) => string;
+    dirname: typeof dirname;
+    basename: typeof basename;
+    extname: typeof extname;
+    relative: typeof relative;
+    parse: typeof parse;
+    format: typeof format;
+    sep: string;
+    delimiter: string;
+};
+export declare const win32: {
+    normalize: typeof normalize;
+    isAbsolute: typeof isAbsolute;
+    join: typeof join;
+    resolve: (...args: string[]) => string;
+    dirname: typeof dirname;
+    basename: typeof basename;
+    extname: typeof extname;
+    relative: typeof relative;
+    parse: typeof parse;
+    format: typeof format;
+    sep: string;
+    delimiter: string;
+};
+export { normalize, isAbsolute, join, resolve, dirname, basename, extname };
+declare const _default: {
+    normalize: typeof normalize;
+    isAbsolute: typeof isAbsolute;
+    join: typeof join;
+    resolve: (...args: string[]) => string;
+    dirname: typeof dirname;
+    basename: typeof basename;
+    extname: typeof extname;
+    relative: typeof relative;
+    parse: typeof parse;
+    format: typeof format;
+    sep: string;
+    delimiter: string;
+    posix: {
+        normalize: typeof normalize;
+        isAbsolute: typeof isAbsolute;
+        join: typeof join;
+        resolve: (...args: string[]) => string;
+        dirname: typeof dirname;
+        basename: typeof basename;
+        extname: typeof extname;
+        relative: typeof relative;
+        parse: typeof parse;
+        format: typeof format;
+        sep: string;
+        delimiter: string;
+    };
+    win32: {
+        normalize: typeof normalize;
+        isAbsolute: typeof isAbsolute;
+        join: typeof join;
+        resolve: (...args: string[]) => string;
+        dirname: typeof dirname;
+        basename: typeof basename;
+        extname: typeof extname;
+        relative: typeof relative;
+        parse: typeof parse;
+        format: typeof format;
+        sep: string;
+        delimiter: string;
+    };
+};
+export default _default;
+//# sourceMappingURL=path.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"path.d.ts","sourceRoot":"","sources":["../../../../src/substrate/lifo/node-compat/path.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,SAAS,EACT,UAAU,EACV,IAAI,EACJ,OAAO,EACP,OAAO,EACP,QAAQ,EACR,OAAO,EACR,MAAM,kBAAkB,CAAC;AAE1B,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAiBzD;AAED,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;CACd;AAED,wBAAgB,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,CAO9C;AAED,wBAAgB,MAAM,CAAC,OAAO,EAAE,OAAO,CAAC,UAAU,CAAC,GAAG,MAAM,CAO3D;AAED,eAAO,MAAM,GAAG,MAAM,CAAC;AACvB,eAAO,MAAM,SAAS,MAAM,CAAC;AAC7B,eAAO,MAAM,KAAK;;;;uBACgC,MAAM,EAAE;;;;;;;;;CAEzD,CAAC;AAEF,eAAO,MAAM,KAAK;;;;uBACgC,MAAM,EAAE;;;;;;;;;CAIzD,CAAC;AAEF,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC;;;;;uBAE1B,MAAM,EAAE;;;;;;;;;;;;;2BAbR,MAAM,EAAE;;;;;;;;;;;;;;2BAKR,MAAM,EAAE;;;;;;;;;;;AAO1D,wBAGE"}