@poe-platform/safe-bash 0.1.799 → 0.1.800

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

@@ -1,17 +1,2 @@
-import type { CommandContext } from "../../contracts/index.js";
-import { Pattern } from "../text-programs/regex.js";
-import { type ArchiveLimits } from "./internal.js";
-export interface NameTransform {
-    readonly pattern: Pattern;
-    readonly replacement: string;
-    readonly global: boolean;
-}
-export declare function parseTransform(source: string): NameTransform[];
-export declare class TransformedNames {
-    private readonly transforms;
-    private readonly limits;
-    private readonly budget;
-    constructor(context: CommandContext, transforms: readonly NameTransform[], limits: ArchiveLimits);
-    apply(name: string): Promise<string>;
-}
+export * from "../../../safe-bash-command-tar/transform.js";
 //# sourceMappingURL=transform.d.ts.map

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

@@ -1,86 +1,2 @@
-import { Pattern, substitute } from "../text-programs/regex.js";
-import { Budget } from "../text-programs/shared.js";
-import { checkPath, fail } from "./internal.js";
-export function parseTransform(source) {
-    const transforms = [];
-    let offset = 0;
-    while (offset < source.length) {
-        if (source[offset++] !== "s")
-            fail("only substitution transforms are supported");
-        const delimiter = source[offset++];
-        if (!delimiter || delimiter === "\\" || delimiter === "\n")
-            fail("invalid transform delimiter");
-        const field = () => {
-            let value = "";
-            while (offset < source.length) {
-                const character = source[offset++];
-                if (character === delimiter)
-                    return value;
-                if (character === "\\") {
-                    const next = source[offset++];
-                    if (next === undefined)
-                        break;
-                    value += `\\${next}`;
-                }
-                else
-                    value += character;
-            }
-            return fail("unterminated transform expression");
-        };
-        const patternSource = field();
-        if (!patternSource)
-            fail("empty transform pattern is unsupported");
-        const replacement = field();
-        let global = false;
-        let ignoreCase = false;
-        let extended = false;
-        while (offset < source.length && source[offset] !== ";") {
-            const flag = source[offset++];
-            if (flag === "g")
-                global = true;
-            else if (flag === "i")
-                ignoreCase = true;
-            else if (flag === "x")
-                extended = true;
-            else
-                fail(`unsupported transform flag: ${flag}`);
-        }
-        const pattern = new Pattern(patternSource, extended, ignoreCase);
-        for (let index = 0; index < replacement.length; index++) {
-            if (replacement[index] !== "\\")
-                continue;
-            const next = replacement[++index];
-            if (next && "uUlLE".includes(next))
-                fail("transform replacement case conversion is unsupported");
-            if (next && next >= "1" && next <= "9" && Number(next) > pattern.groupCount)
-                fail("transform references an undefined capture group");
-        }
-        transforms.push({ pattern, replacement, global });
-        if (source[offset] === ";")
-            offset++;
-    }
-    if (!transforms.length)
-        fail("empty transform expression");
-    return transforms;
-}
-export class TransformedNames {
-    transforms;
-    limits;
-    budget;
-    constructor(context, transforms, limits) {
-        this.transforms = transforms;
-        this.limits = limits;
-        this.budget = new Budget(context, {
-            ...(Number.isFinite(limits.maxPatternSteps) ? { maxSteps: limits.maxPatternSteps } : {}),
-            ...(Number.isFinite(limits.maxPathBytes) ? { maxBufferBytes: limits.maxPathBytes } : {}),
-        });
-    }
-    async apply(name) {
-        for (const transform of this.transforms) {
-            name = (await substitute(name, transform.pattern, transform.replacement, this.budget, transform.global)).text;
-            checkPath(name, this.limits);
-        }
-        return name;
-    }
-}
+export * from "../../../safe-bash-command-tar/transform.js";
 //# sourceMappingURL=transform.js.map

package/dist/safe-bash/commands/archive/unzip/arguments.d.ts

@@ -1,54 +1,2 @@
-import { type ByteSource, type CommandContext } from "../../../contracts/index.js";
-import { type ArchiveLimits } from "../internal.js";
-export declare function parseArguments(context: Pick<CommandContext, "args" | "argumentValues">, limits: ArchiveLimits): {
-    test: boolean;
-    quiet: number;
-    password: Uint8Array<ArrayBufferLike> | undefined;
-    names: boolean;
-    archiveComment: boolean;
-    list: boolean;
-    verbose: boolean;
-    caseInsensitive: boolean;
-    update: boolean;
-    freshen: boolean;
-    exclusions: string[];
-    pipe: boolean;
-    pipeHeaders: boolean;
-    overwrite: boolean;
-    neverOverwrite: boolean;
-    junkPaths: boolean;
-    destination: string | undefined;
-    archive: string;
-    patterns: string[];
-};
-export declare class Selection {
-    private readonly limits;
-    private readonly signal;
-    private readonly options;
-    private work;
-    private readonly patterns;
-    private readonly tailComponents;
-    private readonly emptyTailMatch;
-    readonly matched: Set<number>;
-    constructor(patterns: readonly string[], limits: ArchiveLimits, signal: AbortSignal, options?: {
-        noWild?: boolean;
-        stopAtDirectories?: boolean;
-        trailingComponents?: boolean;
-        caseInsensitive?: boolean;
-    });
-    private step;
-    matches(name: string, firstMatchOnly?: boolean): Promise<boolean>;
-}
-export declare class Answers {
-    private readonly limits;
-    private readonly signal;
-    private readonly iterator;
-    private chunk;
-    private offset;
-    private bytes;
-    private pulls;
-    constructor(source: ByteSource, limits: ArchiveLimits, signal: AbortSignal);
-    read(maximum?: number): Promise<string | undefined>;
-    close(): Promise<void>;
-}
+export * from "../../../../safe-bash-zip-engine/unzip/arguments.js";
 //# sourceMappingURL=arguments.d.ts.map

package/dist/safe-bash/commands/archive/unzip/arguments.js

@@ -1,323 +1,2 @@
-import { byteLength, decodeBytes, encodeBytes } from "../../../byte-encoding.js";
-import { getCommandArguments, readBytes } from "../../../contracts/index.js";
-import { shellValueByteLength, shellValueBytes } from "../../../contracts/value.js";
-import { yieldTurn } from "../../../contracts/yield.js";
-import { checkPath, fail, text } from "../internal.js";
-export function parseArguments(context, limits) {
-    const { args } = context;
-    const rawArguments = context.argumentValues ? getCommandArguments(context) : undefined;
-    const passwordArguments = new Set();
-    let bytes = 0;
-    for (const argument of args) {
-        bytes += byteLength(argument) + 1;
-        if (bytes > limits.maxArgumentBytes)
-            fail("argument byte limit exceeded");
-        if (argument.includes("\0"))
-            fail("NUL in argument");
-    }
-    if (context.argumentValues) {
-        const argumentsValue = getCommandArguments(context);
-        let rawBytes = 0;
-        for (const value of argumentsValue.values) {
-            const size = shellValueByteLength(value) + 1;
-            if (size > limits.maxArgumentBytes - rawBytes)
-                fail("argument byte limit exceeded");
-            rawBytes += size;
-        }
-    }
-    let list = false;
-    let verbose = false;
-    let caseInsensitive = false;
-    let update = false;
-    let freshen = false;
-    let excluding = false;
-    const exclusions = [];
-    let zipinfo = false;
-    let names = false;
-    let archiveComment = false;
-    let test = false;
-    let quiet = 0;
-    let password;
-    let pipe = false;
-    let pipeHeaders = false;
-    let overwrite = false;
-    let neverOverwrite = false;
-    let junkPaths = false;
-    let destination;
-    let archive;
-    let ended = false;
-    const patterns = [];
-    for (let index = 0; index < args.length; index++) {
-        const argument = args[index];
-        if (!ended && argument === "--") {
-            ended = true;
-            continue;
-        }
-        if (!ended && argument.startsWith("-") && argument !== "-") {
-            for (let offset = 1; offset < argument.length; offset++) {
-                const flag = argument[offset];
-                if (flag === "P") {
-                    const attached = offset + 1 < argument.length;
-                    const value = argument.slice(offset + 1) || args[++index];
-                    if (value === undefined)
-                        fail("password option requires a value");
-                    passwordArguments.add(index);
-                    const raw = rawArguments?.bytes(index);
-                    password = raw ? new Uint8Array(raw.subarray(attached ? offset + 1 : 0)) : encodeBytes(value);
-                    break;
-                }
-                else if (flag === "Z" && index === 0 && offset === 1)
-                    zipinfo = true;
-                else if (flag === "1" && zipinfo)
-                    names = true;
-                else if (flag === "z")
-                    archiveComment = true;
-                else if (flag === "t")
-                    test = true;
-                else if (flag === "q")
-                    quiet++;
-                else if (flag === "l")
-                    list = true;
-                else if (flag === "v") {
-                    list = true;
-                    verbose = true;
-                }
-                else if (flag === "C")
-                    caseInsensitive = true;
-                else if (flag === "u") {
-                    update = true;
-                    freshen = false;
-                }
-                else if (flag === "f") {
-                    update = true;
-                    freshen = true;
-                }
-                else if (flag === "x") {
-                    excluding = true;
-                    if (argument.length > offset + 1)
-                        exclusions.push(argument.slice(offset + 1));
-                    break;
-                }
-                else if (flag === "p")
-                    pipe = true;
-                else if (flag === "c")
-                    pipeHeaders = true;
-                else if (flag === "o")
-                    overwrite = true;
-                else if (flag === "n")
-                    neverOverwrite = true;
-                else if (flag === "j")
-                    junkPaths = true;
-                else if (flag === "d") {
-                    if (destination !== undefined)
-                        fail("-d may only be specified once");
-                    destination = argument.slice(offset + 1) || args[++index];
-                    if (!destination)
-                        fail("must specify directory to which to extract with -d option");
-                    checkPath(destination, limits);
-                    break;
-                }
-                else
-                    fail(`unsupported option: -${flag}`);
-            }
-        }
-        else if (archive === undefined)
-            archive = argument;
-        else
-            (excluding ? exclusions : patterns).push(argument);
-    }
-    if (rawArguments)
-        for (const [index, value] of rawArguments.values.entries()) {
-            if (!passwordArguments.has(index))
-                text(shellValueBytes(value));
-        }
-    pipeHeaders = pipeHeaders && !pipe;
-    pipe = pipe || pipeHeaders;
-    if (archive === undefined)
-        fail("usage: unzip [-l|-v] [-C] [-u|-f] [-p|-c] [-t] [-z] [-Z -1] [-q[q]] [-o] [-n] [-j] [-d DIR] ARCHIVE [FILES...] [-x PATTERNS...]");
-    checkPath(archive, limits);
-    if (zipinfo && (!names || list || test || pipe || archiveComment || overwrite || destination !== undefined || password !== undefined))
-        fail("supported zipinfo mode is unzip -Z -1 ARCHIVE [FILES...]");
-    if (archiveComment && (list || test || pipe || overwrite || destination !== undefined))
-        fail("archive comment mode cannot be combined with extraction, listing or test options");
-    if (test && (list || pipe || destination !== undefined))
-        fail("unzip test mode cannot be combined with listing, pipe or destination");
-    return { test, quiet, password, names, archiveComment, list: list && !pipe, verbose, caseInsensitive, update, freshen, exclusions, pipe, pipeHeaders, overwrite, neverOverwrite, junkPaths, destination, archive, patterns };
-}
-function tokenize(pattern, noWild, stopAtDirectories) {
-    const characters = Array.from(pattern);
-    const tokens = [];
-    for (let index = 0; index < characters.length; index++) {
-        const character = characters[index];
-        if (character === "*" && !noWild) {
-            let count = 1;
-            while (characters[index + 1] === "*") {
-                count++;
-                index++;
-            }
-            tokens.push({ kind: "star", crossDirectories: !stopAtDirectories || count > 1 });
-        }
-        else if (character === "?")
-            tokens.push({ kind: "any" });
-        else if (character === "\\" && !noWild) {
-            const escaped = characters[++index];
-            tokens.push(escaped === undefined ? { kind: "never" } : { kind: "literal", value: escaped });
-        }
-        else if (character === "[" && !noWild) {
-            const negative = characters[index + 1] === "!" || characters[index + 1] === "^";
-            if (negative)
-                index++;
-            const ranges = [];
-            const start = index + 1;
-            let closing = start;
-            let escaped = false;
-            for (; closing < characters.length; closing++) {
-                const current = characters[closing];
-                if (escaped)
-                    escaped = false;
-                else if (current === "\\")
-                    escaped = true;
-                else if (current === "]")
-                    break;
-            }
-            // Info-ZIP recmatch defers a character followed by '-' and uses the
-            // immediately preceding character for each range. Chained and trailing
-            // hyphens therefore differ from conventional glob character classes.
-            let first;
-            escaped = characters[start] === "-";
-            for (let position = start; position < closing; position++) {
-                const current = characters[position];
-                if (!escaped && current === "\\")
-                    escaped = true;
-                else if (!escaped && current === "-")
-                    first = characters[position - 1].codePointAt(0);
-                else {
-                    const last = current.codePointAt(0);
-                    if (characters[position + 1] !== "-")
-                        ranges.push([first ?? last, last]);
-                    first = undefined;
-                    escaped = false;
-                }
-            }
-            index = closing;
-            tokens.push(closing < characters.length ? { kind: "class", ranges, negative } : { kind: "never" });
-        }
-        else
-            tokens.push({ kind: "literal", value: character });
-    }
-    return tokens;
-}
-export class Selection {
-    limits;
-    signal;
-    options;
-    work = 0;
-    patterns;
-    tailComponents;
-    emptyTailMatch;
-    matched = new Set();
-    constructor(patterns, limits, signal, options = {}) {
-        this.limits = limits;
-        this.signal = signal;
-        this.options = options;
-        this.patterns = patterns.map(pattern => tokenize(options.caseInsensitive ? pattern.toLowerCase() : pattern, options.noWild === true, options.stopAtDirectories === true));
-        this.tailComponents = patterns.map(pattern => pattern.split("/").length);
-        this.emptyTailMatch = patterns.map(pattern => !options.noWild && (pattern === "*" || options.stopAtDirectories === true && pattern === "**"));
-    }
-    step() {
-        if (++this.work > this.limits.maxPatternSteps)
-            fail("pattern work limit exceeded");
-    }
-    async matches(name, firstMatchOnly = false) {
-        if (!this.patterns.length)
-            return true;
-        if (this.options.caseInsensitive)
-            name = name.toLowerCase();
-        const fullCharacters = Array.from(name);
-        let selected = false;
-        for (let pattern = 0; pattern < this.patterns.length; pattern++) {
-            this.step();
-            const characters = this.options.trailingComponents ? Array.from(name.split("/").slice(-this.tailComponents[pattern]).join("/")) : fullCharacters;
-            if (this.options.trailingComponents && !characters.length && !this.emptyTailMatch[pattern])
-                continue;
-            let states = new Uint8Array(characters.length + 1);
-            states[0] = 1;
-            for (const token of this.patterns[pattern]) {
-                const next = new Uint8Array(states.length);
-                for (let index = 0; index < states.length; index++) {
-                    this.step();
-                    if (token.kind === "star")
-                        next[index] = states[index] || (index > 0 && (token.crossDirectories || characters[index - 1] !== "/") ? next[index - 1] : 0);
-                    else if (states[index] && index < characters.length) {
-                        const character = characters[index];
-                        let match = token.kind === "any" && (!this.options.stopAtDirectories || character !== "/") || (token.kind === "literal" && token.value === character);
-                        if (token.kind === "class") {
-                            let inRange = false;
-                            for (const [first, last] of token.ranges) {
-                                this.step();
-                                if (character.codePointAt(0) >= first && character.codePointAt(0) <= last)
-                                    inRange = true;
-                            }
-                            match = inRange !== token.negative;
-                        }
-                        if (match)
-                            next[index + 1] = 1;
-                    }
-                    if (this.work % 4096 === 0)
-                        await yieldTurn(this.signal);
-                }
-                states = next;
-            }
-            if (states[characters.length]) {
-                this.matched.add(pattern);
-                if (firstMatchOnly)
-                    return true;
-                selected = true;
-            }
-        }
-        return selected;
-    }
-}
-export class Answers {
-    limits;
-    signal;
-    iterator;
-    chunk = new Uint8Array();
-    offset = 0;
-    bytes = 0;
-    pulls = 0;
-    constructor(source, limits, signal) {
-        this.limits = limits;
-        this.signal = signal;
-        this.iterator = readBytes(source, signal)[Symbol.asyncIterator]();
-    }
-    async read(maximum = 9) {
-        const answer = [];
-        while (answer.length < maximum) {
-            this.signal.throwIfAborted();
-            if (this.offset === this.chunk.length) {
-                if (++this.pulls > this.limits.maxPatternSteps)
-                    fail("overwrite input work limit exceeded");
-                if (this.pulls % 64 === 0)
-                    await yieldTurn(this.signal);
-                const next = await this.iterator.next();
-                if (next.done)
-                    break;
-                if (next.value.length > this.limits.maxFilesFromBytes - this.bytes)
-                    fail("overwrite input byte limit exceeded");
-                this.bytes += next.value.length;
-                this.chunk = Uint8Array.from(next.value);
-                this.offset = 0;
-                if (!this.chunk.length)
-                    continue;
-            }
-            const byte = this.chunk[this.offset++];
-            answer.push(byte);
-            if (byte === 10)
-                break;
-        }
-        return answer.length ? decodeBytes(encodeBytes(answer), "utf8") : undefined;
-    }
-    async close() { await this.iterator.return?.(); }
-}
+export * from "../../../../safe-bash-zip-engine/unzip/arguments.js";
 //# sourceMappingURL=arguments.js.map

package/dist/safe-bash/commands/archive/unzip/safety.d.ts

@@ -1,33 +1,2 @@
-import { type ByteSource, type CommandContext, type FileStat, type FileStagingEntry } from "../../../contracts/index.js";
-import { type ArchiveLimits } from "../internal.js";
-export declare class Extraction {
-    readonly context: CommandContext;
-    readonly limits: ArchiveLimits;
-    inputVolumes: readonly {
-        path: string;
-        stat: FileStat;
-    }[];
-    private readonly pending;
-    private readonly publications;
-    private readonly readers;
-    private closed;
-    private work;
-    private serial;
-    constructor(context: CommandContext, limits: ArchiveLimits);
-    operation<Value>(action: () => Promise<Value>): Promise<Value>;
-    close(): Promise<void>;
-    source(source: ByteSource): ByteSource;
-    input(path: string): ByteSource;
-    stat(path: string): Promise<FileStat | undefined>;
-    directory(raw: string, create: boolean, ancestors?: FileStagingEntry[]): Promise<string>;
-    createDirectory(path: string, parent: FileStat): Promise<FileStat>;
-    parents(root: string, path: string, create: boolean): Promise<void>;
-    member(root: string, name: string): string;
-    target(root: string, path: string, target: string): Promise<void>;
-    destination(path: string, archivePath: string, archiveStat: FileStat): Promise<FileStat | undefined>;
-    checked(root: string, path: string, expected: FileStat): Promise<void>;
-    metadata(root: string, path: string, identity: FileStat, parent: FileStat, mode: number, modified: Date): Promise<void>;
-    publish(root: string, path: string, chunks: readonly Uint8Array[], expected: FileStat | undefined, parent: FileStat, mode: number, modified: Date, target?: string): Promise<void>;
-    private stage;
-}
+export * from "../../../../safe-bash-command-unzip/unzip/safety.js";
 //# sourceMappingURL=safety.d.ts.map