@poe-platform/safe-bash 0.1.798 → 0.1.800

package/dist/safe-bash/command-chunks/{chunk-2HOESGFJ.js → chunk-BKCNF5U3.js}

@@ -1,12 +1,15 @@
+import {
+  extendedPattern
+} from "./chunk-GI4CJED2.js";
 import {
   describe
-} from "./chunk-PRCT7FKJ.js";
+} from "./chunk-UMDIOL3O.js";
 import {
   JqError,
   JqLimitError,
   object,
   put
-} from "./chunk-AC6X7Q4I.js";
+} from "./chunk-QP4R6GLA.js";
 import {
   utf8ByteLength
 } from "./chunk-PDKXAR4Y.js";
@@ -18,7 +21,7 @@ import {
 init_buffer();
 import { Pattern } from "../../safe-bash-regex-engine/text/regex.js";
 import { ProgramError } from "../../safe-bash-regex-engine/text/budget.js";
-async function* substituteRegex(input, source, flags, replacement, budget) {
+async function* substituteRegex(input, source, flags, replacement, budget, global = true) {
   if (typeof input !== "string") throw new JqError(`${describe(input, budget)} cannot be matched, as it is not a string`);
   if (typeof source !== "string") throw new JqError(`${describe(source, budget)} is not a string`);
   if (typeof flags !== "string" || [...flags].some((flag) => !"gimns".includes(flag))) throw new JqError(`${typeof flags === "string" ? flags + "g" : describe(flags, budget)} is not a valid modifier string`);
@@ -58,6 +61,7 @@ async function* substituteRegex(input, source, flags, replacement, budget) {
         results = next;
         copied = match.end;
       }
+      if (!global && !flags.includes("g")) break;
       search = match.end > match.start ? match.end : match.end + ((input.codePointAt(match.end) ?? 0) > 65535 ? 2 : 1);
     }
     for (const prefix of results) {
@@ -76,10 +80,11 @@ function regexError(error) {
   const message = error.message === "unterminated bracket expression" ? "premature end of char-class" : error.message === "unmatched '(' in regular expression" ? "end pattern with unmatched parenthesis" : error.message === "quantifier without an expression" ? "target of repeat operator is not specified" : error.message === "reversed character range" ? "empty range in char class" : error.message;
   return new JqError(`Regex failure: ${message}`);
 }
-async function* scanRegex(input, source, budget) {
+async function* scanRegex(input, source, budget, modifiers = null) {
+  const flags = regexFlags(modifiers, budget);
   if (typeof source !== "string") throw new JqError(`${describe(source, budget)} is not a string`);
   if (typeof input !== "string") throw new JqError(`${describe(input, budget)} cannot be matched, as it is not a string`);
-  if (source === "") {
+  if (source === "" && !flags.includes("n")) {
     const boundaries = utf8ByteLength(input) + 1;
     for (let index = 0; index < boundaries; index++) {
       {
@@ -93,7 +98,7 @@ async function* scanRegex(input, source, budget) {
   const work = { step: (count = 1) => budget.step(count), checkpoint: () => budget.tick(0), maxBufferBytes: budget.limits.maxValueBytes };
   try {
     budget.step(source.length);
-    const pattern = new Pattern(source, true, false, "jq");
+    const pattern = new Pattern(flags.includes("x") ? await extendedPattern(source, budget) : source, true, flags.includes("i"), "jq", flags.includes("p") ? flags + "m" : flags);
     let search = 0;
     while (search <= input.length) {
       const match = await pattern.find(input, work, search);
@@ -108,9 +113,65 @@ async function* scanRegex(input, source, budget) {
     throw regexError(error);
   }
 }
+function regexFlags(modifiers, budget) {
+  if (modifiers !== null && typeof modifiers !== "string") throw new JqError(`${describe(modifiers, budget)} is not a string`);
+  const flags = modifiers ?? "";
+  if ([...flags].some((flag) => !"gimnpsx".includes(flag))) throw new JqError(`${flags} is not a valid modifier string`);
+  return flags;
+}
+async function* matchRegex(input, source, modifiers, budget, test) {
+  if (typeof input !== "string") throw new JqError(`${describe(input, budget)} cannot be matched, as it is not a string`);
+  if (typeof source !== "string") throw new JqError(`${describe(source, budget)} is not a string`);
+  const flags = regexFlags(modifiers, budget);
+  const work = { step: (count = 1) => budget.step(count), checkpoint: () => budget.tick(0), maxBufferBytes: budget.limits.maxValueBytes };
+  try {
+    budget.step(source.length + input.length);
+    const pattern = new Pattern(flags.includes("x") ? await extendedPattern(source, budget) : source, true, flags.includes("i"), "jq", flags.includes("p") ? flags + "m" : flags);
+    let search = 0;
+    while (search <= input.length) {
+      const match = await pattern.find(input, work, search);
+      if (!match) {
+        if (test) yield false;
+        return;
+      }
+      if (test) {
+        yield true;
+        return;
+      }
+      const position = (start, end) => {
+        budget.step(end + start);
+        return { offset: [...input.slice(0, start)].length, length: [...input.slice(start, end)].length, string: input.slice(start, end) };
+      };
+      const names = new Map([...pattern.groupNames].map(([name, index]) => [index, name]));
+      const captures = [];
+      budget.collection(pattern.groupCount);
+      for (let index = 1; index <= pattern.groupCount; index++) {
+        const start = match.captureOffsets?.[index * 2];
+        const end = match.captureOffsets?.[index * 2 + 1];
+        captures.push({ ...start === void 0 || end === void 0 ? { offset: -1, length: 0, string: null } : position(start, end), name: names.get(index) ?? null });
+      }
+      const result = { ...position(match.start, match.end), captures };
+      budget.value(result);
+      yield result;
+      if (!flags.includes("g")) return;
+      if (source === "" && match.end < input.length) {
+        const character = String.fromCodePoint(input.codePointAt(match.end));
+        for (let repeat = 1; repeat < utf8ByteLength(character); repeat++) {
+          await budget.tick();
+          yield { offset: result.offset + 1, length: 0, string: "", captures: [] };
+        }
+      }
+      search = match.end > match.start ? match.end : match.end + ((input.codePointAt(match.end) ?? 0) > 65535 ? 2 : 1);
+    }
+  } catch (error) {
+    throw regexError(error);
+  }
+}
 
 export {
   substituteRegex,
   regexError,
-  scanRegex
+  scanRegex,
+  regexFlags,
+  matchRegex
 };

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

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

package/dist/safe-bash/command-chunks/{chunk-QAN7KKDZ.js → chunk-BZDDAPSV.js}

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

package/dist/safe-bash/command-chunks/{chunk-HZCPWYWA.js → chunk-BZPAWTUL.js}

@@ -1,6 +1,6 @@
 import {
   UsageError
-} from "./chunk-HVI6ALJF.js";
+} from "./chunk-PFAADCB5.js";
 import {
   init_buffer
 } from "./chunk-HX3SHTCE.js";

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

@@ -0,0 +1,25 @@
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-tar/src/listing.ts
+init_buffer();
+import { encodeBytes } from "../../safe-bash-io-engine/byte-encoding.js";
+function quoteName(name, style) {
+  if (style === "literal") return name;
+  const escapes = { "\x07": "\\a", "\b": "\\b", "	": "\\t", "\n": "\\n", "\v": "\\v", "\f": "\\f", "\r": "\\r" };
+  let result = style === "c" ? '"' : "";
+  for (const character of name) {
+    const escape = escapes[character];
+    if (escape !== void 0) result += escape;
+    else if (style === "c" && character === '"' || character === "\\") result += `\\${character}`;
+    else if (character.charCodeAt(0) < 32 || character.charCodeAt(0) >= 127 && character.charCodeAt(0) <= 159 || character === "\u2028" || character === "\u2029") {
+      for (const byte of encodeBytes(character)) result += `\\${byte.toString(8).padStart(3, "0")}`;
+    } else result += character;
+  }
+  return style === "c" ? result + '"' : result;
+}
+
+export {
+  quoteName
+};

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

@@ -0,0 +1,65 @@
+import {
+  CurlError
+} from "./chunk-IYPAQ7PH.js";
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-network-engine/src/form-content-type.ts
+init_buffer();
+function token(character) {
+  if (character === void 0) return false;
+  const code = character.charCodeAt(0);
+  return code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 97 && code <= 122 || "!#$%&'*+-.^_`|~".includes(character);
+}
+function formContentType(input, start, fileList = false) {
+  let end = start;
+  const invalid = () => {
+    throw new CurlError(2, "Invalid multipart content type");
+  };
+  const readToken = () => {
+    const begin = end;
+    while (token(input[end])) end++;
+    if (end === begin) invalid();
+  };
+  const whitespace = () => {
+    while (input[end] === " " || input[end] === "	") end++;
+  };
+  readToken();
+  if (input[end++] !== "/") invalid();
+  readToken();
+  whitespace();
+  while (end < input.length) {
+    if (fileList && input[end] === ",") break;
+    if (input[end] !== ";") invalid();
+    const separator = end++;
+    whitespace();
+    if (["type=", "filename=", "encoder=", "headers="].some((attribute) => input.startsWith(attribute, end))) {
+      return { value: input.slice(start, separator), end: separator };
+    }
+    readToken();
+    whitespace();
+    if (input[end++] !== "=") invalid();
+    whitespace();
+    if (input[end] === '"') {
+      end++;
+      let closed = false;
+      while (end < input.length) {
+        const character = input[end++];
+        if (character === '"') {
+          closed = true;
+          break;
+        }
+        const literal = character === "\\" ? input[end++] : character;
+        if (literal === void 0 || literal.charCodeAt(0) < 32 || literal.charCodeAt(0) === 127) invalid();
+      }
+      if (!closed) invalid();
+    } else readToken();
+    whitespace();
+  }
+  return { value: input.slice(start, end), end };
+}
+
+export {
+  formContentType
+};

package/dist/safe-bash/command-chunks/{chunk-RT2J5ATD.js → chunk-CPPGTBZF.js}

@@ -1,7 +1,7 @@
 import {
   PrError,
   quote
-} from "./chunk-3WKA57FA.js";
+} from "./chunk-N5FGCXQJ.js";
 import {
   init_buffer
 } from "./chunk-HX3SHTCE.js";

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

@@ -0,0 +1,150 @@
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-sed/src/inplace.ts
+init_buffer();
+import { retainFileSystemCleanup } from "@poe-platform/safe-fs/core";
+import { dirname, FsError, joinPath } from "../../safe-bash-contracts/index.js";
+import { compareCopyIdentity } from "../../safe-bash-contracts/filesystem-identity.js";
+import { writeFileOutput } from "../../safe-bash-contracts/filesystem-output.js";
+import { decodeBytes, encodeBytes } from "../../safe-bash-io-engine/byte-encoding.js";
+import { bytes, virtualPath } from "../../safe-bash-io-engine/commands/text-programs/shared.js";
+async function prepareInPlace(context, files, suffix) {
+  const fs = context.fs;
+  if (!fs.confineExtraction || !fs.writeFileConditional || !fs.openReadFile) {
+    throw new FsError("ENOTSUP", { message: "in-place editing requires retained ancestry, retained reads and atomic conditional writes" });
+  }
+  const targets = [];
+  for (const file of files) {
+    const operand = virtualPath(context, file);
+    const path = "/" + operand.split("/").filter((part) => part && part !== ".").join("/");
+    const capabilities = await fs.capabilitiesFor?.(path, { signal: context.signal }) ?? fs.capabilities;
+    if (capabilities.atomicFileMutation !== true || capabilities.retainedRead !== true) {
+      throw new FsError("ENOTSUP", { path, message: "in-place editing requires retained reads and atomic conditional writes" });
+    }
+    const parent = await fs.lstat(dirname(path), { signal: context.signal });
+    const original = await fs.lstat(operand, { signal: context.signal });
+    if (parent.type !== "directory" || original.type !== "file") throw new FsError("ENOTSUP", { path, message: "in-place editing requires regular files and directory parents" });
+    let backup = null;
+    const backupAncestors = [];
+    if (suffix) {
+      try {
+        backup = await fs.lstat(path + suffix, { signal: context.signal });
+      } catch (error) {
+        if (!(error instanceof FsError) || error.code !== "ENOENT") throw error;
+      }
+      if (backup && backup.type !== "file") throw new FsError("ENOTSUP", { path: path + suffix, message: "in-place backups require regular files" });
+      if (backup && compareCopyIdentity(original, backup) === "same") throw new FsError("EINVAL", { path, message: "backup aliases the edited file" });
+      if (backup && (backup.mode & 4095) !== (original.mode & 4095)) {
+        const backupCapabilities = await fs.capabilitiesFor?.(path + suffix, { signal: context.signal }) ?? fs.capabilities;
+        if (backupCapabilities.atomicFileStaging !== true || backupCapabilities.atomicStagingAncestry !== true || !fs.createStagedFile || !fs.publishStagedFile || !fs.removeStagedFile) {
+          throw new FsError("ENOTSUP", { path: path + suffix, message: "preserving backup permissions requires atomic staging with ancestry verification" });
+        }
+        for (let directory = dirname(path); ; directory = dirname(directory)) {
+          const stat = directory === dirname(path) ? parent : await fs.lstat(directory, { signal: context.signal });
+          if (stat.type !== "directory") throw new FsError("ENOTSUP", { path: directory, message: "in-place backups require directory ancestry" });
+          backupAncestors.unshift({ path: directory, stat });
+          if (directory === "/") break;
+        }
+      }
+    }
+    targets.push({ path, parent, original, backup, backupAncestors });
+  }
+  const view = await fs.confineExtraction([...new Set(targets.map((target) => dirname(target.path)))], { signal: context.signal });
+  if (!view.writeFileConditional) throw new FsError("ENOTSUP", { message: "in-place editing requires atomic conditional writes" });
+  return targets.map((target) => ({ ...target, fs: view }));
+}
+async function replaceBackup(context, target, suffix, data) {
+  let staging;
+  let operation;
+  let failure;
+  let closed = false;
+  const release = retainFileSystemCleanup(context.fs, async (view) => {
+    await operation?.catch(() => {
+    });
+    if (staging) await view.removeStagedFile(staging);
+  }, { maxOperations: 1 });
+  const cleanup = () => {
+    closed = true;
+    return release();
+  };
+  context.registerCleanup?.(cleanup);
+  try {
+    operation = Promise.resolve().then(async () => {
+      context.signal.throwIfAborted();
+      if (closed) throw new FsError("EPIPE", { message: "in-place backup publication is closed" });
+      staging = await context.fs.createStagedFile(joinPath(dirname(target.path), `.sed-${globalThis.crypto.randomUUID()}`), "backup", {
+        type: "file",
+        data
+      }, { parent: target.parent, mode: target.original.mode & 4095, signal: context.signal });
+      context.signal.throwIfAborted();
+      if (closed) throw new FsError("EPIPE", { message: "in-place backup publication is closed" });
+      await context.fs.publishStagedFile(staging, target.path + suffix, {
+        parent: target.parent,
+        destination: target.backup,
+        ancestors: target.backupAncestors,
+        signal: context.signal
+      });
+      context.signal.throwIfAborted();
+    });
+    await operation;
+  } catch (error) {
+    failure = { reason: error };
+  }
+  try {
+    await cleanup();
+  } catch (error) {
+    if (failure) throw new AggregateError([failure.reason, error], "in-place backup publication and cleanup failed");
+    throw error;
+  }
+  if (failure) throw failure.reason;
+}
+async function editInPlace(context, target, suffix, budget, run) {
+  const reader = await context.fs.openReadFile(target.path, { signal: context.signal });
+  let closing;
+  const close = () => closing ??= reader.close();
+  try {
+    context.registerCleanup?.(close);
+    const identity = compareCopyIdentity(target.original, await reader.stat({ signal: context.signal }));
+    if (identity !== "same") throw new FsError(identity === "unknown" ? "ENOTSUP" : "EAGAIN", { path: target.path, message: "in-place reader does not match the inspected file" });
+    const source = async function* () {
+      let position = 0;
+      while (true) {
+        const chunk = await reader.read(position, 64 * 1024, { signal: context.signal });
+        if (!chunk.byteLength) return;
+        position += chunk.byteLength;
+        yield chunk;
+      }
+    };
+    const { data, result } = await run(source());
+    if (suffix) {
+      let original = "";
+      for await (const chunk of source()) {
+        budget.step();
+        original = budget.check(original + decodeBytes(encodeBytes(chunk), "latin1"));
+        await budget.checkpoint();
+      }
+      context.signal.throwIfAborted();
+      if (target.backupAncestors.length) await replaceBackup(context, target, suffix, bytes(original));
+      else await target.fs.writeFileConditional(target.path + suffix, bytes(original), {
+        parent: target.parent,
+        expected: target.backup,
+        mode: target.original.mode & 4095,
+        signal: context.signal
+      });
+      context.signal.throwIfAborted();
+    }
+    await writeFileOutput(context, data, async (chunk) => {
+      await target.fs.writeFileConditional(target.path, chunk, { parent: target.parent, expected: target.original, signal: context.signal });
+    });
+    return result;
+  } finally {
+    await close();
+  }
+}
+
+export {
+  prepareInPlace,
+  editInPlace
+};