@poe-platform/safe-bash 0.1.788 → 0.1.789

package/dist/safe-bash/commands/docx/index.browser.js

@@ -1,56 +1,13 @@
-import {
-  contracts_exports
-} from "../../chunks/chunk-FJZNUUOQ.js";
-import "../../chunks/chunk-O6356Z27.js";
-import {
-  command_exports
-} from "../../chunks/chunk-T3VDYWKZ.js";
 import {
   init_platform
 } from "../../chunks/chunk-Q45QCA4J.js";
 
 // packages/safe-bash/src/commands/docx/index.ts
 init_platform();
-function createDocxCommand(options) {
-  if (!options?.engine || typeof options.engine.execute !== "function")
-    throw new TypeError("An explicit docx command engine is required.");
-  if (options.replace !== void 0 && typeof options.replace !== "boolean")
-    throw new TypeError("docx replace must be boolean.");
-  const engine = options.engine;
-  return {
-    name: "docx",
-    async execute(context) {
-      context.signal.throwIfAborted();
-      const arguments_ = (0, contracts_exports.getCommandArguments)(context);
-      const result = await engine.execute({
-        args: Object.freeze(arguments_.args.map((_, index) => arguments_.bytes(index))),
-        cwd: context.cwd,
-        filesystem: context.fs,
-        stdin: context.stdin,
-        ...context.stdinIsDefault === void 0 ? {} : { stdinIsDefault: context.stdinIsDefault },
-        stdout: context.stdout,
-        stderr: context.stderr,
-        signal: context.signal,
-        ...context.registerCleanup === void 0 ? {} : { registerCleanup: context.registerCleanup }
-      });
-      context.signal.throwIfAborted();
-      return { exitCode: (0, command_exports.validateExitCode)(result.exitCode) };
-    }
-  };
-}
-function docxCommands(options) {
-  const command = createDocxCommand(options);
-  const replace = options.replace ?? false;
-  return {
-    name: "docx-commands",
-    setup(host) {
-      if (!replace && host.commands.has(command.name))
-        throw new Error("Command already registered: docx");
-      host.commands.register(command, { replace });
-    }
-  };
-}
+export * from "../../../safe-bash-command-docx/index.js";
+import { createDocxCommand, createDocxCommands, docxCommands } from "../../../safe-bash-command-docx/index.js";
 export {
   createDocxCommand,
+  createDocxCommands,
   docxCommands
 };

package/dist/safe-bash/commands/docx/index.d.ts

@@ -1,25 +1,3 @@
-import { type ByteSink, type ByteSource, type CommandContext, type CommandDefinition, type FileSystem, type VirtualShellPlugin } from "../../contracts/index.js";
-/** Explicit invocation capabilities for an injected document operation engine. */
-export interface DocxCommandRequest {
-    readonly args: readonly Uint8Array[];
-    readonly cwd: string;
-    readonly filesystem: FileSystem;
-    readonly stdin: ByteSource;
-    readonly stdinIsDefault?: boolean;
-    readonly stdout: ByteSink;
-    readonly stderr: ByteSink;
-    readonly signal: AbortSignal;
-    readonly registerCleanup?: CommandContext["registerCleanup"];
-}
-export interface DocxCommandEngine {
-    execute(request: DocxCommandRequest): Promise<{
-        readonly exitCode: number;
-    }>;
-}
-export interface DocxCommandOptions {
-    readonly engine: DocxCommandEngine;
-    readonly replace?: boolean;
-}
-export declare function createDocxCommand(options: DocxCommandOptions): CommandDefinition;
-export declare function docxCommands(options: DocxCommandOptions): VirtualShellPlugin;
+export * from "../../../safe-bash-command-docx/index.js";
+export { createDocxCommand, createDocxCommands, docxCommands } from "../../../safe-bash-command-docx/index.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/safe-bash/commands/docx/index.js

@@ -1,42 +1,3 @@
-import { getCommandArguments } from "../../contracts/index.js";
-import { validateExitCode } from "../../contracts/command.js";
-export function createDocxCommand(options) {
-    if (!options?.engine || typeof options.engine.execute !== "function")
-        throw new TypeError("An explicit docx command engine is required.");
-    if (options.replace !== undefined && typeof options.replace !== "boolean")
-        throw new TypeError("docx replace must be boolean.");
-    const engine = options.engine;
-    return {
-        name: "docx",
-        async execute(context) {
-            context.signal.throwIfAborted();
-            const arguments_ = getCommandArguments(context);
-            const result = await engine.execute({
-                args: Object.freeze(arguments_.args.map((_, index) => arguments_.bytes(index))),
-                cwd: context.cwd,
-                filesystem: context.fs,
-                stdin: context.stdin,
-                ...(context.stdinIsDefault === undefined ? {} : { stdinIsDefault: context.stdinIsDefault }),
-                stdout: context.stdout,
-                stderr: context.stderr,
-                signal: context.signal,
-                ...(context.registerCleanup === undefined ? {} : { registerCleanup: context.registerCleanup })
-            });
-            context.signal.throwIfAborted();
-            return { exitCode: validateExitCode(result.exitCode) };
-        }
-    };
-}
-export function docxCommands(options) {
-    const command = createDocxCommand(options);
-    const replace = options.replace ?? false;
-    return {
-        name: "docx-commands",
-        setup(host) {
-            if (!replace && host.commands.has(command.name))
-                throw new Error("Command already registered: docx");
-            host.commands.register(command, { replace });
-        }
-    };
-}
+export * from "../../../safe-bash-command-docx/index.js";
+export { createDocxCommand, createDocxCommands, docxCommands } from "../../../safe-bash-command-docx/index.js";
 //# sourceMappingURL=index.js.map

package/dist/safe-bash/commands/docx/io.d.ts

@@ -1,15 +1,2 @@
-import { type ByteSink, type ByteSource } from "../../contracts/io.js";
-import type { CommandContext } from "../../contracts/command.js";
-export declare function documentByteSource(source: ByteSource): {
-    open(signal: AbortSignal): AsyncIterable<Uint8Array>;
-};
-export declare function documentByteSink(sink: ByteSink): {
-    write(bytes: Uint8Array, signal: AbortSignal): Promise<void>;
-};
-export declare function createDocumentOutput(context: Pick<CommandContext, "signal" | "registerCleanup">, destination: ByteSink): {
-    readonly sink: {
-        write(bytes: Uint8Array, signal: AbortSignal): Promise<void>;
-    };
-    readonly cleanup: () => Promise<void>;
-};
+export * from "../../../safe-bash-command-docx/io.js";
 //# sourceMappingURL=io.d.ts.map

package/dist/safe-bash/commands/docx/io.js

@@ -1,16 +1,2 @@
-import { readBytes, writeBytes } from "../../contracts/io.js";
-import { createOutputOperation } from "../../contracts/output.js";
-export function documentByteSource(source) {
-    return { open: signal => readBytes(source, signal) };
-}
-export function documentByteSink(sink) {
-    return { write: (bytes, signal) => writeBytes(sink, bytes, signal) };
-}
-export function createDocumentOutput(context, destination) {
-    const operation = createOutputOperation(context, destination);
-    return {
-        sink: documentByteSink(operation.output),
-        cleanup: operation.close,
-    };
-}
+export * from "../../../safe-bash-command-docx/io.js";
 //# sourceMappingURL=io.js.map

package/dist/safe-bash/commands/llm/index.browser.js

@@ -2,11 +2,11 @@ import {
   createLlmCommands,
   createLlmService,
   llmCommands
-} from "../../chunks/chunk-WHURJBET.js";
+} from "../../chunks/chunk-2MUJ7RLZ.js";
 import "../../chunks/chunk-2G2T5MEM.js";
-import "../../chunks/chunk-FJZNUUOQ.js";
+import "../../chunks/chunk-VUVKC6HV.js";
 import "../../chunks/chunk-LAPF2XE6.js";
-import "../../chunks/chunk-O6356Z27.js";
+import "../../chunks/chunk-H7MMJS26.js";
 import "../../chunks/chunk-T3VDYWKZ.js";
 import "../../chunks/chunk-GJWUEOT6.js";
 import {

package/dist/safe-bash/commands/network/index.browser.js

@@ -12,12 +12,12 @@ import {
   evalSyncCurl,
   evalSyncWget,
   networkCommands
-} from "../../chunks/chunk-ZMYVCRAF.js";
+} from "../../chunks/chunk-X5ZCECM6.js";
 import "../../chunks/chunk-BI6JV62X.js";
 import "../../chunks/chunk-2G2T5MEM.js";
-import "../../chunks/chunk-FJZNUUOQ.js";
+import "../../chunks/chunk-VUVKC6HV.js";
 import "../../chunks/chunk-LAPF2XE6.js";
-import "../../chunks/chunk-O6356Z27.js";
+import "../../chunks/chunk-H7MMJS26.js";
 import "../../chunks/chunk-T3VDYWKZ.js";
 import "../../chunks/chunk-GJWUEOT6.js";
 import "../../chunks/chunk-Q45QCA4J.js";

package/dist/safe-bash/commands/node/index.browser.js

@@ -2,11 +2,11 @@ import {
   createSafeJsNodeCommand,
   createSafeJsNodeCommands,
   safeJsNodeCommands
-} from "../../chunks/chunk-PYTLIUST.js";
+} from "../../chunks/chunk-CTUHLNJM.js";
 import "../../chunks/chunk-2G2T5MEM.js";
-import "../../chunks/chunk-FJZNUUOQ.js";
+import "../../chunks/chunk-VUVKC6HV.js";
 import "../../chunks/chunk-LAPF2XE6.js";
-import "../../chunks/chunk-O6356Z27.js";
+import "../../chunks/chunk-H7MMJS26.js";
 import "../../chunks/chunk-T3VDYWKZ.js";
 import "../../chunks/chunk-GJWUEOT6.js";
 import "../../chunks/chunk-Q45QCA4J.js";

package/dist/safe-bash/commands/pptx/index.d.ts

@@ -1,29 +1,3 @@
-import { type CommandDefinition, type VirtualShellPlugin } from "../../contracts/index.js";
-export interface PptxCommandEngine {
-    execute(request: {
-        readonly args: readonly Uint8Array[];
-        readonly signal: AbortSignal;
-        readonly readInput: (path: string, maxBytes: number) => Promise<Uint8Array>;
-        readonly publishOutput?: (publication: {
-            readonly inputPath?: string;
-            readonly protectedInputPaths?: readonly string[];
-            readonly outputPath: string;
-            readonly bytes: Uint8Array;
-            readonly originalBytes: Uint8Array;
-            readonly inPlace: boolean;
-            readonly force: boolean;
-            readonly dryRun: boolean;
-        }) => Promise<void>;
-    }): Promise<{
-        readonly exitCode: number;
-        readonly stdout: Uint8Array;
-        readonly stderr: Uint8Array;
-    }>;
-}
-export interface PptxCommandsOptions {
-    readonly engine: PptxCommandEngine;
-    readonly replace?: boolean;
-}
-export declare function createPptxCommands(options: PptxCommandsOptions): readonly CommandDefinition[];
-export declare function pptxCommands(options: PptxCommandsOptions): VirtualShellPlugin;
+export * from "../../../safe-bash-command-pptx/index.js";
+export { createPptxCommand, createPptxCommands, pptxCommands } from "../../../safe-bash-command-pptx/index.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/safe-bash/commands/pptx/index.js

@@ -1,153 +1,3 @@
-import { collectBytes, FsError, getCommandArguments, writeBytes } from "../../contracts/index.js";
-import { writeFileOutput } from "../../contracts/filesystem-output.js";
-import { compareObservedEntries } from "../copy-identity.js";
-import { pathOf } from "../internal.js";
-import { inputRequirements } from "../portable-requirements.js";
-export function createPptxCommands(options) {
-    if (!options?.engine || typeof options.engine.execute !== "function")
-        throw new TypeError("An explicit pptx command engine is required.");
-    if (options.replace !== undefined && typeof options.replace !== "boolean")
-        throw new TypeError("pptx replace must be boolean");
-    const engine = options.engine;
-    return [{ name: "pptx", filesystemRequirements: inputRequirements, async execute(context) {
-                const arguments_ = getCommandArguments(context);
-                const snapshots = new Map();
-                const result = await engine.execute({
-                    args: arguments_.args.map((_, index) => arguments_.bytes(index)),
-                    signal: context.signal,
-                    async readInput(path, maxBytes) {
-                        try {
-                            context.signal.throwIfAborted();
-                            if (path === "-")
-                                return await collectBytes(context.stdin, { maxBytes, signal: context.signal });
-                            const resolved = pathOf(context, path);
-                            if (!snapshots.has(resolved)) {
-                                try {
-                                    snapshots.set(resolved, await context.fs.lstat(resolved, { signal: context.signal }));
-                                }
-                                catch {
-                                    context.signal.throwIfAborted();
-                                }
-                            }
-                            const capabilities = await context.fs.capabilitiesFor?.(resolved, { signal: context.signal }) ?? context.fs.capabilities;
-                            context.signal.throwIfAborted();
-                            if (context.fs.readStream && capabilities.streamingRead !== false) {
-                                let emitted = false;
-                                try {
-                                    const stream = context.fs.readStream(resolved, { signal: context.signal });
-                                    return await collectBytes((async function* () {
-                                        for await (const chunk of stream) {
-                                            if (chunk.byteLength)
-                                                emitted = true;
-                                            yield chunk;
-                                        }
-                                    })(), { maxBytes, signal: context.signal });
-                                }
-                                catch (error) {
-                                    context.signal.throwIfAborted();
-                                    if (emitted || !(error instanceof FsError) || error.code !== "ENOTSUP")
-                                        throw error;
-                                }
-                            }
-                            if (capabilities.read === false)
-                                throw new FsError("ENOTSUP");
-                            const bytes = await context.fs.readFile(resolved, { maxBytes, signal: context.signal });
-                            context.signal.throwIfAborted();
-                            if (bytes.byteLength > maxBytes)
-                                throw new FsError("EFBIG");
-                            return bytes;
-                        }
-                        catch (error) {
-                            context.signal.throwIfAborted();
-                            throw Object.assign(new Error("Input could not be read."), { code: error instanceof FsError && error.code === "EFBIG" ? "resource-limit" : "io-failure" });
-                        }
-                    },
-                    async publishOutput(publication) {
-                        try {
-                            const { fs, signal } = context;
-                            signal.throwIfAborted();
-                            const input = publication.inputPath === undefined || publication.inputPath === "-" ? undefined : pathOf(context, publication.inputPath);
-                            const output = pathOf(context, publication.outputPath);
-                            if (publication.inPlace ? !input || input !== output : input === output)
-                                throw new FsError("EINVAL");
-                            const capabilities = await fs.capabilitiesFor?.(output, { signal }) ?? fs.capabilities;
-                            signal.throwIfAborted();
-                            if (capabilities.readOnly === true || capabilities.write === false || !capabilities.atomicFileMutation || !fs.writeFileConditional)
-                                throw new FsError("ENOTSUP");
-                            let destination;
-                            try {
-                                destination = await fs.lstat(output, { signal });
-                            }
-                            catch (error) {
-                                signal.throwIfAborted();
-                                if (!(error instanceof FsError) || error.code !== "ENOENT")
-                                    throw error;
-                                destination = null;
-                            }
-                            if (destination && destination.type !== "file")
-                                throw new FsError("EINVAL");
-                            if (destination) {
-                                const protectedInputs = new Set((publication.protectedInputPaths ?? []).filter(path => path !== "-").map(path => pathOf(context, path)));
-                                for (const [source, observed] of snapshots) {
-                                    if (source === input && !protectedInputs.has(source))
-                                        continue;
-                                    const identity = observed.type === "symlink" ? await fs.stat(source, { signal }) : observed;
-                                    if (source === output || await compareObservedEntries(fs, source, identity, fs, output, destination, { signal }) !== "distinct")
-                                        throw new FsError("EINVAL");
-                                }
-                            }
-                            if (destination && !publication.inPlace) {
-                                if (!publication.force)
-                                    throw new FsError("EEXIST");
-                                if (input && await compareObservedEntries(fs, input, await fs.stat(input, { signal }), fs, output, destination, { signal }) !== "distinct")
-                                    throw new FsError("EINVAL");
-                            }
-                            const parentPath = output.slice(0, output.lastIndexOf("/")) || "/";
-                            const parent = await fs.stat(parentPath, { signal });
-                            if (parent.type !== "directory")
-                                throw new FsError("ENOTDIR");
-                            if (publication.inPlace) {
-                                const original = snapshots.get(input);
-                                if (!original || original.type !== "file" || !destination || original.revision === undefined
-                                    || original.revision !== destination.revision || original.size !== destination.size
-                                    || original.mode !== destination.mode || original.nlink !== destination.nlink
-                                    || original.mtimeMs !== destination.mtimeMs || original.ctimeMs !== destination.ctimeMs
-                                    || await compareObservedEntries(fs, input, original, fs, output, destination, { signal }) !== "same")
-                                    throw new FsError("EAGAIN");
-                                const current = await fs.readFile(input, { maxBytes: publication.originalBytes.length, signal });
-                                if (current.length !== publication.originalBytes.length || current.some((byte, index) => byte !== publication.originalBytes[index]))
-                                    throw new FsError("EAGAIN");
-                                destination = original;
-                            }
-                            signal.throwIfAborted();
-                            if (!publication.dryRun)
-                                await writeFileOutput(context, publication.bytes, async (bytes) => {
-                                    await fs.writeFileConditional(output, bytes, { parent, expected: destination, signal });
-                                });
-                        }
-                        catch (error) {
-                            context.signal.throwIfAborted();
-                            const code = error instanceof FsError && error.code === "EAGAIN" ? "stale-input"
-                                : error instanceof FsError && error.code === "ENOTSUP" ? "publication-unsupported" : "io-failure";
-                            throw Object.assign(new Error("Output could not be published."), { code });
-                        }
-                    }
-                });
-                if (result.stdout.length)
-                    await writeBytes(context.stdout, result.stdout, context.signal);
-                if (result.stderr.length)
-                    await writeBytes(context.stderr, result.stderr, context.signal);
-                return { exitCode: result.exitCode };
-            } }];
-}
-export function pptxCommands(options) {
-    const commands = createPptxCommands(options);
-    const replace = options.replace ?? false;
-    return { name: "pptx-commands", setup(host) {
-            if (!replace && host.commands.has("pptx"))
-                throw new Error("Command already registered: pptx");
-            for (const command of commands)
-                host.commands.register(command, { replace });
-        } };
-}
+export * from "../../../safe-bash-command-pptx/index.js";
+export { createPptxCommand, createPptxCommands, pptxCommands } from "../../../safe-bash-command-pptx/index.js";
 //# sourceMappingURL=index.js.map

package/dist/safe-bash/commands/printf-float.d.ts

@@ -1,5 +1,6 @@
 export declare function parsePrintfFloat(operand: string): {
     value: number;
     special?: string;
+    error?: string;
 } | undefined;
 //# sourceMappingURL=printf-float.d.ts.map

package/dist/safe-bash/commands/printf-float.js

@@ -1,18 +1,36 @@
-// Parse C floating operands without a host libc or shell fallback.
+// Parse the C numeric prefix while retaining trailing-input diagnostics.
 export function parsePrintfFloat(operand) {
-    const token = operand.trim().toLowerCase();
+    let start = 0;
+    while (start < operand.length && " \t\n\r\v\f".includes(operand[start]))
+        start++;
+    let end = operand.length;
+    while (end > start && " \t\n\r\v\f".includes(operand[end - 1]))
+        end--;
+    const token = operand.slice(start, end).toLowerCase();
     if (token.length > 4096)
         return undefined;
     const negative = token.startsWith("-");
     const magnitude = token.startsWith("+") || negative ? token.slice(1) : token;
-    const payload = magnitude.startsWith("nan(") && magnitude.endsWith(")") ? magnitude.slice(4, -1) : undefined;
-    const nan = magnitude === "nan" || payload !== undefined && [...payload].every(char => "abcdefghijklmnopqrstuvwxyz0123456789_".includes(char));
-    if (nan || magnitude === "inf" || magnitude === "infinity") {
-        return { value: nan ? NaN : negative ? -Infinity : Infinity, special: (negative ? "-" : "") + (nan ? "nan" : "inf") };
+    const converted = (value, end, special) => ({
+        value, ...(special === undefined ? {} : { special }), ...(end < magnitude.length || operand.length > start + token.length ? { error: "invalid number" } : {}),
+    });
+    if (magnitude.startsWith("inf")) {
+        return converted(negative ? -Infinity : Infinity, magnitude.startsWith("infinity") ? 8 : 3, (negative ? "-" : "") + "inf");
     }
-    if (!magnitude.startsWith("0x")) {
-        let offset = 0;
-        let digits = 0;
+    if (magnitude.startsWith("nan")) {
+        let end = 3;
+        if (magnitude[end] === "(") {
+            let offset = end + 1;
+            while (offset < magnitude.length && "abcdefghijklmnopqrstuvwxyz0123456789_".includes(magnitude[offset]))
+                offset++;
+            if (magnitude[offset] === ")")
+                end = offset + 1;
+        }
+        return converted(NaN, end, (negative ? "-" : "") + "nan");
+    }
+    const hexadecimal = magnitude.startsWith("0x") && ("0123456789abcdef".includes(magnitude[2] ?? "!") || magnitude[2] === "." && "0123456789abcdef".includes(magnitude[3] ?? "!"));
+    if (!hexadecimal) {
+        let offset = 0, digits = 0;
         while (offset < magnitude.length && "0123456789".includes(magnitude[offset])) {
             offset++;
             digits++;
@@ -27,64 +45,56 @@ export function parsePrintfFloat(operand) {
         if (!digits)
             return undefined;
         if (magnitude[offset] === "e") {
-            offset++;
+            const exponentStart = offset++;
             if (magnitude[offset] === "+" || magnitude[offset] === "-")
                 offset++;
-            const start = offset;
+            const firstDigit = offset;
             while (offset < magnitude.length && "0123456789".includes(magnitude[offset]))
                 offset++;
-            if (offset === start)
-                return undefined;
+            if (offset === firstDigit)
+                offset = exponentStart;
         }
-        if (offset !== magnitude.length)
-            return undefined;
-        const value = Number(operand);
-        return Number.isFinite(value) ? { value } : undefined;
+        const value = Number((negative ? "-" : "") + magnitude.slice(0, offset));
+        return Number.isFinite(value) ? converted(value, offset) : undefined;
     }
-    let offset = 2;
-    let digits = "";
-    let fractionDigits = 0;
-    let point = false;
+    let offset = 2, digits = "", fractionDigits = 0, point = false;
     while (offset < magnitude.length) {
-        const char = magnitude[offset];
-        if ("0123456789abcdef".includes(char)) {
-            digits += char;
+        const character = magnitude[offset];
+        if ("0123456789abcdef".includes(character)) {
+            digits += character;
             if (point)
                 fractionDigits++;
         }
-        else if (char === "." && !point)
+        else if (character === "." && !point)
             point = true;
         else
             break;
         offset++;
     }
-    if (!digits)
-        return undefined;
     let exponent = 0;
-    if (offset < magnitude.length) {
-        if (magnitude[offset++] !== "p")
-            return undefined;
-        const start = offset;
+    if (magnitude[offset] === "p") {
+        const exponentStart = offset++;
+        const numberStart = offset;
         if (magnitude[offset] === "+" || magnitude[offset] === "-")
             offset++;
         const firstDigit = offset;
         while (offset < magnitude.length && "0123456789".includes(magnitude[offset]))
             offset++;
-        if (offset === firstDigit || offset !== magnitude.length)
-            return undefined;
-        exponent = Number(magnitude.slice(start));
+        if (offset === firstDigit)
+            offset = exponentStart;
+        else
+            exponent = Number(magnitude.slice(numberStart, offset));
     }
     const significand = BigInt("0x" + digits);
     if (significand === 0n)
-        return { value: negative ? -0 : 0 };
+        return converted(negative ? -0 : 0, offset);
     const bits = significand.toString(2).length;
     const scale = exponent - fractionDigits * 4;
     const top = bits - 1 + scale;
     if (top > 1023)
         return undefined;
     if (top < -1075)
-        return { value: negative ? -0 : 0 };
-    // Round once to binary64, including the fixed subnormal quantum.
+        return converted(negative ? -0 : 0, offset);
     const shift = Math.max(bits - 53, -1074 - scale);
     let rounded = significand;
     if (shift > 0) {
@@ -95,6 +105,6 @@ export function parsePrintfFloat(operand) {
             rounded++;
     }
     const value = Number(rounded) * 2 ** (scale + Math.max(0, shift)) * (negative ? -1 : 1);
-    return Number.isFinite(value) ? { value } : undefined;
+    return Number.isFinite(value) ? converted(value, offset) : undefined;
 }
 //# sourceMappingURL=printf-float.js.map

package/dist/safe-bash/commands/printf-format.js

@@ -37,14 +37,17 @@ export async function parsePrintfDirective(format, start, signal) {
         offset++;
         precision = await field();
     }
-    const length = character();
-    if (length && "hlLjzt".includes(length)) {
+    let wide = false;
+    for (let modifier = character(); modifier && "hlLjzt".includes(modifier); modifier = character()) {
+        wide ||= modifier === "l";
         offset++;
-        if ((length === "h" || length === "l") && character() === length)
-            offset++;
+        if ((offset - start) % 1024 === 0)
+            await yieldTurn(signal);
     }
-    const specifier = character();
-    if (!specifier || !"sbqcdiouxXfFeEgGaA".includes(specifier)) {
+    let specifier = character();
+    if (wide && (specifier === "s" || specifier === "c"))
+        specifier = specifier.toUpperCase();
+    if (!specifier || !"sbqQcCSdiouxXfFeEgGaA".includes(specifier)) {
         const end = start + 64;
         const preview = typeof format === "string" ? format.slice(start, end) : decoder.decode(format.subarray(start, end));
         throw new UsageError(`invalid format near '${preview}${format.length > end ? "..." : ""}'`);

package/dist/safe-bash/commands/printf-quote.d.ts

@@ -0,0 +1,3 @@
+/** Preserve valid printable UTF-8 units even beside invalid octets. */
+export declare function quotePrintf(bytes: Uint8Array, utf8: boolean, signal: AbortSignal, alternate?: boolean): Promise<Uint8Array>;
+//# sourceMappingURL=printf-quote.d.ts.map