@nimbus-sh/core 0.1.0

package/dist/substrate/lifo/kernel/vfs/types.js

@@ -0,0 +1,42 @@
+/**
+ * `st_mode` file-type bits. `Stat.type` only distinguishes file from
+ * directory, so anything finer — a character device, a symlink — is carried
+ * in the mode, exactly as Unix does it. `ls -l` and `stat` read the leading
+ * type character from here.
+ */
+export const S_IFMT = 0o170000;
+export const S_IFREG = 0o100000;
+export const S_IFDIR = 0o040000;
+export const S_IFCHR = 0o020000;
+export const S_IFLNK = 0o120000;
+/** True for a character device such as `/dev/zero`, which streams rather than stores. */
+export function isCharacterDevice(mode) {
+    return (mode & S_IFMT) === S_IFCHR;
+}
+/** The `ls -l` type character for a mode, falling back to the coarse `Stat.type`. */
+export function fileTypeChar(mode, type) {
+    switch (mode & S_IFMT) {
+        case S_IFCHR: return 'c';
+        case S_IFLNK: return 'l';
+        case S_IFDIR: return 'd';
+        case S_IFREG: return '-';
+        default: return type === 'directory' ? 'd' : '-';
+    }
+}
+export const ErrorCode = {
+    ENOENT: 'ENOENT',
+    EEXIST: 'EEXIST',
+    ENOTDIR: 'ENOTDIR',
+    EISDIR: 'EISDIR',
+    ENOTEMPTY: 'ENOTEMPTY',
+    EINVAL: 'EINVAL',
+    EXDEV: 'EXDEV',
+};
+export class VFSError extends Error {
+    code;
+    constructor(code, message) {
+        super(`${code}: ${message}`);
+        this.code = code;
+        this.name = 'VFSError';
+    }
+}

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

@@ -0,0 +1,44 @@
+export declare class Buffer extends Uint8Array {
+    static from(value: string | Uint8Array | number[] | ArrayBuffer | ArrayLike<number> | Iterable<number>, encodingOrMapFn?: string | ((v: number, k: number) => number), _thisArg?: unknown): Buffer;
+    static alloc(size: number, fill?: number): Buffer;
+    static allocUnsafe(size: number): Buffer;
+    static isBuffer(obj: unknown): obj is Buffer;
+    static concat(list: (Uint8Array | Buffer)[], totalLength?: number): Buffer;
+    static byteLength(str: string, encoding?: string): number;
+    toString(encoding?: string, start?: number, end?: number): string;
+    write(str: string, offset?: number, length?: number, encoding?: string): number;
+    toJSON(): {
+        type: 'Buffer';
+        data: number[];
+    };
+    copy(target: Buffer | Uint8Array, targetStart?: number, sourceStart?: number, sourceEnd?: number): number;
+    equals(other: Uint8Array): boolean;
+    compare(other: Uint8Array): number;
+    slice(start?: number, end?: number): Buffer;
+    subarray(start?: number, end?: number): Buffer;
+    readUInt8(offset?: number): number;
+    readUInt16BE(offset?: number): number;
+    readUInt32BE(offset?: number): number;
+    readInt8(offset?: number): number;
+    readInt16BE(offset?: number): number;
+    readInt32BE(offset?: number): number;
+    readUInt16LE(offset?: number): number;
+    readUInt32LE(offset?: number): number;
+    readInt16LE(offset?: number): number;
+    readInt32LE(offset?: number): number;
+    writeUInt8(value: number, offset?: number): number;
+    writeUInt16BE(value: number, offset?: number): number;
+    writeUInt32BE(value: number, offset?: number): number;
+    writeInt8(value: number, offset?: number): number;
+    writeInt16BE(value: number, offset?: number): number;
+    writeInt32BE(value: number, offset?: number): number;
+    writeUInt16LE(value: number, offset?: number): number;
+    writeUInt32LE(value: number, offset?: number): number;
+    writeInt16LE(value: number, offset?: number): number;
+    writeInt32LE(value: number, offset?: number): number;
+    indexOf(value: number | Uint8Array | string, byteOffset?: number, encoding?: string): number;
+    lastIndexOf(value: number | Uint8Array | string, byteOffset?: number, encoding?: string): number;
+    includes(value: number | Uint8Array | string, byteOffset?: number, encoding?: string): boolean;
+}
+export default Buffer;
+//# sourceMappingURL=buffer.d.ts.map

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

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

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

@@ -0,0 +1,331 @@
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+export class Buffer extends Uint8Array {
+    // Use overloaded signatures to satisfy Uint8Array's static from
+    static from(value, encodingOrMapFn, _thisArg) {
+        if (typeof value === 'string') {
+            const encoding = encodingOrMapFn;
+            if (encoding === 'base64') {
+                const binary = atob(value);
+                const buf = new Buffer(binary.length);
+                for (let i = 0; i < binary.length; i++)
+                    buf[i] = binary.charCodeAt(i);
+                return buf;
+            }
+            if (encoding === 'hex') {
+                const buf = new Buffer(value.length / 2);
+                for (let i = 0; i < value.length; i += 2) {
+                    buf[i / 2] = parseInt(value.substring(i, i + 2), 16);
+                }
+                return buf;
+            }
+            // utf-8 default
+            const bytes = encoder.encode(value);
+            const buf = new Buffer(bytes.length);
+            buf.set(bytes);
+            return buf;
+        }
+        if (value instanceof ArrayBuffer) {
+            const buf = new Buffer(value.byteLength);
+            buf.set(new Uint8Array(value));
+            return buf;
+        }
+        if (value instanceof Uint8Array) {
+            const buf = new Buffer(value.length);
+            buf.set(value);
+            return buf;
+        }
+        // ArrayLike<number> or number[]
+        const arr = value;
+        const buf = new Buffer(arr.length);
+        for (let i = 0; i < arr.length; i++)
+            buf[i] = arr[i];
+        return buf;
+    }
+    static alloc(size, fill) {
+        const buf = new Buffer(size);
+        if (fill !== undefined)
+            buf.fill(fill);
+        return buf;
+    }
+    static allocUnsafe(size) {
+        return new Buffer(size);
+    }
+    static isBuffer(obj) {
+        return obj instanceof Buffer;
+    }
+    static concat(list, totalLength) {
+        const len = totalLength ?? list.reduce((sum, b) => sum + b.length, 0);
+        const result = Buffer.alloc(len);
+        let offset = 0;
+        for (const buf of list) {
+            const slice = buf.subarray(0, Math.min(buf.length, len - offset));
+            result.set(slice, offset);
+            offset += slice.length;
+            if (offset >= len)
+                break;
+        }
+        return result;
+    }
+    static byteLength(str, encoding) {
+        if (encoding === 'base64') {
+            // Remove padding and compute
+            const cleaned = str.replace(/[^A-Za-z0-9+/]/g, '');
+            return Math.floor(cleaned.length * 3 / 4);
+        }
+        if (encoding === 'hex') {
+            return str.length / 2;
+        }
+        return encoder.encode(str).length;
+    }
+    toString(encoding, start, end) {
+        const slice = (start !== undefined || end !== undefined)
+            ? this.subarray(start ?? 0, end ?? this.length)
+            : this;
+        if (encoding === 'base64') {
+            let binary = '';
+            for (let i = 0; i < slice.length; i++)
+                binary += String.fromCharCode(slice[i]);
+            return btoa(binary);
+        }
+        if (encoding === 'hex') {
+            let hex = '';
+            for (let i = 0; i < slice.length; i++)
+                hex += slice[i].toString(16).padStart(2, '0');
+            return hex;
+        }
+        // utf-8 default
+        return decoder.decode(slice);
+    }
+    write(str, offset, length, encoding) {
+        const start = offset ?? 0;
+        const maxLen = length ?? this.length - start;
+        let bytes;
+        if (encoding === 'hex') {
+            // Each pair of hex chars = 1 byte
+            const byteLen = Math.min(Math.floor(str.length / 2), maxLen);
+            bytes = new Uint8Array(byteLen);
+            for (let i = 0; i < byteLen; i++) {
+                bytes[i] = parseInt(str.substring(i * 2, i * 2 + 2), 16);
+            }
+        }
+        else if (encoding === 'base64') {
+            const binary = atob(str);
+            const byteLen = Math.min(binary.length, maxLen);
+            bytes = new Uint8Array(byteLen);
+            for (let i = 0; i < byteLen; i++)
+                bytes[i] = binary.charCodeAt(i);
+        }
+        else {
+            bytes = encoder.encode(str);
+        }
+        const toWrite = Math.min(bytes.length, maxLen);
+        this.set(bytes.subarray(0, toWrite), start);
+        return toWrite;
+    }
+    toJSON() {
+        return { type: 'Buffer', data: Array.from(this) };
+    }
+    copy(target, targetStart = 0, sourceStart = 0, sourceEnd = this.length) {
+        const slice = this.subarray(sourceStart, sourceEnd);
+        const len = Math.min(slice.length, target.length - targetStart);
+        target.set(slice.subarray(0, len), targetStart);
+        return len;
+    }
+    equals(other) {
+        if (this.length !== other.length)
+            return false;
+        for (let i = 0; i < this.length; i++) {
+            if (this[i] !== other[i])
+                return false;
+        }
+        return true;
+    }
+    compare(other) {
+        const len = Math.min(this.length, other.length);
+        for (let i = 0; i < len; i++) {
+            if (this[i] < other[i])
+                return -1;
+            if (this[i] > other[i])
+                return 1;
+        }
+        if (this.length < other.length)
+            return -1;
+        if (this.length > other.length)
+            return 1;
+        return 0;
+    }
+    slice(start, end) {
+        const sliced = super.slice(start, end);
+        return Buffer.from(sliced);
+    }
+    subarray(start, end) {
+        const sub = super.subarray(start, end);
+        return Buffer.from(sub);
+    }
+    // ─── Integer read methods (big-endian) ───
+    readUInt8(offset = 0) {
+        return this[offset];
+    }
+    readUInt16BE(offset = 0) {
+        return (this[offset] << 8) | this[offset + 1];
+    }
+    readUInt32BE(offset = 0) {
+        return ((this[offset] * 0x1000000) +
+            ((this[offset + 1] << 16) |
+                (this[offset + 2] << 8) |
+                this[offset + 3]));
+    }
+    readInt8(offset = 0) {
+        const val = this[offset];
+        return val & 0x80 ? val - 0x100 : val;
+    }
+    readInt16BE(offset = 0) {
+        const val = (this[offset] << 8) | this[offset + 1];
+        return val & 0x8000 ? val - 0x10000 : val;
+    }
+    readInt32BE(offset = 0) {
+        return ((this[offset] << 24) |
+            (this[offset + 1] << 16) |
+            (this[offset + 2] << 8) |
+            this[offset + 3]);
+    }
+    // ─── Integer read methods (little-endian) ───
+    readUInt16LE(offset = 0) {
+        return this[offset] | (this[offset + 1] << 8);
+    }
+    readUInt32LE(offset = 0) {
+        return (this[offset] +
+            (this[offset + 1] << 8) +
+            (this[offset + 2] << 16) +
+            (this[offset + 3] * 0x1000000));
+    }
+    readInt16LE(offset = 0) {
+        const val = this[offset] | (this[offset + 1] << 8);
+        return val & 0x8000 ? val - 0x10000 : val;
+    }
+    readInt32LE(offset = 0) {
+        return (this[offset] |
+            (this[offset + 1] << 8) |
+            (this[offset + 2] << 16) |
+            (this[offset + 3] << 24));
+    }
+    // ─── Integer write methods (big-endian) ───
+    writeUInt8(value, offset = 0) {
+        this[offset] = value & 0xff;
+        return offset + 1;
+    }
+    writeUInt16BE(value, offset = 0) {
+        this[offset] = (value >>> 8) & 0xff;
+        this[offset + 1] = value & 0xff;
+        return offset + 2;
+    }
+    writeUInt32BE(value, offset = 0) {
+        this[offset] = (value >>> 24) & 0xff;
+        this[offset + 1] = (value >>> 16) & 0xff;
+        this[offset + 2] = (value >>> 8) & 0xff;
+        this[offset + 3] = value & 0xff;
+        return offset + 4;
+    }
+    writeInt8(value, offset = 0) {
+        this[offset] = value & 0xff;
+        return offset + 1;
+    }
+    writeInt16BE(value, offset = 0) {
+        this[offset] = (value >>> 8) & 0xff;
+        this[offset + 1] = value & 0xff;
+        return offset + 2;
+    }
+    writeInt32BE(value, offset = 0) {
+        this[offset] = (value >>> 24) & 0xff;
+        this[offset + 1] = (value >>> 16) & 0xff;
+        this[offset + 2] = (value >>> 8) & 0xff;
+        this[offset + 3] = value & 0xff;
+        return offset + 4;
+    }
+    // ─── Integer write methods (little-endian) ───
+    writeUInt16LE(value, offset = 0) {
+        this[offset] = value & 0xff;
+        this[offset + 1] = (value >>> 8) & 0xff;
+        return offset + 2;
+    }
+    writeUInt32LE(value, offset = 0) {
+        this[offset] = value & 0xff;
+        this[offset + 1] = (value >>> 8) & 0xff;
+        this[offset + 2] = (value >>> 16) & 0xff;
+        this[offset + 3] = (value >>> 24) & 0xff;
+        return offset + 4;
+    }
+    writeInt16LE(value, offset = 0) {
+        this[offset] = value & 0xff;
+        this[offset + 1] = (value >>> 8) & 0xff;
+        return offset + 2;
+    }
+    writeInt32LE(value, offset = 0) {
+        this[offset] = value & 0xff;
+        this[offset + 1] = (value >>> 8) & 0xff;
+        this[offset + 2] = (value >>> 16) & 0xff;
+        this[offset + 3] = (value >>> 24) & 0xff;
+        return offset + 4;
+    }
+    // ─── Search methods ───
+    indexOf(value, byteOffset, encoding) {
+        const start = byteOffset ?? 0;
+        if (typeof value === 'number') {
+            for (let i = start; i < this.length; i++) {
+                if (this[i] === value)
+                    return i;
+            }
+            return -1;
+        }
+        const needle = typeof value === 'string'
+            ? Buffer.from(value, encoding)
+            : value;
+        if (needle.length === 0)
+            return start;
+        for (let i = start; i <= this.length - needle.length; i++) {
+            let match = true;
+            for (let j = 0; j < needle.length; j++) {
+                if (this[i + j] !== needle[j]) {
+                    match = false;
+                    break;
+                }
+            }
+            if (match)
+                return i;
+        }
+        return -1;
+    }
+    lastIndexOf(value, byteOffset, encoding) {
+        if (typeof value === 'number') {
+            const start = byteOffset ?? this.length - 1;
+            for (let i = start; i >= 0; i--) {
+                if (this[i] === value)
+                    return i;
+            }
+            return -1;
+        }
+        const needle = typeof value === 'string'
+            ? Buffer.from(value, encoding)
+            : value;
+        if (needle.length === 0)
+            return byteOffset ?? this.length;
+        const start = byteOffset != null ? Math.min(byteOffset, this.length - needle.length) : this.length - needle.length;
+        for (let i = start; i >= 0; i--) {
+            let match = true;
+            for (let j = 0; j < needle.length; j++) {
+                if (this[i + j] !== needle[j]) {
+                    match = false;
+                    break;
+                }
+            }
+            if (match)
+                return i;
+        }
+        return -1;
+    }
+    includes(value, byteOffset, encoding) {
+        return this.indexOf(value, byteOffset, encoding) !== -1;
+    }
+}
+export default Buffer;

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

@@ -0,0 +1,10 @@
+import { EventEmitter } from './events.js';
+type ExecuteCapture = (input: string) => Promise<string>;
+export declare function createChildProcess(executeCapture?: ExecuteCapture): {
+    exec: (cmd: string, optionsOrCb?: Record<string, unknown> | ((err: Error | null, stdout: string, stderr: string) => void), cb?: (err: Error | null, stdout: string, stderr: string) => void) => EventEmitter;
+    execSync: () => never;
+    spawn: () => never;
+    fork: () => never;
+};
+export {};
+//# sourceMappingURL=child_process.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"child_process.d.ts","sourceRoot":"","sources":["../../../../src/substrate/lifo/node-compat/child_process.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAE3C,KAAK,cAAc,GAAG,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;AAEzD,wBAAgB,kBAAkB,CAAC,cAAc,CAAC,EAAE,cAAc;gBAEzD,MAAM,gBACG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,KAAK,GAAG,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC,OAChG,CAAC,GAAG,EAAE,KAAK,GAAG,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,IAAI,KAC/D,YAAY;oBA6BM,KAAK;iBAIR,KAAK;gBAIN,KAAK;EAKvB"}

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

@@ -0,0 +1,42 @@
+import { EventEmitter } from './events.js';
+export function createChildProcess(executeCapture) {
+    function exec(cmd, optionsOrCb, cb) {
+        const callback = typeof optionsOrCb === 'function' ? optionsOrCb : cb;
+        const child = new EventEmitter();
+        if (!executeCapture) {
+            queueMicrotask(() => {
+                const err = new Error('child_process.exec() requires shell interpreter');
+                if (callback)
+                    callback(err, '', '');
+                child.emit('error', err);
+            });
+            return child;
+        }
+        const run = executeCapture;
+        queueMicrotask(async () => {
+            try {
+                const output = await run(cmd);
+                if (callback)
+                    callback(null, output, '');
+                child.emit('close', 0);
+            }
+            catch (e) {
+                const err = e instanceof Error ? e : new Error(String(e));
+                if (callback)
+                    callback(err, '', err.message);
+                child.emit('close', 1);
+            }
+        });
+        return child;
+    }
+    function execSync() {
+        throw new Error('child_process.execSync() is not supported in Lifo');
+    }
+    function spawn() {
+        throw new Error('child_process.spawn() is not supported in Lifo');
+    }
+    function fork() {
+        throw new Error('child_process.fork() is not supported in Lifo');
+    }
+    return { exec, execSync, spawn, fork };
+}

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

@@ -0,0 +1,21 @@
+import type { CommandOutputStream } from '../commands/types.js';
+export declare function createConsole(stdout: CommandOutputStream, stderr: CommandOutputStream): {
+    log: (...args: unknown[]) => void;
+    info: (...args: unknown[]) => void;
+    warn: (...args: unknown[]) => void;
+    error: (...args: unknown[]) => void;
+    debug: (...args: unknown[]) => void;
+    dir: (obj: unknown) => void;
+    time: (label?: string) => void;
+    timeEnd: (label?: string) => void;
+    timeLog: (label?: string, ...args: unknown[]) => void;
+    trace: (...args: unknown[]) => void;
+    assert: (condition: unknown, ...args: unknown[]) => void;
+    clear: () => void;
+    count: (label?: string) => void;
+    countReset: () => void;
+    group: () => void;
+    groupEnd: () => void;
+    table: (data: unknown) => void;
+};
+//# sourceMappingURL=console.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"console.d.ts","sourceRoot":"","sources":["../../../../src/substrate/lifo/node-compat/console.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAGhE,wBAAgB,aAAa,CAAC,MAAM,EAAE,mBAAmB,EAAE,MAAM,EAAE,mBAAmB;mBAInE,OAAO,EAAE;oBAGR,OAAO,EAAE;oBAGT,OAAO,EAAE;qBAGR,OAAO,EAAE;qBAGT,OAAO,EAAE;eAGf,OAAO;;;uCAgBoB,OAAO,EAAE;qBAO9B,OAAO,EAAE;wBAGN,OAAO,WAAW,OAAO,EAAE;;;;;;kBAiBjC,OAAO;EAIxB"}

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

@@ -0,0 +1,68 @@
+import { format } from './util.js';
+export function createConsole(stdout, stderr) {
+    const timers = new Map();
+    return {
+        log: (...args) => {
+            stdout.write(format(args[0], ...args.slice(1)) + '\n');
+        },
+        info: (...args) => {
+            stdout.write(format(args[0], ...args.slice(1)) + '\n');
+        },
+        warn: (...args) => {
+            stderr.write(format(args[0], ...args.slice(1)) + '\n');
+        },
+        error: (...args) => {
+            stderr.write(format(args[0], ...args.slice(1)) + '\n');
+        },
+        debug: (...args) => {
+            stdout.write(format(args[0], ...args.slice(1)) + '\n');
+        },
+        dir: (obj) => {
+            stdout.write(format('%o', obj) + '\n');
+        },
+        time: (label = 'default') => {
+            timers.set(label, performance.now());
+        },
+        timeEnd: (label = 'default') => {
+            const start = timers.get(label);
+            if (start !== undefined) {
+                const elapsed = performance.now() - start;
+                stdout.write(`${label}: ${elapsed.toFixed(3)}ms\n`);
+                timers.delete(label);
+            }
+            else {
+                stderr.write(`Warning: No such label '${label}' for console.timeEnd()\n`);
+            }
+        },
+        timeLog: (label = 'default', ...args) => {
+            const start = timers.get(label);
+            if (start !== undefined) {
+                const elapsed = performance.now() - start;
+                stdout.write(`${label}: ${elapsed.toFixed(3)}ms ${args.map((a) => format('%o', a)).join(' ')}\n`);
+            }
+        },
+        trace: (...args) => {
+            stderr.write('Trace: ' + format(args[0], ...args.slice(1)) + '\n');
+        },
+        assert: (condition, ...args) => {
+            if (!condition) {
+                stderr.write('Assertion failed: ' + (args.length > 0 ? format(args[0], ...args.slice(1)) : '') + '\n');
+            }
+        },
+        clear: () => { },
+        count: (() => {
+            const counts = new Map();
+            return (label = 'default') => {
+                const count = (counts.get(label) ?? 0) + 1;
+                counts.set(label, count);
+                stdout.write(`${label}: ${count}\n`);
+            };
+        })(),
+        countReset: () => { },
+        group: () => { },
+        groupEnd: () => { },
+        table: (data) => {
+            stdout.write(format('%o', data) + '\n');
+        },
+    };
+}

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

@@ -0,0 +1,24 @@
+import { Buffer } from './buffer.js';
+export declare function randomBytes(size: number): Buffer;
+export declare function randomUUID(): string;
+interface HashObject {
+    update(data: string | Uint8Array): HashObject;
+    digest(encoding?: string): string | Buffer;
+}
+export declare function createHash(algorithm: string): HashObject;
+export declare function randomInt(min: number, max?: number): number;
+export declare function getRandomValues<T extends ArrayBufferView>(array: T): T;
+export declare const subtle: SubtleCrypto;
+/** Node.js 21+ one-shot sync hash: crypto.hash(algo, data, encoding) */
+export declare function hash(algorithm: string, data: string | Uint8Array, outputEncoding?: string): string;
+declare const _default: {
+    randomBytes: typeof randomBytes;
+    randomUUID: typeof randomUUID;
+    createHash: typeof createHash;
+    randomInt: typeof randomInt;
+    getRandomValues: typeof getRandomValues;
+    subtle: SubtleCrypto;
+    hash: typeof hash;
+};
+export default _default;
+//# sourceMappingURL=crypto.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"crypto.d.ts","sourceRoot":"","sources":["../../../../src/substrate/lifo/node-compat/crypto.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAErC,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAIhD;AAED,wBAAgB,UAAU,IAAI,MAAM,CAEnC;AAED,UAAU,UAAU;IAClB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,GAAG,UAAU,CAAC;IAC9C,MAAM,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC;CAC5C;AAED,wBAAgB,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,UAAU,CAkCxD;AAED,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CAS3D;AAGD,wBAAgB,eAAe,CAAC,CAAC,SAAS,eAAe,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,CAItE;AAED,eAAO,MAAM,MAAM,cAAgB,CAAC;AAqGpC,wEAAwE;AACxE,wBAAgB,IAAI,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,UAAU,EAAE,cAAc,GAAE,MAAc,GAAG,MAAM,CAUzG;;;;;;;;;;AAED,wBAAiG"}