@poe-platform/safe-bash 0.1.802 → 0.1.804

package/dist/safe-bash/command-chunks/{chunk-LWSBAWLT.js → chunk-TXI64OAG.js}

@@ -1,6 +1,6 @@
 import {
   Parser
-} from "./chunk-LWS62ISU.js";
+} from "./chunk-N6DIASO2.js";
 import {
   init_buffer
 } from "./chunk-HX3SHTCE.js";

package/dist/safe-bash/command-chunks/chunk-TZRI7BJZ.js

@@ -0,0 +1,496 @@
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-stat/src/command.ts
+init_buffer();
+import { FsError } from "../../safe-bash-contracts/index.js";
+import { codeOf, diagnostic, pathOf, requireOperands, UsageError } from "../../safe-bash-io-engine/internal.js";
+import { MetadataBudget, metadataCommand, permissionString, settings } from "../../safe-bash-metadata-engine/index.js";
+var syncStatEncoder = new TextEncoder();
+function concatBytes(chunks) {
+  if (chunks.length === 0) return new Uint8Array(0);
+  if (chunks.length === 1) return chunks[0];
+  let total = 0;
+  for (let i = 0; i < chunks.length; i++) total += chunks[i].byteLength;
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (let i = 0; i < chunks.length; i++) {
+    const c = chunks[i];
+    out.set(c, offset);
+    offset += c.byteLength;
+  }
+  return out;
+}
+function allocSpaces(length) {
+  const out = new Uint8Array(length);
+  out.fill(32);
+  return out;
+}
+function parse(args) {
+  let follow = false;
+  let filesystem = false;
+  let terse = false;
+  let format;
+  let printf = false;
+  let bsd = false;
+  let literal = false;
+  const paths = [];
+  for (let index = 0; index < args.length; index++) {
+    const argument = args[index];
+    if (literal || argument === "-" || !argument.startsWith("-")) paths.push(argument);
+    else if (argument === "--") literal = true;
+    else if (argument === "--dereference") follow = true;
+    else if (argument === "--cached=default" || argument === "--cached=never" || argument === "--cached=always") continue;
+    else if (argument === "--file-system") filesystem = true;
+    else if (argument === "--terse") terse = true;
+    else if (argument === "--format" || argument.startsWith("--format=") || argument === "--printf" || argument.startsWith("--printf=")) {
+      bsd = false;
+      printf = argument.startsWith("--printf");
+      format = argument.includes("=") ? argument.slice(argument.indexOf("=") + 1) : args[++index];
+      if (format === void 0) throw new UsageError(`missing format for '${argument}'`);
+    } else if (!argument.startsWith("--")) {
+      for (let offset = 1; offset < argument.length; offset++) {
+        if (argument[offset] === "L") follow = true;
+        else if (argument[offset] === "f") {
+          const next = args[index + 1];
+          const formatOption = next?.startsWith("-c") || next?.startsWith("--format=") || next?.startsWith("--printf=");
+          if (offset === argument.length - 1 && next?.includes("%") && !formatOption && index + 2 < args.length) {
+            format = args[++index];
+            bsd = true;
+            filesystem = false;
+            printf = false;
+          } else filesystem = true;
+        } else if (argument[offset] === "t") terse = true;
+        else if (argument[offset] === "c") {
+          format = argument.slice(offset + 1) || args[++index];
+          if (format === void 0) throw new UsageError("missing format for '-c'");
+          printf = false;
+          bsd = false;
+          break;
+        } else throw new UsageError(`unrecognized option '${argument}'`);
+      }
+    } else throw new UsageError(`unrecognized option '${argument}'`);
+  }
+  requireOperands(paths);
+  return { follow, filesystem, terse, format, printf, paths, bsd };
+}
+function quoted(text, style) {
+  if (style === "literal") return text;
+  if (style && !["shell-escape-always", "shell-always"].includes(style)) throw new FsError("ENOTSUP", { message: `unsupported QUOTING_STYLE: ${style}` });
+  if (style !== "shell-always" && /[\x00-\x1f\x7f]/u.test(text)) {
+    return "$'" + text.replace(/[\\'\x00-\x1f\x7f]/gu, (character) => {
+      if (character === "\\" || character === "'") return `\\${character}`;
+      if (character === "\n") return "\\n";
+      if (character === "\r") return "\\r";
+      if (character === "	") return "\\t";
+      return `\\${character.charCodeAt(0).toString(8).padStart(3, "0")}`;
+    }) + "'";
+  }
+  return `'${text.replace(/'/gu, "'\\''")}'`;
+}
+function available(value, field) {
+  if (value === void 0) throw new FsError("ENOTSUP", { syscall: "stat", message: `filesystem does not expose ${field}` });
+  if (!Number.isFinite(value)) throw new FsError("EIO", { syscall: "stat", message: `invalid ${field}` });
+  return value;
+}
+function timestamp(milliseconds) {
+  const value = available(milliseconds, "timestamp");
+  if (Math.abs(value) > 864e13) throw new FsError("EIO", { message: "invalid filesystem timestamp" });
+  const [coefficient = "0", exponent = "0"] = Math.abs(value).toString().split("e");
+  const [integer = "0", fraction = ""] = coefficient.split(".");
+  const digits = BigInt(integer + fraction);
+  const power = Number(exponent) - fraction.length + 6;
+  const divisor = power < 0 ? 10n ** BigInt(-power) : 1n;
+  const magnitude = power < 0 ? (digits + divisor / 2n) / divisor : digits * 10n ** BigInt(power);
+  const nanoseconds = value < 0 ? -magnitude : magnitude;
+  const remainder = (nanoseconds % 1000000000n + 1000000000n) % 1000000000n;
+  const seconds = (nanoseconds - remainder) / 1000000000n;
+  const date = new Date(Number(seconds * 1000n));
+  if (Number.isNaN(date.getTime())) throw new FsError("EIO", { message: "invalid filesystem timestamp" });
+  return `${date.toISOString().replace("T", " ").replace(/\.\d{3}Z$/u, `.${remainder.toString().padStart(9, "0")}`)} +0000`;
+}
+function epoch(milliseconds, precision) {
+  const value = available(milliseconds, "timestamp");
+  const [coefficient = "0", exponent = "0"] = Math.abs(value).toString().split("e");
+  const [integer = "0", decimal = ""] = coefficient.split(".");
+  const digits = BigInt(integer + decimal);
+  const places = Math.min(precision, 9);
+  const scale = 10n ** BigInt(places);
+  const power = Number(exponent) - decimal.length - 3 + places;
+  const absolute = power < 0 ? digits / 10n ** BigInt(-power) : digits * 10n ** BigInt(power);
+  const fraction = absolute % scale;
+  const seconds = value < 0 && fraction === 0n ? -Math.floor(value / 1e3) : absolute / scale;
+  const suffix = precision ? "." + fraction.toString().padStart(places, "0") + "0".repeat(precision - places) : "";
+  return `${value < 0 ? "-" : ""}${seconds}${suffix}`;
+}
+function directive(format, start, bsd) {
+  let index = start + 1;
+  const flagsStart = index;
+  while (index < format.length && "-+ #0".includes(format[index])) index++;
+  const flags = format.slice(flagsStart, index);
+  const widthStart = index;
+  while (index < format.length && format[index] >= "0" && format[index] <= "9") index++;
+  const width = format.slice(widthStart, index);
+  let precision;
+  if (format[index] === ".") {
+    const precisionStart = ++index;
+    while (index < format.length && format[index] >= "0" && format[index] <= "9") index++;
+    precision = format.slice(precisionStart, index);
+  }
+  let code = format[index];
+  if (bsd && code !== void 0) {
+    const pair = format.slice(index, index + 2);
+    const mapping = { z: "s", N: "n", m: "Y", a: "X", c: "Z", B: "W", Lp: "a", Sp: "A", u: "u", Su: "U", g: "g", Sg: "G", i: "i", l: "h", HT: "bsdType", Y: "bsdTarget", "%": "%" };
+    const key = Object.hasOwn(mapping, pair) ? pair : code;
+    if (!Object.hasOwn(mapping, key)) throw new UsageError(`unsupported BSD stat format: %${key}`);
+    code = mapping[key];
+    index += key.length - 1;
+  }
+  if (code === void 0) throw new UsageError("invalid stat format directive");
+  const codePoint = code.charCodeAt(0);
+  if (code !== "%" && !(codePoint >= 65 && codePoint <= 90) && !(codePoint >= 97 && codePoint <= 122)) {
+    throw new UsageError("invalid stat format directive");
+  }
+  return { code, flags, length: index + 1 - start, precision, width };
+}
+function formatField(text, code, flags, width, precision, numeric, epoch2) {
+  if (numeric) {
+    const nonzero = !/^0+$/u.test(text);
+    if (!epoch2 && precision !== void 0) text = precision === 0 && !nonzero ? "" : text.padStart(precision, "0");
+    if (flags.includes("#")) text = code === "a" ? text.startsWith("0") ? text : `0${text}` : (code === "f" || code === "D") && nonzero ? `0x${text}` : text;
+    if (epoch2 && !text.startsWith("-") && (flags.includes("+") || flags.includes(" "))) text = `${flags.includes("+") ? "+" : " "}${text}`;
+  }
+  if (epoch2 && precision) {
+    const decimal = text.indexOf(".");
+    const integerWidth = width > precision + 2 && !flags.includes("-") ? width - precision - 1 : 0;
+    const integer = formatField(text.slice(0, decimal), code, flags, integerWidth, void 0, true, false);
+    const trailingWidth = integer.length < width && 1 < width - integer.length ? Math.abs(width - integer.length - 1 - precision) : 0;
+    return concatBytes([integer, syncStatEncoder.encode(text.slice(decimal)), allocSpaces(trailingWidth)]);
+  }
+  const encoded = syncStatEncoder.encode(text);
+  const bytes = !numeric && precision !== void 0 ? encoded.subarray(0, precision) : encoded;
+  const padding = Math.max(0, width - bytes.length);
+  if (flags.includes("-")) return concatBytes([bytes, allocSpaces(padding)]);
+  if (numeric && flags.includes("0") && (epoch2 || precision === void 0) && padding) {
+    const prefix = /^[+ -]|^0x/u.exec(text)?.[0] ?? "";
+    return syncStatEncoder.encode(prefix + "0".repeat(padding) + text.slice(prefix.length));
+  }
+  return concatBytes([allocSpaces(padding), bytes]);
+}
+async function render(context, path, name, stat, format, escapes, limit, filesystem, terse, bsd) {
+  const chunks = [];
+  let bytes = 0;
+  const append = (text) => {
+    const chunk = typeof text === "string" ? new TextEncoder().encode(text) : text;
+    bytes += chunk.byteLength;
+    if (bytes > limit) throw new FsError("EFBIG", { message: "stat format output limit exceeded" });
+    chunks.push(chunk);
+  };
+  for (let index = 0; index < format.length; ) {
+    context.signal.throwIfAborted();
+    if (escapes && format[index] === "\\") {
+      const named = { a: "\x07", b: "\b", e: "\x1B", f: "\f", n: "\n", r: "\r", t: "	", v: "\v", "\\": "\\", '"': '"' };
+      const code2 = format[index + 1] ?? "";
+      if (Object.hasOwn(named, code2)) {
+        append(named[code2]);
+        index += 2;
+        continue;
+      }
+      const radix = code2 === "x" ? 16 : 8;
+      const start = index + (radix === 16 ? 2 : 1);
+      const end = Math.min(format.length, start + (radix === 16 ? 2 : 3));
+      let offset = start;
+      let value = 0;
+      while (offset < end) {
+        const digit = "0123456789abcdef".indexOf(format[offset].toLowerCase());
+        if (digit < 0 || digit >= radix) break;
+        value = value * radix + digit;
+        offset++;
+      }
+      if (offset === start) {
+        append(format[index++]);
+        continue;
+      }
+      append(Uint8Array.of(value));
+      index = offset;
+      continue;
+    }
+    if (format[index] !== "%") {
+      const point = String.fromCodePoint(format.codePointAt(index));
+      append(point);
+      index += point.length;
+      continue;
+    }
+    const parsed = directive(format, index, bsd);
+    index += parsed.length;
+    const { code, flags } = parsed;
+    const width = Number(parsed.width || 0);
+    if (!Number.isSafeInteger(width) || width > limit) throw new FsError("EFBIG", { message: "stat format width limit exceeded" });
+    const epochCode = !filesystem && ["X", "Y", "Z", "W"].includes(code);
+    const precision = parsed.precision === void 0 ? void 0 : Number(parsed.precision || (epochCode ? 9 : 0));
+    if (precision !== void 0 && (!Number.isSafeInteger(precision) || precision > limit)) throw new FsError("EFBIG", { message: "stat format precision limit exceeded" });
+    if (code === "%" && parsed.length !== 2) throw new UsageError("invalid stat format directive");
+    if (filesystem) {
+      let text2;
+      if (code === "n") text2 = name;
+      else if (code === "%") text2 = "%";
+      else if (code === "T") {
+        if (stat.filesystemType === void 0) throw new FsError("ENOTSUP", { syscall: "stat", message: "filesystem does not expose its type" });
+        if (typeof stat.filesystemType !== "string" || stat.filesystemType.length === 0) throw new FsError("EIO", { syscall: "stat", message: "invalid filesystem type" });
+        text2 = stat.filesystemType;
+      } else throw new FsError("ENOTSUP", { message: `unsupported filesystem stat format: %${code}` });
+      append(formatField(text2, code, flags, width, precision, false, false));
+      continue;
+    }
+    let text;
+    let linkText;
+    let numeric = false;
+    if (["a", "A", "f"].includes(code)) available(stat.mode, "mode");
+    const times = { X: stat.atimeMs, Y: stat.mtimeMs, Z: stat.ctimeMs, W: stat.birthtimeMs };
+    if (Object.hasOwn(times, code)) {
+      text = terse && times[code] === void 0 ? "?" : epoch(available(times[code], code), precision ?? 0);
+      numeric = text !== "?";
+    } else if (code === "bsdType") text = stat.type === "directory" ? "Directory" : stat.type === "symlink" ? "Symbolic Link" : stat.type === "character" ? "Character Device" : "Regular File";
+    else if (code === "n") text = name;
+    else if (code === "bsdTarget") {
+      text = "";
+      if (stat.type === "symlink") {
+        if (!context.fs.readlink) throw new FsError("ENOTSUP", { syscall: "readlink", path });
+        text = await context.fs.readlink(path, { signal: context.signal });
+      }
+    } else if (code === "N") {
+      text = quoted(name, context.env.QUOTING_STYLE);
+      if (stat.type === "symlink") {
+        if (!context.fs.readlink) throw new FsError("ENOTSUP", { syscall: "readlink", path });
+        linkText = quoted(await context.fs.readlink(path, { signal: context.signal }), context.env.QUOTING_STYLE);
+      }
+    } else if (code === "%") text = "%";
+    else if (code === "A") text = permissionString(stat.mode, stat.type);
+    else if (code === "U") text = available(stat.uid, "u") === 0 ? "root" : String(stat.uid);
+    else if (code === "G") text = available(stat.gid, "g") === 0 ? "root" : String(stat.gid);
+    else if (code === "m") text = "/";
+    else if (code === "F") text = stat.type === "directory" ? "directory" : stat.type === "symlink" ? "symbolic link" : stat.type === "character" ? "character special file" : stat.size === 0 ? "regular empty file" : "regular file";
+    else if (["x", "y", "z", "w"].includes(code)) {
+      const value = times[code.toUpperCase()];
+      text = code === "w" && value === void 0 ? "-" : timestamp(available(value, code));
+    } else {
+      const fields = {
+        s: stat.size,
+        a: stat.mode & 4095,
+        f: stat.mode,
+        i: stat.ino,
+        h: stat.nlink,
+        u: stat.uid,
+        g: stat.gid,
+        d: stat.dev,
+        D: stat.dev,
+        B: 512,
+        b: stat.allocatedBytes === void 0 ? void 0 : Math.ceil(stat.allocatedBytes / 512),
+        o: stat.ioBlockSize,
+        t: stat.rdevMajor,
+        T: stat.rdevMinor
+      };
+      if (!Object.hasOwn(fields, code)) throw new FsError("ENOTSUP", { message: `unsupported stat format: %${code}` });
+      const value = fields[code];
+      text = terse && value === void 0 ? "?" : available(value, code).toString(code === "a" ? 8 : ["f", "D", "t", "T"].includes(code) ? 16 : 10);
+      numeric = text !== "?";
+    }
+    append(formatField(text, code, flags, width, precision, numeric, epochCode));
+    if (linkText !== void 0) {
+      append(" -> ");
+      append(formatField(linkText, code, flags, width, precision, false, false));
+    }
+  }
+  return concatBytes(chunks);
+}
+function createStatCommand(configuration = {}) {
+  const configured = settings(configuration);
+  return metadataCommand("stat", async (context) => {
+    const budget = new MetadataBudget(context, configured.limits);
+    const parsed = parse(context.args);
+    let exitCode = 0;
+    for (const name of parsed.paths) {
+      await budget.step();
+      try {
+        const path = pathOf(context, name);
+        const stat = await context.fs[parsed.follow || parsed.filesystem ? "stat" : "lstat"](path, { signal: context.signal });
+        const terse = parsed.terse && parsed.format === void 0;
+        if (terse && parsed.filesystem) throw new FsError("ENOTSUP", { message: "filesystem terse stat is unsupported" });
+        const format = parsed.format ?? (parsed.filesystem ? "  File: %n\n  Type: %T" : terse ? "%n %s %b %f %u %g %D %i %h %t %T %X %Y %Z %W %o" : "  File: %N\n  Size: %s	Type: %F\n  Mode: %a (%A)\nAccess: %x\nModify: %y\nChange: %z\n Birth: %w");
+        const text = await render(context, path, name, stat, format, parsed.printf, configured.limits.maxOutputBytes, parsed.filesystem, terse, parsed.bsd);
+        await budget.output(parsed.printf ? text : concatBytes([text, Uint8Array.of(10)]));
+      } catch (error) {
+        context.signal.throwIfAborted();
+        if (codeOf(error) === "EFBIG") throw error;
+        await diagnostic(context, error);
+        exitCode = 1;
+      }
+    }
+    return { exitCode };
+  });
+}
+var syncStatDecoder = new TextDecoder("utf-8", { fatal: false });
+function renderSync(path, name, stat, format, escapes, limit, filesystem, terse, quotingStyle, bsd) {
+  const chunks = [];
+  let bytes = 0;
+  const append = (text) => {
+    const chunk = typeof text === "string" ? new TextEncoder().encode(text) : text;
+    bytes += chunk.byteLength;
+    if (bytes > limit) throw new FsError("EFBIG", { message: "stat format output limit exceeded" });
+    chunks.push(chunk);
+  };
+  for (let index = 0; index < format.length; ) {
+    if (escapes && format[index] === "\\") {
+      const named = { a: "\x07", b: "\b", e: "\x1B", f: "\f", n: "\n", r: "\r", t: "	", v: "\v", "\\": "\\", '"': '"' };
+      const code2 = format[index + 1] ?? "";
+      if (Object.hasOwn(named, code2)) {
+        append(named[code2]);
+        index += 2;
+        continue;
+      }
+      const radix = code2 === "x" ? 16 : 8;
+      const start = index + (radix === 16 ? 2 : 1);
+      const end = Math.min(format.length, start + (radix === 16 ? 2 : 3));
+      let offset = start;
+      let value = 0;
+      while (offset < end) {
+        const digit = "0123456789abcdef".indexOf(format[offset].toLowerCase());
+        if (digit < 0 || digit >= radix) break;
+        value = value * radix + digit;
+        offset++;
+      }
+      if (offset === start) {
+        append(format[index++]);
+        continue;
+      }
+      append(Uint8Array.of(value));
+      index = offset;
+      continue;
+    }
+    if (format[index] !== "%") {
+      const point = String.fromCodePoint(format.codePointAt(index));
+      append(point);
+      index += point.length;
+      continue;
+    }
+    const parsed = directive(format, index, bsd);
+    index += parsed.length;
+    const { code, flags } = parsed;
+    const width = Number(parsed.width || 0);
+    if (!Number.isSafeInteger(width) || width > limit) throw new FsError("EFBIG", { message: "stat format width limit exceeded" });
+    const epochCode = !filesystem && ["X", "Y", "Z", "W"].includes(code);
+    const precision = parsed.precision === void 0 ? void 0 : Number(parsed.precision || (epochCode ? 9 : 0));
+    if (precision !== void 0 && (!Number.isSafeInteger(precision) || precision > limit)) throw new FsError("EFBIG", { message: "stat format precision limit exceeded" });
+    if (code === "%" && parsed.length !== 2) throw new UsageError("invalid stat format directive");
+    if (filesystem) {
+      let text2;
+      if (code === "n") text2 = name;
+      else if (code === "%") text2 = "%";
+      else if (code === "T") {
+        if (stat.filesystemType === void 0) throw new FsError("ENOTSUP", { syscall: "stat", message: "filesystem does not expose its type" });
+        if (typeof stat.filesystemType !== "string" || stat.filesystemType.length === 0) throw new FsError("EIO", { syscall: "stat", message: "invalid filesystem type" });
+        text2 = stat.filesystemType;
+      } else throw new FsError("ENOTSUP", { message: `unsupported filesystem stat format: %${code}` });
+      append(formatField(text2, code, flags, width, precision, false, false));
+      continue;
+    }
+    let text;
+    let linkText;
+    let numeric = false;
+    if (["a", "A", "f"].includes(code)) available(stat.mode, "mode");
+    const times = { X: stat.atimeMs, Y: stat.mtimeMs, Z: stat.ctimeMs, W: stat.birthtimeMs };
+    if (Object.hasOwn(times, code)) {
+      text = terse && times[code] === void 0 ? "?" : epoch(available(times[code], code), precision ?? 0);
+      numeric = text !== "?";
+    } else if (code === "bsdType") text = stat.type === "directory" ? "Directory" : stat.type === "symlink" ? "Symbolic Link" : stat.type === "character" ? "Character Device" : "Regular File";
+    else if (code === "n") text = name;
+    else if (code === "bsdTarget") {
+      if (stat.type === "symlink" && stat.target === void 0) throw new FsError("ENOTSUP", { syscall: "readlink", path });
+      text = stat.type === "symlink" ? stat.target : "";
+    } else if (code === "N") {
+      text = quoted(name, quotingStyle);
+      if (stat.type === "symlink") {
+        if (stat.target === void 0) throw new FsError("ENOTSUP", { syscall: "readlink", path });
+        linkText = quoted(stat.target, quotingStyle);
+      }
+    } else if (code === "%") text = "%";
+    else if (code === "A") text = permissionString(stat.mode, stat.type);
+    else if (code === "U") text = available(stat.uid, "u") === 0 ? "root" : String(stat.uid);
+    else if (code === "G") text = available(stat.gid, "g") === 0 ? "root" : String(stat.gid);
+    else if (code === "m") text = "/";
+    else if (code === "F") text = stat.type === "directory" ? "directory" : stat.type === "symlink" ? "symbolic link" : stat.type === "character" ? "character special file" : stat.size === 0 ? "regular empty file" : "regular file";
+    else if (["x", "y", "z", "w"].includes(code)) {
+      const value = times[code.toUpperCase()];
+      text = code === "w" && value === void 0 ? "-" : timestamp(available(value, code));
+    } else {
+      const fields = {
+        s: stat.size,
+        a: stat.mode & 4095,
+        f: stat.mode,
+        i: stat.ino,
+        h: stat.nlink,
+        u: stat.uid,
+        g: stat.gid,
+        d: stat.dev,
+        D: stat.dev,
+        B: 512,
+        b: stat.allocatedBytes === void 0 ? void 0 : Math.ceil(stat.allocatedBytes / 512),
+        o: stat.ioBlockSize,
+        t: stat.rdevMajor,
+        T: stat.rdevMinor
+      };
+      if (!Object.hasOwn(fields, code)) throw new FsError("ENOTSUP", { message: `unsupported stat format: %${code}` });
+      const value = fields[code];
+      text = terse && value === void 0 ? "?" : available(value, code).toString(code === "a" ? 8 : ["f", "D", "t", "T"].includes(code) ? 16 : 10);
+      numeric = text !== "?";
+    }
+    append(formatField(text, code, flags, width, precision, numeric, epochCode));
+    if (linkText !== void 0) {
+      append(" -> ");
+      append(formatField(linkText, code, flags, width, precision, false, false));
+    }
+  }
+  return concatBytes(chunks);
+}
+function resolveSyncStatPath(cwd, target) {
+  const raw = target.startsWith("/") ? target : cwd.endsWith("/") ? cwd + target : `${cwd}/${target}`;
+  const parts = raw.split("/");
+  const stack = [];
+  for (const part of parts) {
+    if (!part || part === ".") continue;
+    if (part === "..") stack.pop();
+    else stack.push(part);
+  }
+  return "/" + stack.join("/");
+}
+function evalSyncStat(args, cwd, quotingStyle, inspectStat) {
+  let parsed;
+  try {
+    parsed = parse(args);
+  } catch {
+    return void 0;
+  }
+  const outChunks = [];
+  for (const name of parsed.paths) {
+    if (!name) return void 0;
+    const abs = resolveSyncStatPath(cwd, name);
+    const stat = inspectStat(abs, parsed.follow || parsed.filesystem);
+    if (!stat) return void 0;
+    const terse = parsed.terse && parsed.format === void 0;
+    if (terse && parsed.filesystem) return void 0;
+    const format = parsed.format ?? (parsed.filesystem ? "  File: %n\n  Type: %T" : terse ? "%n %s %b %f %u %g %D %i %h %t %T %X %Y %Z %W %o" : "  File: %N\n  Size: %s	Type: %F\n  Mode: %a (%A)\nAccess: %x\nModify: %y\nChange: %z\n Birth: %w");
+    try {
+      const rendered = renderSync(abs, name, stat, format, parsed.printf, 262144, parsed.filesystem, terse, quotingStyle, parsed.bsd);
+      outChunks.push(parsed.printf ? rendered : concatBytes([rendered, Uint8Array.of(10)]));
+    } catch {
+      return void 0;
+    }
+  }
+  return syncStatDecoder.decode(concatBytes(outChunks));
+}
+
+export {
+  createStatCommand,
+  evalSyncStat
+};

package/dist/safe-bash/command-chunks/{chunk-QOKBZFFD.js → chunk-U3MMODA5.js}

@@ -27,22 +27,17 @@ var Budget = class {
   workTotal = 0;
   maxWorkLimit;
   _signal;
-  _aborted = false;
   get signal() {
     return this._signal;
   }
   set signal(value) {
     this._signal = value;
-    this._aborted = value.aborted;
-    if (!this._aborted) value.addEventListener("abort", () => {
-      this._aborted = true;
-    }, { once: true });
   }
   get aborted() {
-    return this._aborted;
+    return this._signal.aborted;
   }
   check() {
-    if (this._aborted) this._signal.throwIfAborted();
+    this._signal.throwIfAborted();
   }
   bound(name, value) {
     this.check();

package/dist/safe-bash/command-chunks/{chunk-ZYHTWNAE.js → chunk-UAW423ZL.js}

@@ -1,6 +1,3 @@
-import {
-  recurse
-} from "./chunk-PTT3I223.js";
 import {
   splitRegex
 } from "./chunk-VSRGNQCP.js";
@@ -9,12 +6,12 @@ import {
   scanRegex,
   substituteRegex
 } from "./chunk-KQLD3AED.js";
-import {
-  formatValue
-} from "./chunk-BPE5INLI.js";
 import {
   indices
 } from "./chunk-4BB2SWJ5.js";
+import {
+  recurse
+} from "./chunk-PTT3I223.js";
 import {
   capture
 } from "./chunk-CQTRW45K.js";
@@ -25,7 +22,7 @@ import {
   strftime,
   strptime,
   toDateIso8601
-} from "./chunk-GMIHJYDG.js";
+} from "./chunk-M32HFSX7.js";
 import {
   delpaths
 } from "./chunk-OYYV7ZAF.js";
@@ -46,6 +43,9 @@ import {
 import {
   splitString
 } from "./chunk-HMOZ6XVJ.js";
+import {
+  formatValue
+} from "./chunk-BPE5INLI.js";
 import {
   JqParseError,
   measureValue,
@@ -1070,10 +1070,10 @@ var Interpreter = class _Interpreter {
     const length = input === null ? 0 : input.length;
     const size = remove2 ? Math.max(0, length - 1) : Math.max(length, key + 1);
     this.budget.collection(size);
-    if (!Number.isSafeInteger(size) || size > 1e6) throw new JqLimitError("maxCollectionSize");
+    if (!Number.isSafeInteger(size)) throw new JqLimitError("maxCollectionSize");
     const padding = remove2 ? 0 : Math.max(0, key - length);
     const minimumBytes = size ? 2 * size + 1 + 3 * padding : 2;
-    if (minimumBytes > Math.min(this.budget.limits.maxValueBytes, 16 * 1024 * 1024)) throw new JqLimitError("maxValueBytes");
+    if (minimumBytes > this.budget.limits.maxValueBytes) throw new JqLimitError("maxValueBytes");
     const result = [];
     if (input !== null) for (const item of input) {
       {
@@ -1255,8 +1255,8 @@ var Interpreter = class _Interpreter {
       yield mktime(input);
       return;
     }
-    if (name === "strftime" || name === "strptime") {
-      for await (const format of this.run(args[0], input)) yield name === "strftime" ? strftime(input, format, budget) : strptime(input, format, budget);
+    if (name === "strftime" || name === "strflocaltime" || name === "strptime") {
+      for await (const format of this.run(args[0], input)) yield name === "strptime" ? strptime(input, format, budget) : strftime(input, format, budget, name === "strflocaltime");
       return;
     }
     if (name === "fromdateiso8601" || name === "fromdate") {