@poe-platform/safe-bash 0.1.799 → 0.1.801

package/dist/safe-bash/commands/archive/options.js

@@ -1,463 +1,2 @@
-import { byteLength, encodeBytes } from "../../byte-encoding.js";
-import { collectBytes } from "../../contracts/index.js";
-import { checkPath, fail, operation, smallFile, text, vfsPath } from "./internal.js";
-import { parseTransform } from "./transform.js";
-export async function parseOptions(context, limits) {
-    if (context.args.reduce((total, argument) => total + byteLength(argument), 0) > limits.maxArgumentBytes)
-        fail("argument byte limit exceeded");
-    let mode;
-    let archive = "-";
-    let compression;
-    let autoCompress = false;
-    let verbose = false;
-    let toStdout = false;
-    let utc = false;
-    let recordSize = 512;
-    let ignoreZeros = false;
-    let totals = false;
-    let quotingStyle = "escape";
-    let sort = "none";
-    let dereference = false;
-    let excludeCaches = false;
-    let recursion = true;
-    let showTransformedNames = false;
-    const transforms = [];
-    let overwrite = "replace";
-    let strip = 0;
-    let format = "pax";
-    let cwd = context.cwd;
-    let nullFiles = false;
-    let verbatim = false;
-    let filesFrom = false;
-    let stdinUsed = false;
-    let filesFromBytes = 0;
-    let lateExclude = false;
-    let wildcards = false;
-    let occurrence;
-    const metadata = {};
-    const operands = [];
-    const excludes = [];
-    const exclude = (pattern) => {
-        checkPath(pattern, limits);
-        if (excludes.length >= limits.maxMembers)
-            fail("exclude pattern limit exceeded");
-        if (operands.length)
-            lateExclude = true;
-        excludes.push(pattern);
-    };
-    const operand = (name) => {
-        checkPath(name, limits);
-        if (operands.length >= limits.maxMembers)
-            fail("operand limit exceeded");
-        operands.push({ name, cwd });
-    };
-    const directory = async (name) => {
-        checkPath(name, limits);
-        const path = await operation(context, () => context.fs.realpath(vfsPath(cwd, name), { signal: context.signal }));
-        const stat = await operation(context, () => context.fs.stat(path, { signal: context.signal }));
-        if (stat.type !== "directory")
-            fail(`not a directory: ${name}`);
-        cwd = path;
-    };
-    const names = async (path) => {
-        filesFrom = true;
-        if (path === "-" && stdinUsed)
-            fail("standard input file list can only be read once");
-        const bytes = path === "-"
-            ? await collectBytes(context.stdin, { ...(Number.isFinite(limits.maxFilesFromBytes) ? { maxBytes: limits.maxFilesFromBytes } : {}), signal: context.signal })
-            : await smallFile(context, vfsPath(context.cwd, path), limits);
-        if (path === "-")
-            stdinUsed = true;
-        filesFromBytes += bytes.length;
-        if (filesFromBytes > limits.maxFilesFromBytes)
-            fail("files-from byte limit exceeded");
-        const contents = text(bytes);
-        if (!nullFiles && contents.includes("\0"))
-            fail("NUL in newline file list; use --null");
-        const lines = contents.split(nullFiles ? "\0" : "\n");
-        for (let index = 0; index < lines.length; index++) {
-            const line = lines[index];
-            if (!line)
-                continue;
-            if (!nullFiles && !verbatim && line.startsWith("-")) {
-                if (line === "-C") {
-                    const next = lines[++index];
-                    if (!next)
-                        fail("missing -C argument in file list");
-                    await directory(next);
-                }
-                else if (line.startsWith("-C") && !/\s/u.test(line[2] ?? ""))
-                    await directory(line.slice(2));
-                else if (line.startsWith("--directory="))
-                    await directory(line.slice(12));
-                else
-                    fail(`unsupported option in file list: ${line}; use --verbatim-files-from for literal names`);
-            }
-            else {
-                operand(!nullFiles && !verbatim ? unquoteFileName(line) : line);
-            }
-        }
-    };
-    const apply = async (flag, value) => {
-        if (flag === "c" || flag === "t" || flag === "x" || flag === "r" || flag === "u" || flag === "d" || flag === "delete" || flag === "A") {
-            if (mode)
-                fail("exactly one tar operation is required (-c, -t, -x, -r, -u, -d, --delete, -A)");
-            mode = flag;
-        }
-        else if (flag === "z" || flag === "j" || flag === "J") {
-            const selected = flag === "z" ? "gzip" : flag === "j" ? "bzip2" : "xz";
-            if (compression && compression !== selected)
-                fail("conflicting compression options");
-            compression = selected;
-        }
-        else if (flag === "a")
-            autoCompress = true;
-        else if (flag === "v")
-            verbose = true;
-        else if (flag === "O" || flag === "to-stdout")
-            toStdout = true;
-        else if (flag === "utc") {
-            utc = true;
-            verbose = true;
-        }
-        else if (flag === "totals")
-            totals = true;
-        else if (flag === "i")
-            ignoreZeros = true;
-        else if (flag === "B" || flag === "n" || flag === "no-seek" || flag === "force-local") {
-            // VFS archives are always local byte streams; Reader already joins short reads
-            // and consumes member bodies sequentially without requiring device seeking.
-        }
-        else if (flag === "b" || flag === "record-size") {
-            let digits = value;
-            let multiplier = flag === "b" ? 512 : 1;
-            if (flag === "record-size") {
-                const suffixes = { c: 1, w: 2, b: 512, k: 1024, K: 1024, M: 1024 ** 2, G: 1024 ** 3 };
-                const suffix = suffixes[digits.at(-1) ?? ""];
-                if (suffix !== undefined) {
-                    multiplier = suffix;
-                    digits = digits.slice(0, -1);
-                }
-            }
-            if (digits.startsWith("+"))
-                digits = digits.slice(1);
-            const size = Number(digits) * multiplier;
-            if (!digits || ![...digits].every(character => "0123456789".includes(character)) || !Number.isSafeInteger(size) || size <= 0 || size % 512 !== 0)
-                fail("record size must be a positive multiple of 512");
-            if (size > limits.maxArchiveBytes)
-                fail("record size exceeds archive byte limit");
-            recordSize = size;
-        }
-        else if (flag === "quoting-style") {
-            if (value !== "literal" && value !== "escape" && value !== "c")
-                fail(`unsupported quoting style: ${value}; use literal, escape or c`);
-            quotingStyle = value;
-        }
-        else if (flag === "sort") {
-            if (value !== "name" && value !== "none")
-                fail(`unsupported sort order: ${value}`);
-            sort = value;
-        }
-        else if (flag === "h" || flag === "dereference")
-            dereference = true;
-        else if (flag === "exclude-caches")
-            excludeCaches = true;
-        else if (flag === "no-recursion")
-            recursion = false;
-        else if (flag === "recursion")
-            recursion = true;
-        else if (flag === "show-transformed-names")
-            showTransformedNames = true;
-        else if (flag === "transform")
-            transforms.push(...parseTransform(value));
-        else if (flag === "atime-preserve") {
-            if (value !== "replace")
-                fail("only --atime-preserve=replace is supported; filesystem has no no-atime read capability");
-            metadata.preserveAtime = true;
-        }
-        else if (flag === "full-time")
-            metadata.fullTime = true;
-        else if (flag === "numeric-owner" || flag === "no-same-owner") { /* IDs are numeric; extraction retains filesystem ownership. */ }
-        else if (flag === "same-owner")
-            fail("filesystem does not support restoring archive ownership");
-        else if (flag === "m" || flag === "touch")
-            metadata.touch = true;
-        else if (flag === "p" || flag === "same-permissions" || flag === "preserve-permissions")
-            metadata.permissions = true;
-        else if (flag === "no-same-permissions")
-            metadata.permissions = false;
-        else if (flag === "delay-directory-restore")
-            metadata.delayDirectories = true;
-        else if (flag === "no-delay-directory-restore")
-            metadata.delayDirectories = false;
-        else if (flag === "owner" || flag === "group" || flag === "mode") {
-            const radix = flag === "mode" ? 8 : 10;
-            const digits = radix === 8 ? "01234567" : "0123456789";
-            if (!value || ![...value].every(character => digits.includes(character)))
-                fail(`invalid numeric ${flag}: ${value}`);
-            const number = parseInt(value, radix);
-            if (!Number.isSafeInteger(number) || (flag === "mode" && number > 0o7777))
-                fail(`invalid numeric ${flag}: ${value}`);
-            if (flag === "owner")
-                metadata.uid = number;
-            else if (flag === "group")
-                metadata.gid = number;
-            else
-                metadata.mode = number;
-        }
-        else if (flag === "mtime") {
-            const seconds = value.startsWith("@") ? Number(value.slice(1)) : Date.parse(value) / 1000;
-            if (!value || value === "@" || !Number.isFinite(seconds) || Math.abs(seconds * 1000) > 8.64e15)
-                fail(`invalid mtime: ${value}`);
-            metadata.mtime = seconds;
-        }
-        else if (flag === "k" || flag === "keep-old-files")
-            overwrite = "keep";
-        else if (flag === "skip-old-files")
-            overwrite = "skip";
-        else if (flag === "overwrite")
-            overwrite = "replace";
-        else if (flag === "f") {
-            if (!value)
-                fail("empty archive name");
-            archive = value;
-        }
-        else if (flag === "C")
-            await directory(value);
-        else if (flag === "T")
-            await names(value);
-        else if (flag === "exclude")
-            exclude(value);
-        else if (flag === "X") {
-            if (value === "-" && stdinUsed)
-                fail("standard input file list can only be read once");
-            const bytes = value === "-"
-                ? await collectBytes(context.stdin, { ...(Number.isFinite(limits.maxFilesFromBytes) ? { maxBytes: limits.maxFilesFromBytes } : {}), signal: context.signal })
-                : await smallFile(context, vfsPath(context.cwd, value), limits);
-            if (value === "-")
-                stdinUsed = true;
-            filesFromBytes += bytes.length;
-            if (filesFromBytes > limits.maxFilesFromBytes)
-                fail("files-from byte limit exceeded");
-            const contents = text(bytes);
-            if (contents.includes("\0"))
-                fail("NUL in exclusion file");
-            for (const pattern of contents.split("\n"))
-                if (pattern)
-                    exclude(pattern);
-        }
-        else if (flag === "wildcards")
-            wildcards = true;
-        else if (flag === "no-wildcards")
-            wildcards = false;
-        else if (flag === "occurrence") {
-            const count = value ?? "1";
-            if (!count || ![...count].every(character => "0123456789".includes(character)) || !Number.isSafeInteger(Number(count)) || Number(count) < 1)
-                fail("invalid occurrence count");
-            occurrence = Number(count);
-        }
-        else if (flag === "strip-components") {
-            if (!/^[0-9]+$/u.test(value) || !Number.isSafeInteger(Number(value)))
-                fail("invalid strip-components count");
-            strip = Number(value);
-        }
-        else if (flag === "format") {
-            if (value !== "ustar" && value !== "pax" && value !== "posix")
-                fail(`unsupported archive format: ${value}`);
-            format = value === "ustar" ? "ustar" : "pax";
-        }
-        else if (flag === "null") {
-            nullFiles = true;
-            verbatim = true;
-        }
-        else if (flag === "no-null")
-            nullFiles = false;
-        else if (flag === "verbatim-files-from")
-            verbatim = true;
-        else if (flag === "no-verbatim-files-from")
-            verbatim = false;
-        else
-            fail(`unsupported option: ${flag}`);
-    };
-    const long = { create: "c", list: "t", extract: "x", get: "x", append: "r", update: "u", compare: "d", diff: "d", catenate: "A", concatenate: "A", file: "f", gzip: "z", bzip2: "j", xz: "J", "auto-compress": "a", verbose: "v", directory: "C", "files-from": "T", "exclude-from": "X", xform: "transform", "blocking-factor": "b", "read-full-records": "B", "ignore-zeros": "i", seek: "n" };
-    const values = new Set(["f", "C", "T", "X", "exclude", "strip-components", "format", "transform", "mtime", "owner", "group", "mode", "sort", "b", "record-size", "quoting-style"]);
-    let end = false;
-    for (let index = 0; index < context.args.length; index++) {
-        const argument = context.args[index];
-        if (!end && argument === "--") {
-            end = true;
-            continue;
-        }
-        if (!end && argument.startsWith("--")) {
-            const equals = argument.indexOf("=");
-            const name = argument.slice(2, equals < 0 ? undefined : equals);
-            const flag = long[name] ?? name;
-            let value = equals < 0 ? undefined : argument.slice(equals + 1);
-            if (values.has(flag) && value === undefined)
-                value = context.args[++index];
-            if (values.has(flag) && value === undefined)
-                fail(`missing argument for --${name}`);
-            if (flag === "atime-preserve" && value === undefined)
-                value = "replace";
-            if (!values.has(flag) && flag !== "atime-preserve" && flag !== "occurrence" && value !== undefined)
-                fail(`option --${name} does not take an argument`);
-            if (flag === "help")
-                return "help";
-            await apply(flag, value);
-        }
-        else if (!end && ((argument.startsWith("-") && argument !== "-") || (index === 0 && argument.length > 0 && [...argument].every(flag => "ctxrudAzjJavfCTXmpkhbBinO".includes(flag))))) {
-            const old = !argument.startsWith("-");
-            const cluster = old ? argument : argument.slice(1);
-            for (let offset = 0; offset < cluster.length; offset++) {
-                const flag = cluster[offset];
-                let value;
-                if (values.has(flag)) {
-                    value = !old && offset + 1 < cluster.length ? cluster.slice(offset + 1) : context.args[++index];
-                    if (value === undefined)
-                        fail(`missing argument for -${flag}`);
-                    if (!old)
-                        offset = cluster.length;
-                }
-                await apply(flag, value);
-            }
-        }
-        else
-            operand(argument);
-    }
-    if (!mode)
-        fail("exactly one tar operation is required (-c, -t, -x, -r, -u, -d, --delete, -A)");
-    const creating = mode === "c" || mode === "r" || mode === "u";
-    if (occurrence !== undefined && (creating || mode === "A" || !operands.length))
-        fail("--occurrence requires member operands when reading archives");
-    if (mode !== "c" && archive === "-" && stdinUsed)
-        fail("archive and file list cannot both use standard input");
-    if (mode !== "t" && mode !== "x" && strip !== 0)
-        fail("--strip-components is only supported when listing or extracting archives");
-    if (creating && lateExclude)
-        fail("--exclude after source operands is unsupported; place exclusions before operands");
-    if (mode === "c" && !operands.length && !filesFrom)
-        fail("refusing to create an empty archive without -T");
-    if (archive !== "-")
-        checkPath(archive, limits);
-    if (mode === "c" && autoCompress) {
-        compression = archive.endsWith(".gz") || archive.endsWith(".tgz") ? "gzip"
-            : archive.endsWith(".bz2") || archive.endsWith(".tbz2") || archive.endsWith(".tbz") ? "bzip2"
-                : archive.endsWith(".xz") || archive.endsWith(".txz") ? "xz" : undefined;
-    }
-    return { mode, archive, ...(compression ? { compression } : {}), verbose, toStdout, utc, recordSize, ignoreZeros, totals, quotingStyle, showTransformedNames, transforms, strip, format, cwd, operands, excludes, sort, dereference, excludeCaches, recursion, wildcards, ...(occurrence !== undefined ? { occurrence } : {}), metadata, overwrite };
-}
-function unquoteFileName(name) {
-    const input = encodeBytes(name);
-    const output = [];
-    const escapes = { a: 7, b: 8, f: 12, n: 10, r: 13, t: 9, v: 11, "\\": 92 };
-    for (let index = 0; index < input.length; index++) {
-        const byte = input[index];
-        if (byte === 92 && index + 1 < input.length) {
-            const next = input[index + 1];
-            const escape = escapes[String.fromCharCode(next)];
-            if (escape !== undefined) {
-                output.push(escape);
-                index++;
-                continue;
-            }
-            const digits = input.subarray(index + 1, index + 4);
-            if (digits.length === 3 && digits.every(digit => digit >= 48 && digit <= 55)) {
-                output.push(((digits[0] - 48) * 64 + (digits[1] - 48) * 8 + digits[2] - 48) & 255);
-                index += 3;
-                continue;
-            }
-        }
-        output.push(byte);
-    }
-    return text(Uint8Array.from(output));
-}
-function tokenize(pattern) {
-    const characters = Array.from(pattern);
-    const tokens = [];
-    for (let index = 0; index < characters.length; index++) {
-        const character = characters[index];
-        if (character === "*") {
-            if (tokens.at(-1)?.kind !== "star")
-                tokens.push({ kind: "star" });
-        }
-        else if (character === "?")
-            tokens.push({ kind: "any" });
-        else if (character === "\\") {
-            if (++index === characters.length)
-                fail("trailing escape in exclude pattern");
-            tokens.push({ kind: "literal", value: characters[index] });
-        }
-        else if (character === "[") {
-            const ranges = [];
-            index++;
-            const negative = characters[index] === "!" || characters[index] === "^";
-            if (negative)
-                index++;
-            while (index < characters.length && (characters[index] !== "]" || ranges.length === 0)) {
-                const first = characters[index];
-                if (first === "[" || first === "\\")
-                    fail("POSIX classes and escapes inside exclude brackets are unsupported");
-                let last = first;
-                if (characters[index + 1] === "-" && characters[index + 2] && characters[index + 2] !== "]") {
-                    last = characters[index + 2];
-                    index += 2;
-                }
-                if (first.codePointAt(0) > last.codePointAt(0))
-                    fail("invalid exclude bracket range");
-                ranges.push([first.codePointAt(0), last.codePointAt(0)]);
-                index++;
-            }
-            if (characters[index] !== "]")
-                fail("unclosed exclude bracket");
-            tokens.push({ kind: "class", ranges, negative });
-        }
-        else
-            tokens.push({ kind: "literal", value: character });
-    }
-    return tokens;
-}
-export class Exclusions {
-    maxWork;
-    anchored;
-    patterns;
-    work = 0;
-    constructor(patterns, maxWork = Infinity, anchored = false) {
-        this.maxWork = maxWork;
-        this.anchored = anchored;
-        this.patterns = patterns.map(tokenize);
-    }
-    matches(name) {
-        const characters = Array.from(name);
-        for (const tokens of this.patterns) {
-            let states = new Uint8Array(characters.length + 1);
-            states[0] = 1;
-            if (!this.anchored)
-                for (let index = 0; index < characters.length; index++)
-                    if (characters[index] === "/")
-                        states[index + 1] = 1;
-            for (const token of tokens) {
-                this.work += characters.length + 1;
-                if (this.work > this.maxWork)
-                    fail("exclude pattern work limit exceeded");
-                const next = new Uint8Array(states.length);
-                for (let index = 0; index < states.length; index++) {
-                    if (token.kind === "star")
-                        next[index] = states[index] || (index > 0 ? next[index - 1] : 0);
-                    else if (states[index] && index < characters.length) {
-                        const character = characters[index];
-                        const matches = token.kind === "any" || (token.kind === "literal" ? token.value === character
-                            : token.ranges.some(([first, last]) => character.codePointAt(0) >= first && character.codePointAt(0) <= last) !== token.negative);
-                        if (matches)
-                            next[index + 1] = 1;
-                    }
-                }
-                states = next;
-            }
-            for (let index = 0; index < states.length; index++)
-                if (states[index] && (index === characters.length || characters[index] === "/"))
-                    return true;
-        }
-        return false;
-    }
-}
+export * from "../../../safe-bash-command-tar/options.js";
 //# sourceMappingURL=options.js.map

package/dist/safe-bash/commands/archive/stream.d.ts

@@ -1,23 +1,2 @@
-import { type ByteSource } from "../../contracts/index.js";
-import type { TarOptions } from "./options.js";
-import { type ArchiveLimits, type Budget } from "./internal.js";
-export declare function compressed(source: ByteSource, decode: boolean, signal: AbortSignal, limits: ArchiveLimits, format?: NonNullable<TarOptions["compression"]>): ByteSource;
-export declare function autodetected(source: ByteSource, signal: AbortSignal, limits: ArchiveLimits): ByteSource;
-export declare function recordPadding(size: number, recordSize: number, maximum: number): number;
-export declare function recorded(source: ByteSource, options: TarOptions, budget: Budget): ByteSource;
-export declare class Reader {
-    readonly signal: AbortSignal;
-    position: number;
-    readonly iterator: AsyncIterator<Uint8Array>;
-    private chunk;
-    private offset;
-    constructor(source: ByteSource, signal: AbortSignal);
-    take(maximum: number): Promise<Uint8Array | undefined>;
-    exact(size: number): Promise<Uint8Array>;
-    body(size: number): ByteSource;
-    discard(size: number): Promise<void>;
-    padding(size: number): Promise<void>;
-    finish(): Promise<void>;
-    close(): Promise<void>;
-}
+export * from "../../../safe-bash-command-tar/stream.js";
 //# sourceMappingURL=stream.d.ts.map

package/dist/safe-bash/commands/archive/stream.js

@@ -1,189 +1,2 @@
-import { readBytes } from "../../contracts/index.js";
-import { compressionDiagnostic } from "../bytes/compression/errors.js";
-import { codec, CodecReader } from "../bytes/compression/codec.js";
-import { boundedCodec } from "../bytes/compression/bounded-codec.js";
-import { profiles } from "../bytes/compression/options.js";
-import { bounded, fail } from "./internal.js";
-export async function* compressed(source, decode, signal, limits, format = "gzip") {
-    signal.throwIfAborted();
-    const controller = new AbortController();
-    const combined = AbortSignal.any([signal, controller.signal]);
-    const reader = new CodecReader(bounded(source, limits.maxArchiveBytes, combined, limits.chunkSize), combined);
-    let hasFailure = false;
-    let failure;
-    try {
-        const onFailure = (error) => {
-            if (!hasFailure) {
-                hasFailure = true;
-                failure = error;
-                controller.abort(error);
-            }
-        };
-        const output = format === "gzip"
-            ? codec(reader, { mode: decode ? "gunzip" : "gzip", chunkSize: limits.chunkSize, onFailure }, combined)
-            : boundedCodec(reader, { format, decompress: decode, level: profiles.find(profile => profile.format === format).level, onFailure }, combined);
-        yield* bounded(output, limits.maxArchiveBytes, combined, limits.chunkSize);
-    }
-    catch (error) {
-        signal.throwIfAborted();
-        throw compressionDiagnostic(hasFailure ? failure : error);
-    }
-    finally {
-        controller.abort(new Error("archive compression finished"));
-        await reader.close();
-    }
-}
-export async function* autodetected(source, signal, limits) {
-    const iterator = readBytes(source, signal)[Symbol.asyncIterator]();
-    try {
-        const prefix = new Uint8Array(6);
-        let size = 0;
-        let remainder;
-        while (size < prefix.length) {
-            const next = await iterator.next();
-            if (next.done)
-                break;
-            const chunk = next.value;
-            if (!chunk.length)
-                continue;
-            const take = Math.min(prefix.length - size, chunk.length);
-            prefix.set(chunk.subarray(0, take), size);
-            size += take;
-            if (take < chunk.length) {
-                remainder = chunk.subarray(take);
-                break;
-            }
-        }
-        const replay = (async function* () {
-            yield prefix.subarray(0, size);
-            if (remainder)
-                yield remainder;
-            for (;;) {
-                const next = await iterator.next();
-                if (next.done)
-                    return;
-                if (next.value.length)
-                    yield next.value;
-            }
-        })();
-        const format = size >= 2 && prefix[0] === 31 && prefix[1] === 139 ? "gzip"
-            : size >= 3 && prefix[0] === 66 && prefix[1] === 90 && prefix[2] === 104 ? "bzip2"
-                : size === 6 && [253, 55, 122, 88, 90, 0].every((byte, index) => prefix[index] === byte) ? "xz" : undefined;
-        yield* format ? compressed(replay, true, signal, limits, format) : replay;
-    }
-    finally {
-        if (iterator.return)
-            await iterator.return(undefined);
-    }
-}
-export function recordPadding(size, recordSize, maximum) {
-    const padding = (recordSize - size % recordSize) % recordSize;
-    if (!Number.isSafeInteger(size) || size < 0 || size > maximum || padding > maximum - size)
-        fail("archive byte limit exceeded");
-    return padding;
-}
-export async function* recorded(source, options, budget) {
-    let size = 0;
-    for await (const chunk of readBytes(source, budget.context.signal)) {
-        if (chunk.length > budget.limits.maxArchiveBytes - size)
-            fail("archive byte limit exceeded");
-        size += chunk.length;
-        yield chunk;
-    }
-    let padding = recordPadding(size, options.recordSize, budget.limits.maxArchiveBytes);
-    while (padding > 0) {
-        budget.context.signal.throwIfAborted();
-        const length = Math.min(padding, budget.limits.chunkSize);
-        size += length;
-        padding -= length;
-        yield new Uint8Array(length);
-    }
-    if (options.totals)
-        await budget.output(`Total bytes written: ${size}\n`, true);
-}
-export class Reader {
-    signal;
-    position = 0;
-    iterator;
-    chunk = new Uint8Array();
-    offset = 0;
-    constructor(source, signal) {
-        this.signal = signal;
-        this.iterator = readBytes(source, signal)[Symbol.asyncIterator]();
-    }
-    async take(maximum) {
-        this.signal.throwIfAborted();
-        while (this.offset === this.chunk.length) {
-            const result = await this.iterator.next();
-            if (result.done)
-                return undefined;
-            this.chunk = result.value;
-            this.offset = 0;
-        }
-        const end = Math.min(this.chunk.length, this.offset + maximum);
-        const bytes = this.chunk.subarray(this.offset, end);
-        this.offset = end;
-        this.position += bytes.length;
-        return bytes;
-    }
-    async exact(size) {
-        this.signal.throwIfAborted();
-        if (this.chunk.length - this.offset >= size) {
-            const bytes = this.chunk.subarray(this.offset, this.offset + size);
-            this.offset += size;
-            this.position += size;
-            return bytes;
-        }
-        const result = new Uint8Array(size);
-        let offset = 0;
-        while (offset < size) {
-            const bytes = await this.take(size - offset);
-            if (!bytes)
-                fail("truncated archive");
-            result.set(bytes, offset);
-            offset += bytes.length;
-        }
-        return result;
-    }
-    async *body(size) {
-        let remaining = size;
-        while (remaining > 0) {
-            const bytes = await this.take(remaining);
-            if (!bytes)
-                fail("truncated archive body");
-            remaining -= bytes.length;
-            yield bytes;
-        }
-    }
-    async discard(size) {
-        this.signal.throwIfAborted();
-        if (size === 0)
-            return;
-        if (this.chunk.length - this.offset >= size) {
-            this.offset += size;
-            this.position += size;
-            return;
-        }
-        for await (const ignoredChunk of this.body(size))
-            this.signal.throwIfAborted();
-    }
-    async padding(size) { await this.discard((512 - size % 512) % 512); }
-    async finish() {
-        let trailing = 0;
-        while (true) {
-            const bytes = await this.take(64 * 1024);
-            if (!bytes)
-                break;
-            if (bytes.some(byte => byte !== 0))
-                fail("nonzero trailing archive data or concatenated archive is unsupported");
-            trailing += bytes.length;
-        }
-        if (trailing % 512 !== 0)
-            fail("truncated archive trailing record");
-    }
-    async close() {
-        if (this.iterator.return)
-            await this.iterator.return();
-    }
-}
+export * from "../../../safe-bash-command-tar/stream.js";
 //# sourceMappingURL=stream.js.map