@poe-platform/safe-bash 0.1.630 → 0.1.632

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

@@ -0,0 +1,195 @@
+export const integerMaximum = 9223372036854775807n;
+export class UsageError extends Error {
+}
+const escapes = new Map([[7, "a"], [8, "b"], [9, "t"], [10, "n"], [11, "v"], [12, "f"], [13, "r"]]);
+export function quote(value) {
+    let result = "'";
+    for (const byte of new TextEncoder().encode(value)) {
+        const escape = escapes.get(byte);
+        result += escape ? `\\${escape}` : byte < 32 || byte >= 127 ? `\\${byte.toString(8).padStart(3, "0")}`
+            : byte === 39 || byte === 92 ? `\\${String.fromCharCode(byte)}` : String.fromCharCode(byte);
+    }
+    return `${result}'`;
+}
+export function pathQuote(value) {
+    if (value && !value.startsWith("~") && !value.startsWith("#") && value !== "{" && value !== "}"
+        && Array.from(value).every(character => "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_./-+,:@%]~#{}".includes(character)))
+        return value;
+    const bytes = new TextEncoder().encode(value);
+    if (bytes.every(byte => byte >= 32 && byte < 127)) {
+        if (!value.includes("'"))
+            return `'${value}'`;
+        if (!["$", "`", "\\", '"'].some(character => value.includes(character)))
+            return `"${value}"`;
+        return `'${value.replaceAll("'", "'\\''")}'`;
+    }
+    let result = "'", escaped = false;
+    for (const byte of bytes) {
+        const special = byte < 32 || byte >= 127;
+        if (special !== escaped) {
+            result += special ? "'$'" : "''";
+            escaped = special;
+        }
+        result += special ? `\\${escapes.get(byte) ?? byte.toString(8).padStart(3, "0")}`
+            : byte === 39 ? "'\\''" : String.fromCharCode(byte);
+    }
+    return `${result}'`;
+}
+function countValue(text, kind) {
+    const invalid = () => { throw new UsageError(`invalid --${kind} value ${quote(text)}`); };
+    let position = 0;
+    while (position < text.length && " \t\n\r\v\f".includes(text[position]))
+        position++;
+    let negative = false;
+    if (text[position] === "+" || text[position] === "-")
+        negative = text[position++] === "-";
+    let base = 10;
+    if (text[position] === "0") {
+        base = 8;
+        if (text[position + 1]?.toLowerCase() === "x") {
+            base = 16;
+            position += 2;
+        }
+    }
+    const start = position;
+    let value = 0n;
+    while (position < text.length) {
+        const digit = "0123456789abcdef".indexOf(text[position].toLowerCase());
+        if (digit < 0 || digit >= base)
+            break;
+        value = value * BigInt(base) + BigInt(digit);
+        if (value > integerMaximum)
+            value = integerMaximum + 1n;
+        position++;
+    }
+    const suffix = text.slice(position);
+    const power = suffix ? "KMGTPEZY".indexOf(suffix[0] === "k" ? "K" : suffix[0]) + 1 : 0;
+    if (position === start && (!power || base !== 10 || negative || start !== 0))
+        invalid();
+    if (position === start)
+        value = 1n;
+    if (suffix) {
+        if (!power || !["", "B", "D", "iB"].includes(suffix.slice(1)))
+            invalid();
+        value *= (suffix.endsWith("B") && !suffix.endsWith("iB") || suffix.endsWith("D") ? 1000n : 1024n) ** BigInt(power);
+    }
+    if (negative && value !== 0n)
+        invalid();
+    return value > integerMaximum ? integerMaximum + 1n : value;
+}
+const longOptions = [
+    ["print-bytes", "b"], ["print-chars", "c"], ["ignore-initial", "i"], ["verbose", "l"],
+    ["bytes", "n"], ["silent", "s"], ["quiet", "s"], ["version", "v"], ["help", "help"],
+];
+export function parseArguments(args, posix) {
+    const operands = [];
+    const skips = [0n, 0n];
+    let count = integerMaximum, mode = "first", printBytes = false, stopped = false;
+    const skip = (index, text) => {
+        const parsed = countValue(text, "ignore-initial");
+        if (skips[index] < integerMaximum && parsed > skips[index])
+            skips[index] = parsed;
+    };
+    const apply = (flag, value) => {
+        if (flag === "b" || flag === "c")
+            printBytes = true;
+        if (flag === "l" || flag === "s") {
+            const selected = flag === "l" ? "all" : "silent";
+            if (mode !== "first" && mode !== selected)
+                throw new UsageError("options -l and -s are incompatible");
+            mode = selected;
+        }
+        if (flag === "n") {
+            const parsed = countValue(value, "bytes");
+            if (parsed < count)
+                count = parsed;
+        }
+        if (flag === "i") {
+            const delimiter = value.indexOf(":");
+            if (delimiter < 0) {
+                skip(0, value);
+                if (skips[0] > skips[1])
+                    skips[1] = skips[0];
+            }
+            else {
+                try {
+                    skip(0, value.slice(0, delimiter));
+                }
+                catch {
+                    throw new UsageError(`invalid --ignore-initial value ${quote(value)}`);
+                }
+                skip(1, value.slice(delimiter + 1));
+            }
+        }
+    };
+    for (let index = 0; index < args.length; index++) {
+        const argument = args[index];
+        if (stopped || argument === "-" || !argument.startsWith("-")) {
+            operands.push(argument);
+            if (posix)
+                stopped = true;
+            continue;
+        }
+        if (argument === "--") {
+            stopped = true;
+            continue;
+        }
+        if (argument.startsWith("--")) {
+            const separator = argument.indexOf("=");
+            const name = argument.slice(2, separator < 0 ? undefined : separator);
+            const exact = longOptions.find(([option]) => option === name);
+            const matches = exact ? [exact] : longOptions.filter(([option]) => option.startsWith(name));
+            if (!matches.length)
+                throw new UsageError(`unrecognized option '${argument}'`);
+            if (matches.length > 1)
+                throw new UsageError(`option '${argument}' is ambiguous; possibilities:${matches.map(([option]) => ` '--${option}'`).join("")}`);
+            const flag = matches[0][1];
+            let value = separator < 0 ? undefined : argument.slice(separator + 1);
+            if (flag === "i" || flag === "n") {
+                if (value === undefined)
+                    value = args[++index];
+                if (value === undefined)
+                    throw new UsageError(`option '${argument}' requires an argument`);
+            }
+            else if (value !== undefined)
+                throw new UsageError(`option '--${matches[0][0]}' doesn't allow an argument`);
+            if (flag === "help" || flag === "v")
+                return { files: ["-", "-"], skips, count, mode, printBytes, information: flag === "v" ? "version" : "help" };
+            apply(flag, value);
+        }
+        else {
+            for (let offset = 1; offset < argument.length; offset++) {
+                const flag = argument[offset];
+                if (!"bci:ln:sv".includes(flag) || flag === ":")
+                    throw new UsageError(`invalid option -- '${flag}'`);
+                if (flag === "v")
+                    return { files: ["-", "-"], skips, count, mode, printBytes, information: "version" };
+                let value;
+                if (flag === "i" || flag === "n") {
+                    value = argument.slice(offset + 1) || args[++index];
+                    if (value === undefined)
+                        throw new UsageError(`option requires an argument -- '${flag}'`);
+                    offset = argument.length;
+                }
+                apply(flag, value);
+            }
+        }
+    }
+    if (!operands.length)
+        throw new UsageError(`missing operand after ${quote(args.at(-1) ?? "cmp")}`);
+    if (operands[2] !== undefined)
+        skip(0, operands[2]);
+    if (operands[3] !== undefined)
+        skip(1, operands[3]);
+    if (operands[4] !== undefined)
+        throw new UsageError(`extra operand ${quote(operands[4])}`);
+    return { files: [operands[0], operands[1] ?? "-"], skips, count, mode, printBytes };
+}
+export function limitsFor(options) {
+    const limits = { maxChunkBytes: 1024 * 1024, maxFallbackBytes: 8 * 1024 * 1024, ...options.limits };
+    for (const [name, value] of Object.entries(limits)) {
+        if (!Number.isSafeInteger(value) || value < 1)
+            throw new RangeError(`cmp ${name} must be a positive safe integer`);
+    }
+    return Object.freeze(limits);
+}

package/dist/safe-bash/opt-in/commands/dd/conversions.js

@@ -0,0 +1,152 @@
+const encodings = {
+    ascii: "000102039c09867f978d8e0b0c0d0e0f101112139d8508871819928f1c1d1e1f" +
+        "80818283840a171b88898a8b8c050607909116939495960498999a9b14159e1a" +
+        "20a0a1a2a3a4a5a6a7a8d52e3c282b7c26a9aaabacadaeafb0b121242a293b7e" +
+        "2d2fb2b3b4b5b6b7b8b9cb2c255f3e3fbabbbcbdbebfc0c1c2603a2340273d22" +
+        "c3616263646566676869c4c5c6c7c8c9ca6a6b6c6d6e6f7071725ecccdcecfd0" +
+        "d1e5737475767778797ad2d3d45bd6d7d8d9dadbdcdddedfe0e1e2e3e45de6e7" +
+        "7b414243444546474849e8e9eaebeced7d4a4b4c4d4e4f505152eeeff0f1f2f3" +
+        "5c9f535455565758595af4f5f6f7f8f930313233343536373839fafbfcfdfeff",
+    ebcdic: "00010203372d2e2f1605250b0c0d0e0f101112133c3d322618193f271c1d1e1f" +
+        "405a7f7b5b6c507d4d5d5c4e6b604b61f0f1f2f3f4f5f6f7f8f97a5e4c7e6e6f" +
+        "7cc1c2c3c4c5c6c7c8c9d1d2d3d4d5d6d7d8d9e2e3e4e5e6e7e8e9ade0bd9a6d" +
+        "79818283848586878889919293949596979899a2a3a4a5a6a7a8a9c04fd05f07" +
+        "202122232415061728292a2b2c090a1b30311a333435360838393a3b04143ee1" +
+        "4142434445464748495152535455565758596263646566676869707172737475" +
+        "767778808a8b8c8d8e8f906a9b9c9d9e9fa0aaabac4aaeafb0b1b2b3b4b5b6b7" +
+        "b8b9babbbca1bebfcacbcccdcecfdadbdcdddedfeaebecedeeeffafbfcfdfeff",
+    ibm: "00010203372d2e2f1605250b0c0d0e0f101112133c3d322618193f271c1d1e1f" +
+        "405a7f7b5b6c507d4d5d5c4e6b604b61f0f1f2f3f4f5f6f7f8f97a5e4c7e6e6f" +
+        "7cc1c2c3c4c5c6c7c8c9d1d2d3d4d5d6d7d8d9e2e3e4e5e6e7e8e9ade0bd5f6d" +
+        "79818283848586878889919293949596979899a2a3a4a5a6a7a8a9c04fd0a107" +
+        "202122232415061728292a2b2c090a1b30311a333435360838393a3b04143ee1" +
+        "4142434445464748495152535455565758596263646566676869707172737475" +
+        "767778808a8b8c8d8e8f909a9b9c9d9e9fa0aaabacadaeafb0b1b2b3b4b5b6b7" +
+        "b8b9babbbcbdbebfcacbcccdcecfdadbdcdddedfeaebecedeeeffafbfcfdfeff",
+};
+export class DdConverter {
+    plan;
+    stats;
+    emit;
+    table = Uint8Array.from({ length: 256 }, (_, index) => index);
+    newline;
+    space;
+    saved;
+    column = 0;
+    spaces = 0;
+    buffer;
+    used = 0;
+    constructor(plan, stats, emit, chunkSize) {
+        this.plan = plan;
+        this.stats = stats;
+        this.emit = emit;
+        const translate = (name, byte) => Number.parseInt(encodings[name].slice(byte * 2, byte * 2 + 2), 16);
+        for (let index = 0; index < 256; index++) {
+            let value = plan.convert.has("ascii") ? translate("ascii", index) : index;
+            if (plan.convert.has("lcase") && value >= 65 && value <= 90)
+                value += 32;
+            if (plan.convert.has("ucase") && value >= 97 && value <= 122)
+                value -= 32;
+            if (plan.convert.has("ebcdic"))
+                value = translate("ebcdic", value);
+            if (plan.convert.has("ibm"))
+                value = translate("ibm", value);
+            this.table[index] = value;
+        }
+        this.newline = plan.convert.has("ebcdic") || plan.convert.has("ibm") ? 37 : 10;
+        this.space = plan.convert.has("ebcdic") || plan.convert.has("ibm") ? 64 : 32;
+        this.buffer = new Uint8Array(chunkSize);
+    }
+    async output(byte) {
+        this.buffer[this.used++] = byte;
+        if (this.used === this.buffer.length) {
+            await this.emit(this.buffer);
+            this.used = 0;
+        }
+    }
+    async record(byte) {
+        const width = Number(this.plan.cbs);
+        if (this.plan.convert.has("block")) {
+            if (byte === this.newline) {
+                while (this.column < width) {
+                    await this.output(this.space);
+                    this.column++;
+                }
+                this.column = 0;
+            }
+            else {
+                if (this.column < width)
+                    await this.output(byte);
+                else if (this.column === width)
+                    this.stats.truncated++;
+                this.column = Math.min(width + 1, this.column + 1);
+            }
+        }
+        else if (this.plan.convert.has("unblock")) {
+            if (this.column === width) {
+                await this.output(this.newline);
+                this.column = 0;
+                this.spaces = 0;
+            }
+            this.column++;
+            if (byte === this.space)
+                this.spaces++;
+            else {
+                while (this.spaces > 0) {
+                    await this.output(this.space);
+                    this.spaces--;
+                }
+                await this.output(byte);
+            }
+        }
+        else
+            await this.output(byte);
+    }
+    async push(input) {
+        if (!["swab", "block", "unblock"].some(conversion => this.plan.convert.has(conversion))) {
+            for (let offset = 0; offset < input.length; offset += this.buffer.length) {
+                const count = Math.min(this.buffer.length, input.length - offset);
+                for (let index = 0; index < count; index++)
+                    this.buffer[index] = this.table[input[offset + index]];
+                await this.emit(this.buffer.subarray(0, count));
+            }
+            return;
+        }
+        for (const byte of input) {
+            const value = this.table[byte];
+            if (this.plan.convert.has("swab")) {
+                if (this.saved === undefined)
+                    this.saved = value;
+                else {
+                    await this.record(value);
+                    await this.record(this.saved);
+                    this.saved = undefined;
+                }
+            }
+            else
+                await this.record(value);
+        }
+        if (this.used) {
+            await this.emit(this.buffer.subarray(0, this.used));
+            this.used = 0;
+        }
+    }
+    async finish() {
+        if (this.saved !== undefined) {
+            await this.record(this.saved);
+            this.saved = undefined;
+        }
+        if (this.plan.convert.has("block") && this.column > 0) {
+            while (this.column < Number(this.plan.cbs)) {
+                await this.output(this.space);
+                this.column++;
+            }
+        }
+        if (this.plan.convert.has("unblock") && this.column)
+            await this.output(this.newline);
+        if (this.used) {
+            await this.emit(this.buffer.subarray(0, this.used));
+            this.used = 0;
+        }
+    }
+}

package/dist/safe-bash/opt-in/commands/dd/index.d.ts

@@ -0,0 +1,18 @@
+import type { CommandDefinition } from "@poe-platform/safe-bash/contracts/command";
+import type { VirtualShellPlugin } from "@poe-platform/safe-bash/contracts/plugin";
+import { type DdFileOpener } from "./io.js";
+export { openDdFile } from "./io.js";
+export type { DdFileHandle, DdFileOpener, DdFileRequest } from "./io.js";
+export interface DdCommandsOptions {
+    readonly replace?: boolean | undefined;
+    readonly maxBlockBytes?: number | undefined;
+    readonly maxBufferBytes?: number | undefined;
+    readonly maxTransferBytes?: number | undefined;
+    readonly maxReadOperations?: number | undefined;
+    readonly maxArgumentBytes?: number | undefined;
+    readonly now?: (() => number) | undefined;
+    readonly openFile?: DdFileOpener | undefined;
+}
+export declare function createDdCommand(options?: DdCommandsOptions): CommandDefinition;
+export declare function createDdCommands(options?: DdCommandsOptions): readonly CommandDefinition[];
+export declare function ddCommands(options?: DdCommandsOptions): VirtualShellPlugin;