@poe-platform/safe-bash 0.1.788 → 0.1.790

package/dist/safe-bash/opt-in/commands/cmp/io.js

@@ -1,218 +0,0 @@
-import { FsError, readBytes, resolvePath, writeBytes } from "@poe-platform/safe-bash/contracts";
-import { integerMaximum, pathQuote } from "./options.js";
-import { yieldTurn } from "@poe-platform/safe-bash/contracts/yield";
-export async function observe(operation, signal) {
-    signal.throwIfAborted();
-    return new Promise((resolve, reject) => {
-        const abort = () => { signal.removeEventListener("abort", abort); reject(signal.reason); };
-        signal.addEventListener("abort", abort, { once: true });
-        Promise.resolve().then(() => { signal.throwIfAborted(); return operation(); }).then(value => {
-            signal.removeEventListener("abort", abort);
-            resolve(value);
-        }, error => {
-            signal.removeEventListener("abort", abort);
-            reject(error);
-        });
-    });
-}
-export class InputError extends Error {
-    operand;
-    reason;
-    opening;
-    constructor(operand, reason, opening) {
-        super("cmp input failure");
-        this.operand = operand;
-        this.reason = reason;
-        this.opening = opening;
-    }
-}
-const errnoMessages = {
-    ENOENT: "No such file or directory", EACCES: "Permission denied", EPERM: "Operation not permitted",
-    EISDIR: "Is a directory", ENOTDIR: "Not a directory", EIO: "Input/output error", EBADF: "Bad file descriptor",
-    ELOOP: "Too many levels of symbolic links", ENAMETOOLONG: "File name too long", ENOSPC: "No space left on device",
-    EMFILE: "Too many open files", ENFILE: "Too many open files in system", EPIPE: "Broken pipe",
-    EOVERFLOW: "Value too large to be stored in data type", ENOTSUP: "Operation not supported", EFBIG: "File too large",
-};
-export function errorText(error) {
-    if (error instanceof FsError)
-        return errnoMessages[error.code] ?? error.message;
-    return error instanceof Error ? error.message : String(error);
-}
-export class Cursor {
-    operand;
-    signal;
-    maxChunkBytes;
-    reader;
-    chunk = new Uint8Array();
-    offset = 0;
-    done = false;
-    closed;
-    returned;
-    untilYield = 65536;
-    constructor(operand, source, signal, maxChunkBytes) {
-        this.operand = operand;
-        this.signal = signal;
-        this.maxChunkBytes = maxChunkBytes;
-        this.reader = readBytes({
-            [Symbol.asyncIterator]: () => {
-                const iterator = source[Symbol.asyncIterator]();
-                return {
-                    next: () => iterator.next(),
-                    return: () => {
-                        this.returned ??= Promise.resolve().then(() => iterator.return ? iterator.return() : { value: undefined, done: true });
-                        return this.returned;
-                    },
-                };
-            },
-        }, signal);
-    }
-    async available() {
-        try {
-            this.signal.throwIfAborted();
-            while (!this.done && this.offset === this.chunk.length) {
-                if (this.untilYield <= 0) {
-                    await yieldTurn(this.signal);
-                    this.untilYield = 65536;
-                }
-                const next = await this.reader.next();
-                this.done = Boolean(next.done);
-                if (next.done) {
-                    this.chunk = new Uint8Array();
-                    this.offset = 0;
-                    break;
-                }
-                if (next.value.byteLength > this.maxChunkBytes)
-                    throw new Error("input chunk bytes limit exceeded");
-                this.untilYield -= Math.max(64, next.value.byteLength);
-                this.chunk = new Uint8Array(next.value);
-                this.offset = 0;
-            }
-            return this.chunk.subarray(this.offset);
-        }
-        catch (error) {
-            this.signal.throwIfAborted();
-            throw new InputError(this.operand, error, false);
-        }
-    }
-    consume(count) { this.offset += count; }
-    async block(count) {
-        const bytes = new Uint8Array(count);
-        let size = 0;
-        while (size < count) {
-            const chunk = await this.available();
-            if (!chunk.length)
-                break;
-            const length = Math.min(count - size, chunk.length);
-            bytes.set(chunk.subarray(0, length), size);
-            this.consume(length);
-            size += length;
-        }
-        return bytes.subarray(0, size);
-    }
-    async skip(count) {
-        while (count > 0n) {
-            const chunk = await this.available();
-            if (!chunk.length)
-                break;
-            const amount = Number(count < BigInt(chunk.length) ? count : BigInt(chunk.length));
-            this.consume(amount);
-            count -= BigInt(amount);
-        }
-    }
-    close() {
-        this.closed ??= (async () => {
-            try {
-                await this.reader.return(undefined);
-                await this.returned;
-            }
-            catch (error) {
-                throw new InputError(this.operand, error, false);
-            }
-            finally {
-                this.chunk = new Uint8Array();
-            }
-        })();
-        return this.closed;
-    }
-}
-export class Session {
-    context;
-    limits;
-    comparisonBlockBytes;
-    controller = new AbortController();
-    signal;
-    cursors = [];
-    closed;
-    constructor(context, limits, comparisonBlockBytes) {
-        this.context = context;
-        this.limits = limits;
-        this.comparisonBlockBytes = comparisonBlockBytes;
-        this.signal = AbortSignal.any([context.signal, this.controller.signal]);
-        context.registerCleanup?.(() => this.close());
-    }
-    async open(name) {
-        this.signal.throwIfAborted();
-        if (name === "-")
-            return { name };
-        try {
-            if (!name)
-                throw new FsError("ENOENT");
-            const path = resolvePath(this.context.cwd, name);
-            const stat = await observe(() => this.context.fs.stat(path, { signal: this.signal }), this.signal);
-            this.signal.throwIfAborted();
-            await observe(() => this.context.fs.access(path, 4, { signal: this.signal }), this.signal);
-            this.signal.throwIfAborted();
-            return { name, path, stat };
-        }
-        catch (error) {
-            this.signal.throwIfAborted();
-            throw new InputError(name, error, true);
-        }
-    }
-    cursor(input, skip) {
-        this.signal.throwIfAborted();
-        const { context, signal, limits } = this;
-        const source = input.path === undefined ? context.stdin : (async function* () {
-            if (input.stat?.type === "directory")
-                throw new FsError("EISDIR");
-            if (skip > integerMaximum && input.stat?.type === "file")
-                return;
-            if (context.fs.readStream) {
-                const start = input.stat?.type === "file" && input.stat.size >= 0 ? Number(skip < BigInt(Number.MAX_SAFE_INTEGER) ? skip : BigInt(Number.MAX_SAFE_INTEGER)) : 0;
-                yield* context.fs.readStream(input.path, { signal, start, chunkSize: Math.min(65536, limits.maxChunkBytes) });
-            }
-            else {
-                if (!input.stat || !Number.isSafeInteger(input.stat.size) || input.stat.size < 0 || input.stat.size > limits.maxFallbackBytes) {
-                    throw new Error("bounded comparison requires readStream or a file within maxFallbackBytes");
-                }
-                const bytes = await observe(() => context.fs.readFile(input.path, { signal, ...(Number.isFinite(limits.maxFallbackBytes) ? { maxBytes: limits.maxFallbackBytes } : {}) }), signal);
-                if (bytes.length > limits.maxFallbackBytes)
-                    throw new Error("input fallback bytes limit exceeded");
-                for (let offset = Number(skip < BigInt(bytes.length) ? skip : BigInt(bytes.length)); offset < bytes.length; offset += limits.maxChunkBytes)
-                    yield bytes.subarray(offset, offset + limits.maxChunkBytes);
-            }
-        })();
-        const cursor = new Cursor(input.name, source, signal, limits.maxChunkBytes);
-        this.cursors.push(cursor);
-        return cursor;
-    }
-    async output(text, stderr = false) {
-        await writeBytes(stderr ? this.context.stderr : this.context.stdout, new TextEncoder().encode(text), this.signal);
-    }
-    close(cancel = true) {
-        if (!this.closed) {
-            this.closed = Promise.resolve().then(async () => {
-                const results = await Promise.allSettled(this.cursors.map(cursor => cursor.close()));
-                const failure = results.find(result => result.status === "rejected");
-                if (failure?.status === "rejected")
-                    throw failure.reason;
-            });
-            if (cancel)
-                this.controller.abort(new Error("cmp invocation closed"));
-        }
-        return this.closed;
-    }
-}
-export function inputDiagnostic(error) {
-    return `cmp: ${pathQuote(error.operand)}: ${errorText(error.reason)}\n`;
-}

package/dist/safe-bash/command-chunks/{chunk-RTOJNFFL.js → chunk-KNI4GRXF.js}

@@ -8,6 +8,13 @@ import {
   scanRegex,
   substituteRegex
 } from "./chunk-3KROFHBT.js";
+import {
+  capture
+} from "./chunk-OYZ534IK.js";
+import {
+  fromDateIso8601,
+  toDateIso8601
+} from "./chunk-SNXWY3KV.js";
 import {
   delpaths
 } from "./chunk-VQLFJCG7.js";
@@ -17,9 +24,6 @@ import {
 import {
   indices
 } from "./chunk-MYKK3Q5G.js";
-import {
-  capture
-} from "./chunk-OYZ534IK.js";
 import {
   binary,
   compare,
@@ -43,10 +47,6 @@ import {
   parseJson,
   stringify
 } from "./chunk-VUG324ER.js";
-import {
-  fromDateIso8601,
-  toDateIso8601
-} from "./chunk-SNXWY3KV.js";
 import {
   JqError,
   JqHalt,

package/dist/safe-bash/command-chunks/{chunk-DEH3CMGL.js → chunk-QJ3ONEBI.js}

@@ -1,9 +1,9 @@
-import {
-  CompressedDataError
-} from "./chunk-Z6SFT6OC.js";
 import {
   formats
 } from "./chunk-KHGQDFQ7.js";
+import {
+  CompressedDataError
+} from "./chunk-Z6SFT6OC.js";
 import {
   init_buffer
 } from "./chunk-HX3SHTCE.js";