@poe-platform/safe-bash 0.1.803 → 0.1.804

package/dist/safe-bash-line-ending-engine/encoding.js

@@ -1,42 +1,9 @@
-export const encodingLabels = { bytes: "no_bom", le: "UTF-16LE", be: "UTF-16BE", utf8: "UTF-8", gb: "GB18030" };
-export async function readEncoding(reader) {
-    const prefix = [];
-    let bom = "bytes", error = false;
-    const first = await reader.get();
-    if (first !== -1) {
-        if (first !== 0xff && first !== 0xfe && first !== 0xef && first !== 0x84)
-            prefix.push(first);
-        else {
-            const second = await reader.get();
-            if (second === -1)
-                error = true;
-            else if (first === 0xff && second === 0xfe)
-                bom = "le";
-            else if (first === 0xfe && second === 0xff)
-                bom = "be";
-            else {
-                const third = await reader.get();
-                if (third === -1)
-                    error = true;
-                else if (first === 0xef && second === 0xbb && third === 0xbf)
-                    bom = "utf8";
-                else {
-                    prefix.push(first, second, third);
-                    if (first === 0x84 && second === 0x31 && third === 0x95) {
-                        const fourth = await reader.get();
-                        if (fourth === -1)
-                            error = true;
-                        else if (fourth === 0x33) {
-                            bom = "gb";
-                            prefix.length = 0;
-                        }
-                        else
-                            prefix.push(fourth);
-                    }
-                }
-            }
-        }
-    }
-    let offset = 0;
-    return { bom, error, byte: () => offset < prefix.length ? prefix[offset++] : reader.get() };
-}
+import {
+  encodingLabels,
+  readEncoding
+} from "../safe-bash/command-chunks/chunk-TFR6B3WB.js";
+import "../safe-bash/command-chunks/chunk-HX3SHTCE.js";
+export {
+  encodingLabels,
+  readEncoding
+};

package/dist/safe-bash-line-ending-engine/index.js

@@ -0,0 +1,48 @@
+import {
+  convert
+} from "../safe-bash/command-chunks/chunk-NGL7YK7O.js";
+import {
+  FileInformation
+} from "../safe-bash/command-chunks/chunk-LU4HBPP2.js";
+import {
+  encodingLabels,
+  readEncoding
+} from "../safe-bash/command-chunks/chunk-TFR6B3WB.js";
+import {
+  Lifecycle,
+  Reader,
+  Writer
+} from "../safe-bash/command-chunks/chunk-Y22VXJBD.js";
+import {
+  Files,
+  Stage
+} from "../safe-bash/command-chunks/chunk-MQREDAL6.js";
+import {
+  Budget,
+  LineEndingError,
+  missing,
+  sameIdentity,
+  settings
+} from "../safe-bash/command-chunks/chunk-TOH3OF3O.js";
+import {
+  init_buffer
+} from "../safe-bash/command-chunks/chunk-HX3SHTCE.js";
+
+// packages/safe-bash-line-ending-engine/src/index.ts
+init_buffer();
+export {
+  Budget,
+  FileInformation,
+  Files,
+  Lifecycle,
+  LineEndingError,
+  Reader,
+  Stage,
+  Writer,
+  convert,
+  encodingLabels,
+  missing,
+  readEncoding,
+  sameIdentity,
+  settings
+};

package/dist/safe-bash-line-ending-engine/info.js

@@ -1,90 +1,9 @@
-import { LineEndingError } from "./internal.js";
-import { encodingLabels, readEncoding } from "./encoding.js";
-export class FileInformation {
-    life;
-    flags = new Set();
-    headerDone = false;
-    constructor(life) {
-        this.life = life;
-    }
-    configure(value) {
-        for (const flag of value) {
-            if (!"0dumbtechp".includes(flag))
-                throw new LineEndingError(`wrong flag '${flag}' for option -i or --info`);
-            this.flags.add(flag);
-        }
-        if (![...value].some(flag => "dumbtec".includes(flag)))
-            for (const flag of "dumbt")
-                this.flags.add(flag);
-    }
-    async print(direction, reader, options, filename) {
-        if (options.verbose && options.assume !== "bytes")
-            await this.life.diagnostic(`${direction}: Assuming UTF-16${options.assume === "le" ? "LE" : "BE"} encoding.\n`);
-        const input = await readEncoding(reader);
-        if (input.error) {
-            if (!options.quiet)
-                await this.life.diagnostic(`${direction}: can not read from input file: Success\n`);
-            return;
-        }
-        const bom = encodingLabels[input.bom];
-        const encoding = input.bom === "bytes" ? options.assume : input.bom === "le" || input.bom === "be" ? input.bom : "bytes";
-        const byte = input.byte;
-        let dos = 0, unix = 0, mac = 0, previous = -1, last = "noeol", binary = false;
-        for (;;) {
-            const b1 = byte();
-            let current = typeof b1 === "number" ? b1 : await b1;
-            if (current === -1)
-                break;
-            if (encoding !== "bytes") {
-                const b2 = byte();
-                const trail = typeof b2 === "number" ? b2 : await b2;
-                if (trail === -1)
-                    break;
-                current = encoding === "le" ? current + trail * 256 : current * 256 + trail;
-            }
-            if (current < 32 && ![9, 10, 12, 13].includes(current))
-                binary = true;
-            if (current === 13) {
-                mac++;
-                last = "mac";
-            }
-            else if (current === 10 && previous === 13) {
-                dos++;
-                mac--;
-                last = "dos";
-            }
-            else if (current === 10) {
-                unix++;
-                last = "unix";
-            }
-            else
-                last = "noeol";
-            previous = current;
-        }
-        const flags = this.flags;
-        if (flags.has("c") && (binary && !options.force || (direction === "dos2unix" ? dos : unix) === 0 && (!options.addEol || last === (direction === "dos2unix" ? "unix" : "dos"))))
-            return;
-        const eol = flags.has("e") || options.addEol && !flags.has("c");
-        const fields = ["d", "u", "m", "b", "t", "e"].filter(flag => flag === "e" ? eol : flags.has(flag));
-        const separator = fields.length ? "  " : "";
-        const terminator = flags.has("0") ? "\0" : "\n";
-        if (flags.has("p"))
-            filename = filename.slice(Math.max(filename.lastIndexOf("/"), filename.lastIndexOf("\\")) + 1);
-        let text = "";
-        if (flags.has("h") && !this.headerDone) {
-            const labels = { d: "     DOS", u: "    UNIX", m: "     MAC", b: "  BOM     ", t: "  TXTBIN", e: " LASTLN" };
-            text += fields.map(field => labels[field]).join("") + (filename ? `${separator}FILE` : "") + terminator;
-            this.headerDone = true;
-        }
-        const values = {
-            d: `  ${String(dos).padStart(6)}`, u: `  ${String(unix).padStart(6)}`, m: `  ${String(mac).padStart(6)}`,
-            b: `  ${bom.padEnd(8)}`, t: binary ? "  binary" : "  text  ", e: ` ${last.padEnd(5)} `,
-        };
-        text += fields.map(field => values[field]).join("") + (filename ? separator + filename : "") + terminator;
-        const budget = this.life.budget;
-        budget.check(text.length * 3, budget.limits.maxBufferedBytes, "information buffer bytes");
-        const bytes = new TextEncoder().encode(text);
-        budget.emitted(bytes.length);
-        await this.life.stdout(bytes);
-    }
-}
+import {
+  FileInformation
+} from "../safe-bash/command-chunks/chunk-LU4HBPP2.js";
+import "../safe-bash/command-chunks/chunk-TFR6B3WB.js";
+import "../safe-bash/command-chunks/chunk-TOH3OF3O.js";
+import "../safe-bash/command-chunks/chunk-HX3SHTCE.js";
+export {
+  FileInformation
+};

package/dist/safe-bash-line-ending-engine/internal.js

@@ -1,160 +1,15 @@
-import { getCommandArguments } from "../safe-bash-contracts/index.js";
-import { shellValueByteLength, shellValueBytes } from "../safe-bash-contracts/value.js";
-import { yieldTurn } from "../safe-bash-contracts/yield.js";
-import { PublicDiagnostic } from "../safe-bash-contracts/diagnostics.js";
-export function settings(options) {
-    const limits = {
-        maxArguments: Infinity, maxArgumentBytes: Infinity, maxInputBytes: Infinity, maxOutputBytes: Infinity,
-        maxBufferedBytes: Infinity, maxDiagnosticBytes: Infinity, maxFiles: Infinity, maxWork: Infinity,
-        maxEmptyChunks: Infinity, maxPathBytes: Infinity, maxDepth: Infinity, maxTempAttempts: Infinity, chunkSize: 16_384,
-        ...options.limits,
-    };
-    for (const [name, value] of Object.entries(options.limits ?? {}))
-        if (value !== Infinity && (!Number.isSafeInteger(value) || value < 1))
-            throw new RangeError(`Invalid line-ending limit: ${name}`);
-    return Object.freeze(limits);
-}
-export class LineEndingError extends PublicDiagnostic {
-    status;
-    constructor(message, status = 1) {
-        super(message);
-        this.status = status;
-    }
-}
-export class Budget {
-    context;
-    limits;
-    signal;
-    caller;
-    admission;
-    work = 0;
-    quantum = 0;
-    memory = 0;
-    input = 0;
-    output = 0;
-    diagnostics = 0;
-    files = 0;
-    signalAborted;
-    pollSignal;
-    constructor(context, limits, signal, caller, admission) {
-        this.context = context;
-        this.limits = limits;
-        this.signal = signal;
-        this.caller = caller;
-        this.admission = admission;
-        this.signalAborted = signal.aborted;
-        this.pollSignal = Object.prototype.hasOwnProperty.call(signal, "aborted");
-        if (!this.signalAborted && !this.pollSignal) {
-            signal.addEventListener("abort", () => { this.signalAborted = true; }, { once: true });
-        }
-    }
-    assertOpen() {
-        if (this.pollSignal ? this.signal.aborted : this.signalAborted)
-            this.signal.throwIfAborted();
-        if (this.admission.closed)
-            throw new LineEndingError("command is closed");
-    }
-    check(value, maximum, label) {
-        if (value > maximum || value < 0 || ((value | 0) !== value && !Number.isSafeInteger(value)))
-            throw new LineEndingError(`${label} limit exceeded`);
-    }
-    retain(amount) { this.check(this.memory + amount, this.limits.maxBufferedBytes, "buffered bytes"); this.memory += amount; }
-    incoming(amount) { this.check(this.input + amount, this.limits.maxInputBytes, "input bytes"); this.input += amount; }
-    emitted(amount, diagnostic = false) {
-        if (diagnostic) {
-            this.check(this.diagnostics + amount, this.limits.maxDiagnosticBytes, "diagnostic bytes");
-            this.diagnostics += amount;
-        }
-        else {
-            this.check(this.output + amount, this.limits.maxOutputBytes, "output bytes");
-            this.output += amount;
-        }
-    }
-    file() { this.check(++this.files, this.limits.maxFiles, "file count"); }
-    step(amount = 1) {
-        this.assertOpen();
-        this.check(this.work + amount, this.limits.maxWork, "work");
-        this.work += amount;
-        this.quantum += amount;
-        if (this.quantum < 1024)
-            return;
-        this.quantum = 0;
-        return yieldTurn(this.caller).then(() => {
-            this.assertOpen();
-        });
-    }
-    async arguments() {
-        const args = this.context.args;
-        this.assertOpen();
-        const count = args.length;
-        this.assertOpen();
-        this.check(count, this.limits.maxArguments, "argument count");
-        const argumentValues = this.context.argumentValues;
-        this.assertOpen();
-        const carrier = argumentValues === undefined ? undefined : getCommandArguments({ args, argumentValues });
-        const snapshot = [];
-        this.retain(count * 64);
-        let total = 0;
-        for (let index = 0; index < count; index++) {
-            const argument = args[index];
-            this.assertOpen();
-            if (typeof argument !== "string")
-                throw new LineEndingError("arguments must be strings");
-            this.check(argument.length, this.limits.maxPathBytes, "argument bytes");
-            total += argument.length;
-            this.check(total, this.limits.maxArgumentBytes, "argument bytes");
-            this.retain(argument.length * 12);
-            snapshot.push(argument);
-        }
-        for (const argument of snapshot) {
-            for (let index = 0; index < argument.length; index++) {
-                {
-                    const s = this.step();
-                    if (s)
-                        await s;
-                }
-                const unit = argument.charCodeAt(index);
-                if (unit >= 0xd800 && unit <= 0xdbff) {
-                    const next = argument.charCodeAt(++index);
-                    if (!(next >= 0xdc00 && next <= 0xdfff))
-                        throw new LineEndingError("arguments must be valid UTF-8 paths");
-                }
-                else if (unit >= 0xdc00 && unit <= 0xdfff)
-                    throw new LineEndingError("arguments must be valid UTF-8 paths");
-            }
-        }
-        const values = (carrier ?? getCommandArguments({ args: snapshot })).values;
-        total = 0;
-        for (const value of values) {
-            const length = shellValueByteLength(value);
-            this.check(length, this.limits.maxPathBytes, "argument bytes");
-            total += length;
-            this.check(total, this.limits.maxArgumentBytes, "argument bytes");
-        }
-        const result = [];
-        for (const value of values) {
-            {
-                const s = this.step(shellValueByteLength(value));
-                if (s)
-                    await s;
-            }
-            let text;
-            try {
-                text = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(shellValueBytes(value));
-            }
-            catch {
-                throw new LineEndingError("arguments must be valid UTF-8 paths");
-            }
-            if (text.includes("\0"))
-                throw new LineEndingError("NUL is not supported in paths");
-            result.push(text);
-        }
-        return result;
-    }
-}
-export function sameIdentity(first, second) {
-    return ((typeof first.identityScope === "object" && first.identityScope !== null) || typeof first.identityScope === "symbol")
-        && first.identityScope === second.identityScope && Number.isSafeInteger(first.dev) && Number.isSafeInteger(first.ino)
-        && first.dev >= 0 && first.ino >= 0 && first.dev === second.dev && first.ino === second.ino;
-}
-export function missing(error) { return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT"; }
+import {
+  Budget,
+  LineEndingError,
+  missing,
+  sameIdentity,
+  settings
+} from "../safe-bash/command-chunks/chunk-TOH3OF3O.js";
+import "../safe-bash/command-chunks/chunk-HX3SHTCE.js";
+export {
+  Budget,
+  LineEndingError,
+  missing,
+  sameIdentity,
+  settings
+};

package/dist/safe-bash-line-ending-engine/io.js

@@ -1,289 +1,12 @@
-import { LineEndingError } from "./internal.js";
-const typedArrayPrototype = Object.getPrototypeOf(Uint8Array.prototype);
-const viewBuffer = Object.getOwnPropertyDescriptor(typedArrayPrototype, "buffer").get;
-const viewOffset = Object.getOwnPropertyDescriptor(typedArrayPrototype, "byteOffset").get;
-const viewLength = Object.getOwnPropertyDescriptor(typedArrayPrototype, "byteLength").get;
-export class Lifecycle {
-    budget;
-    captured;
-    caller;
-    admission;
-    pending = new Set();
-    cleanups = [];
-    closing;
-    diagnosticDestination;
-    diagnosticCancellation;
-    constructor(budget, output, captured, caller, admission) {
-        this.budget = budget;
-        this.captured = captured;
-        this.caller = caller;
-        this.admission = admission;
-        output.registerCleanup(() => this.close());
-    }
-    assertOpen() { this.budget.assertOpen(); if (this.closing)
-        throw new LineEndingError("command is closed"); }
-    assertDiagnosticOpen() {
-        this.caller.throwIfAborted();
-        const consumer = this.diagnosticDestination?.consumer;
-        if (consumer?.aborted) {
-            this.diagnosticCancellation = { reason: consumer.reason };
-            consumer.throwIfAborted();
-        }
-    }
-    cleanup(action) { this.assertOpen(); this.cleanups.push(action); }
-    async operation(action) {
-        this.assertOpen();
-        const pending = Promise.resolve().then(async () => { {
-            const s = this.budget.step();
-            if (s)
-                await s;
-        } this.assertOpen(); return action(); });
-        this.pending.add(pending);
-        try {
-            const value = await pending;
-            this.assertOpen();
-            return value;
-        }
-        finally {
-            this.pending.delete(pending);
-        }
-    }
-    close() {
-        return this.closing ??= Promise.resolve().then(async () => {
-            while (this.pending.size)
-                await Promise.allSettled([...this.pending]);
-            const failures = [];
-            for (const close of this.cleanups) {
-                try {
-                    await close();
-                }
-                catch (error) {
-                    failures.push(error);
-                }
-            }
-            if (failures.length === 1)
-                throw failures[0];
-            if (failures.length > 1)
-                throw new AggregateError(failures, "line-ending cleanup failed");
-        });
-    }
-    async stdout(bytes) {
-        await this.operation(async () => {
-            const write = this.captured.write;
-            this.assertOpen();
-            await Reflect.apply(write, this.captured, [bytes]);
-        });
-    }
-    async diagnostic(text) {
-        this.assertDiagnosticOpen();
-        if (this.closing || this.admission.closed)
-            throw new LineEndingError("command is closed");
-        this.budget.check(text.length * 3, this.budget.limits.maxDiagnosticBytes, "diagnostic buffer bytes");
-        const bytes = new TextEncoder().encode(text);
-        this.budget.emitted(bytes.length, true);
-        const pending = Promise.resolve().then(async () => {
-            this.assertDiagnosticOpen();
-            if (!this.diagnosticDestination) {
-                const sink = this.budget.context.stderr;
-                this.assertDiagnosticOpen();
-                const capability = sink.ownedOutput;
-                this.assertDiagnosticOpen();
-                const consumer = capability?.consumerClosed;
-                this.diagnosticDestination = { destination: capability ?? sink, consumer };
-            }
-            this.assertDiagnosticOpen();
-            const destination = this.diagnosticDestination.destination;
-            const write = destination.write;
-            this.assertDiagnosticOpen();
-            await Reflect.apply(write, destination, [bytes]);
-        });
-        this.pending.add(pending);
-        try {
-            await pending;
-            this.assertDiagnosticOpen();
-        }
-        finally {
-            this.pending.delete(pending);
-        }
-    }
-}
-export class Reader {
-    life;
-    iterator;
-    chunk = new Uint8Array();
-    offset = 0;
-    ended = false;
-    empties = 0;
-    snapshotBytes = 0;
-    closing;
-    constructor(life) {
-        this.life = life;
-        life.cleanup(() => this.close());
-    }
-    close() {
-        return this.closing ??= (async () => {
-            try {
-                if (!this.ended && this.iterator) {
-                    const iterator = this.iterator;
-                    const close = iterator.return;
-                    if (close)
-                        await Reflect.apply(close, iterator, []);
-                }
-            }
-            finally {
-                this.iterator = undefined;
-                this.life.budget.retain(-this.chunk.length - this.snapshotBytes);
-                this.chunk = new Uint8Array();
-                this.snapshotBytes = 0;
-            }
-        })();
-    }
-    async open(path, stat) {
-        const { context, signal, limits } = this.life.budget;
-        await this.life.operation(async () => {
-            let source;
-            let acquisitionAborted = false;
-            if (path === undefined)
-                source = context.stdin;
-            else {
-                const fs = context.fs;
-                const capabilitiesFor = fs.capabilitiesFor;
-                this.life.assertOpen();
-                const selected = capabilitiesFor ? await Reflect.apply(capabilitiesFor, fs, [path, { signal }]) : undefined;
-                this.life.assertOpen();
-                const capabilities = selected ?? fs.capabilities;
-                this.life.assertOpen();
-                const readStream = fs.readStream;
-                this.life.assertOpen();
-                const streaming = capabilities.streamingRead !== false;
-                this.life.assertOpen();
-                if (readStream && streaming) {
-                    source = Reflect.apply(readStream, fs, [path, { signal, chunkSize: limits.chunkSize === Infinity ? 16_384 : limits.chunkSize }]);
-                    acquisitionAborted = signal.aborted || this.life.admission.closed;
-                }
-                else {
-                    const maximum = Math.min(limits.maxInputBytes, Math.floor(limits.maxBufferedBytes / 3));
-                    const size = stat.size;
-                    this.life.assertOpen();
-                    this.life.budget.check(size, maximum, "buffered input bytes");
-                    this.life.budget.retain(Number.isFinite(maximum) ? maximum : size);
-                    this.snapshotBytes = Number.isFinite(maximum) ? maximum : size;
-                    const readFile = fs.readFile;
-                    this.life.assertOpen();
-                    const bytes = await Reflect.apply(readFile, fs, [path, { signal, ...(Number.isFinite(maximum) ? { maxBytes: maximum } : {}) }]);
-                    this.life.assertOpen();
-                    if (!(bytes instanceof Uint8Array))
-                        throw new TypeError("line-ending input requires bytes");
-                    this.life.budget.check(viewLength.call(bytes), maximum, "buffered input bytes");
-                    this.life.budget.retain(viewLength.call(bytes) - this.snapshotBytes);
-                    this.snapshotBytes = viewLength.call(bytes);
-                    source = { [Symbol.asyncIterator]: (async function* () { try {
-                            yield bytes;
-                        }
-                        finally {
-                            this.life.budget.retain(-this.snapshotBytes);
-                            this.snapshotBytes = 0;
-                        } }).bind(this) };
-                }
-            }
-            if (!acquisitionAborted)
-                this.life.assertOpen();
-            const factory = source[Symbol.asyncIterator];
-            if (!acquisitionAborted)
-                this.life.assertOpen();
-            this.iterator = Reflect.apply(factory, source, []);
-        });
-    }
-    get() {
-        const step = this.life.budget.step();
-        if (!step && this.offset < this.chunk.length) {
-            this.life.assertOpen();
-            return this.chunk[this.offset++];
-        }
-        return this.getSlow(step);
-    }
-    beforeRead;
-    async getSlow(step) {
-        if (step)
-            await step;
-        this.life.assertOpen();
-        while (this.offset === this.chunk.length) {
-            if (this.ended)
-                return -1;
-            await this.beforeRead?.();
-            const next = await this.life.operation(() => {
-                const iterator = this.iterator;
-                const advance = iterator.next;
-                this.life.assertOpen();
-                return Reflect.apply(advance, iterator, []);
-            });
-            this.life.budget.retain(-this.chunk.length);
-            this.chunk = new Uint8Array();
-            this.offset = 0;
-            const done = next.done;
-            this.life.assertOpen();
-            if (done) {
-                this.ended = true;
-                this.iterator = undefined;
-                return -1;
-            }
-            const value = next.value;
-            this.life.assertOpen();
-            if (!(value instanceof Uint8Array))
-                throw new TypeError("line-ending input requires bytes");
-            const buffer = viewBuffer.call(value);
-            const offset = viewOffset.call(value);
-            const length = viewLength.call(value);
-            this.life.budget.incoming(length);
-            this.life.budget.retain(length);
-            try {
-                if (viewOffset.call(value) !== offset || viewLength.call(value) < length)
-                    throw new TypeError("line-ending input extent changed during admission");
-                this.chunk = new Uint8Array(new Uint8Array(buffer, offset, length));
-            }
-            catch (error) {
-                this.life.budget.retain(-length);
-                throw error;
-            }
-            if (!this.chunk.length)
-                this.life.budget.check(++this.empties, this.life.budget.limits.maxEmptyChunks, "empty input chunks");
-        }
-        return this.chunk[this.offset++];
-    }
-}
-export class Writer {
-    life;
-    publish;
-    buffer;
-    used = 0;
-    constructor(life, publish) {
-        this.life = life;
-        this.publish = publish;
-        const { chunkSize, maxBufferedBytes } = life.budget.limits;
-        const size = Math.min(chunkSize === Infinity ? 16_384 : chunkSize, maxBufferedBytes);
-        life.budget.retain(size);
-        this.buffer = new Uint8Array(size);
-        life.cleanup(async () => { this.release(); });
-    }
-    release() { this.life.budget.retain(-this.buffer.length); this.buffer = new Uint8Array(); this.used = 0; }
-    put(byte) {
-        const step = this.life.budget.step();
-        if (step)
-            return step.then(() => this.putAfterStep(byte));
-        return this.putAfterStep(byte);
-    }
-    putAfterStep(byte) {
-        this.life.assertOpen();
-        this.life.budget.emitted(1);
-        this.buffer[this.used++] = byte;
-        if (this.used === this.buffer.length)
-            return this.flush();
-    }
-    async flush() {
-        this.life.assertOpen();
-        if (this.used) {
-            await this.publish(this.buffer.slice(0, this.used));
-            this.used = 0;
-        }
-    }
-}
+import {
+  Lifecycle,
+  Reader,
+  Writer
+} from "../safe-bash/command-chunks/chunk-Y22VXJBD.js";
+import "../safe-bash/command-chunks/chunk-TOH3OF3O.js";
+import "../safe-bash/command-chunks/chunk-HX3SHTCE.js";
+export {
+  Lifecycle,
+  Reader,
+  Writer
+};