@poe-platform/safe-bash 0.1.798 → 0.1.800

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

@@ -0,0 +1,293 @@
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-wget/src/wget.ts
+init_buffer();
+import { createTransferCommand } from "../../safe-bash-command-curl/curl.js";
+import { getCommandArguments } from "../../safe-bash-contracts/index.js";
+import { shellValueByteLength, shellValueBytes } from "../../safe-bash-contracts/value.js";
+import { yieldTurn } from "../../safe-bash-contracts/yield.js";
+import { pathOf } from "../../safe-bash-io-engine/internal.js";
+import { validateRequestHeader } from "../../safe-bash-network-engine/args.js";
+import { validateHeaderName } from "../../safe-bash-network-engine/platform-portable.js";
+import { collectNetworkBytes as collectBytes } from "../../safe-bash-network-engine/shared.js";
+import { CurlError } from "../../safe-bash-network-engine/types.js";
+async function parseWget(context, limits) {
+  const carrier = getCommandArguments(context);
+  let argumentBytes = 0;
+  for (const value of carrier.values) {
+    if (typeof value === "string" && value.length > limits.maxBufferBytes) throw new CurlError(2, "Arguments exceed host buffer limit");
+    argumentBytes += shellValueByteLength(value);
+    if (argumentBytes > limits.maxBufferBytes) throw new CurlError(2, "Arguments exceed host buffer limit");
+    if (typeof value === "string") {
+      for (let index = 0; index < value.length; index++) {
+        if (index % 1024 === 0) await yieldTurn(context.signal);
+        const code = value.charCodeAt(index);
+        if (code >= 55296 && code <= 56319) {
+          const next = value.charCodeAt(++index);
+          if (!(next >= 56320 && next <= 57343)) throw new CurlError(2, "Arguments must be valid UTF-8");
+        } else if (code >= 56320 && code <= 57343) throw new CurlError(2, "Arguments must be valid UTF-8");
+      }
+      continue;
+    }
+    const bytes = shellValueBytes(value);
+    const decoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
+    for (let offset = 0; offset < bytes.length; offset += 1024) {
+      await yieldTurn(context.signal);
+      try {
+        decoder.decode(bytes.subarray(offset, offset + 1024), { stream: offset + 1024 < bytes.length });
+      } catch (error) {
+        context.signal.throwIfAborted();
+        if (!(error instanceof TypeError) || "code" in error && error.code !== "ERR_ENCODING_INVALID_ENCODED_DATA") throw error;
+        throw new CurlError(2, "Arguments must be valid UTF-8");
+      }
+    }
+  }
+  const result = {
+    urls: [],
+    data: [],
+    headers: [],
+    include: false,
+    head: false,
+    get: false,
+    location: true,
+    remoteName: true,
+    fail: true,
+    failWithBody: false,
+    silent: false,
+    showError: false,
+    verbose: false,
+    globoff: true,
+    help: false,
+    version: false,
+    retries: limits.maxRetries,
+    retryDelayMs: 0,
+    maxTimeMs: limits.maxTimeMs,
+    maxRedirects: limits.maxRedirects,
+    maxFileSize: limits.maxDownloadBytes,
+    agent: "virtual-bash-wget/0.0",
+    retryTransport: true,
+    directoryIndex: "index.html",
+    download: { spider: false, resume: false, noClobber: false, contentDisposition: false }
+  };
+  const number = (value, integral) => {
+    let start = 0;
+    let end = value.length;
+    if (!integral) {
+      while (start < end && " 	\n\r\v\f".includes(value[start])) start++;
+      while (end > start && " 	\n\r\v\f".includes(value[end - 1])) end--;
+    }
+    let multiplier = 1;
+    if (!integral) {
+      const units = { s: 1, m: 60, h: 3600, d: 86400 };
+      const unit = units[value[end - 1]];
+      if (unit !== void 0) {
+        multiplier = unit;
+        end--;
+      }
+    }
+    let position = start;
+    if (!integral && (value[position] === "+" || value[position] === "-")) position++;
+    let digits = 0;
+    let dot = false;
+    for (; position < end; position++) {
+      const character = value[position];
+      if (character >= "0" && character <= "9") digits++;
+      else if (!integral && character === "." && !dot) dot = true;
+      else throw new CurlError(2, "Invalid numeric option");
+    }
+    if (!digits) throw new CurlError(2, "Invalid numeric option");
+    const parsed = Number(value.slice(start, end)) * multiplier;
+    if (!Number.isFinite(parsed) || parsed < 0 || parsed > Number.MAX_SAFE_INTEGER) throw new CurlError(2, "Invalid numeric option");
+    return parsed;
+  };
+  const bodies = {};
+  const headers = /* @__PURE__ */ new Map();
+  let agent;
+  let referer;
+  let ended = false;
+  let inputFile;
+  for (let index = 0; index < context.args.length; index++) {
+    if (index % 128 === 0) await yieldTurn(context.signal);
+    const argument = context.args[index];
+    if (ended || !argument.startsWith("-") || argument === "-") {
+      result.urls.push(argument);
+      continue;
+    }
+    if (argument === "--") {
+      ended = true;
+      continue;
+    }
+    if (!argument.startsWith("--")) {
+      for (let position = 1; position < argument.length; position++) {
+        if (position % 1024 === 0) await yieldTurn(context.signal);
+        const flag2 = argument[position];
+        if (flag2 === "q") result.silent = true;
+        else if (flag2 === "c") result.download.resume = true;
+        else if (flag2 === "n" && argument[position + 1] === "c") {
+          result.download.noClobber = true;
+          position++;
+        } else if (flag2 === "n" && argument[position + 1] === "v") position++;
+        else if (flag2 === "h") result.help = true;
+        else if (flag2 === "r") throw new CurlError(2, "Recursive mirroring is unsupported");
+        else if (["O", "P", "i", "T", "t"].includes(flag2)) {
+          const output = position + 1 < argument.length ? argument.slice(position + 1) : context.args[++index];
+          if (!output) throw new CurlError(2, `-${flag2} requires a nonempty argument`);
+          if (flag2 === "O") {
+            result.output = output;
+            result.remoteName = false;
+          } else if (flag2 === "P") result.outputDirectory = output;
+          else if (flag2 === "i") inputFile = output;
+          else if (flag2 === "T") {
+            const seconds = number(output, false);
+            result.maxTimeMs = Math.min(seconds === 0 ? Infinity : seconds * 1e3, limits.maxTimeMs);
+          } else {
+            const tries = number(output, true);
+            result.retries = tries === 0 ? limits.maxRetries : Math.min(tries - 1, limits.maxRetries);
+          }
+          break;
+        } else throw new CurlError(2, `Unsupported option: -${flag2}`);
+      }
+      continue;
+    }
+    if (argument === "--quiet") {
+      result.silent = true;
+      continue;
+    }
+    if (argument === "--no-verbose") continue;
+    if (argument === "--help") {
+      result.help = true;
+      continue;
+    }
+    if (argument === "--version") {
+      result.version = true;
+      continue;
+    }
+    if (argument === "--spider") {
+      result.download.spider = true;
+      continue;
+    }
+    if (argument === "--continue") {
+      result.download.resume = true;
+      continue;
+    }
+    if (argument === "--no-clobber") {
+      result.download.noClobber = true;
+      continue;
+    }
+    if (argument === "--content-disposition") {
+      result.download.contentDisposition = true;
+      continue;
+    }
+    if (argument === "--recursive") throw new CurlError(2, "Recursive mirroring is unsupported");
+    const equal = argument.indexOf("=");
+    const flag = equal < 0 ? argument : argument.slice(0, equal);
+    let operand;
+    if (["--directory-prefix", "--input-file", "--output-document", "--timeout", "--tries", "--method", "--post-data", "--post-file", "--body-data", "--body-file", "--header", "--user-agent", "--referer"].includes(flag)) {
+      operand = equal < 0 ? context.args[++index] : argument.slice(equal + 1);
+    } else throw new CurlError(2, `Unsupported option: ${argument}`);
+    if (operand === void 0) throw new CurlError(2, `${flag} requires an argument`);
+    if (flag === "--output-document") {
+      if (!operand) throw new CurlError(2, "Output filename must not be empty");
+      result.output = operand;
+      result.remoteName = false;
+    } else if (flag === "--directory-prefix") result.outputDirectory = operand;
+    else if (flag === "--input-file") inputFile = operand;
+    else if (flag === "--timeout") {
+      const seconds = number(operand, false);
+      result.maxTimeMs = Math.min(seconds === 0 ? Infinity : seconds * 1e3, limits.maxTimeMs);
+    } else if (flag === "--tries") {
+      const tries = number(operand, true);
+      result.retries = tries === 0 ? limits.maxRetries : Math.min(tries - 1, limits.maxRetries);
+    } else if (flag === "--header") {
+      if (operand === "") {
+        headers.clear();
+        continue;
+      }
+      const colon = operand.indexOf(":");
+      if (colon < 1) throw new CurlError(2, "Invalid HTTP header");
+      const name = operand.slice(0, colon);
+      const value = operand.slice(colon + 1).trim();
+      validateRequestHeader(name, value);
+      headers.set(name.toLowerCase(), [name, value]);
+    } else if (flag === "--user-agent") {
+      validateRequestHeader("User-Agent", operand);
+      agent = operand;
+    } else if (flag === "--referer") {
+      validateRequestHeader("Referer", operand);
+      referer = operand;
+    } else if (flag === "--method") {
+      try {
+        validateHeaderName(operand);
+      } catch {
+        throw new CurlError(2, "Invalid or unsupported HTTP method");
+      }
+      result.method = operand.toUpperCase();
+      if (["CONNECT", "TRACE"].includes(result.method)) throw new CurlError(2, "Invalid or unsupported HTTP method");
+    } else {
+      const bodyFlag = flag;
+      if (bodyFlag.endsWith("-file") && !operand) throw new CurlError(2, "Upload filename must not be empty");
+      bodies[bodyFlag] = operand;
+    }
+  }
+  if (agent !== void 0 && !headers.has("user-agent")) result.headers.push(["User-Agent", agent === "" ? null : agent]);
+  if (referer !== void 0 && !headers.has("referer")) result.headers.push(["Referer", referer]);
+  result.headers.push(...headers.values());
+  const post = bodies["--post-data"] !== void 0 || bodies["--post-file"] !== void 0;
+  const customBody = bodies["--body-data"] !== void 0 || bodies["--body-file"] !== void 0;
+  if (post && result.method !== void 0 || customBody && result.method === void 0 || bodies["--post-data"] !== void 0 && bodies["--post-file"] !== void 0 || bodies["--body-data"] !== void 0 && bodies["--body-file"] !== void 0) {
+    throw new CurlError(2, "Incompatible request body options: use --post-data or --post-file, or --method with --body-data or --body-file");
+  }
+  const data = bodies["--post-data"] ?? bodies["--body-data"];
+  const file = bodies["--post-file"] ?? bodies["--body-file"];
+  if (data !== void 0) result.data.push({ kind: "raw", value: data });
+  else if (file !== void 0) result.data.push({ kind: "binary", value: `@${file === "-" ? "./-" : file}` });
+  if (!result.help && !result.version) {
+    if (inputFile !== void 0) {
+      let bytes;
+      try {
+        bytes = inputFile === "-" ? await collectBytes(context.stdin, { signal: context.signal, maxBytes: limits.maxBufferBytes }) : await context.fs.readFile(pathOf(context, inputFile), { signal: context.signal, ...Number.isFinite(limits.maxBufferBytes) ? { maxBytes: limits.maxBufferBytes } : {} });
+      } catch {
+        context.signal.throwIfAborted();
+        throw new CurlError(26, "Failed reading virtual URL input file");
+      }
+      let text;
+      try {
+        text = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+      } catch {
+        throw new CurlError(2, "URL input must be valid UTF-8");
+      }
+      let start = 0;
+      let lines = 0;
+      for (let index = 0; index <= text.length; index++) {
+        if (index % 1024 === 0) await yieldTurn(context.signal);
+        if (index !== text.length && text[index] !== "\n") continue;
+        if (index === text.length && start === index) break;
+        if (++lines > 4096) throw new CurlError(2, "URL input exceeds 4096-line limit");
+        const url = text.slice(start, index).trim();
+        start = index + 1;
+        if (url) result.urls.push(url);
+        if (result.urls.length > limits.maxUrls) throw new CurlError(2, "URL count exceeds host limit");
+      }
+    }
+    if (!result.urls.length) throw new CurlError(2, "An HTTP(S) URL is required");
+    if (result.urls.length > limits.maxUrls) throw new CurlError(2, "URL count exceeds host limit");
+    if (result.download.resume && result.download.noClobber) throw new CurlError(2, "Continue and no-clobber are incompatible");
+    if (result.output === "-" && (result.download.resume || result.download.noClobber)) throw new CurlError(2, "Download controls require a file output");
+  }
+  return result;
+}
+function createWgetCommand(options = {}) {
+  return createTransferCommand(options, {
+    name: "wget",
+    parse: parseWget,
+    help: "Usage: wget [-O FILE|-] [-q|-nv] [-T SECONDS] [-t COUNT] [URL ...]\nDownloads: --spider | -c/--continue | -nc/--no-clobber | -P/--directory-prefix DIR | --content-disposition\nInput: -i/--input-file FILE (VFS URL list; '-' reads stdin)\nRequest headers: --header 'NAME: VALUE' | --user-agent AGENT | --referer URL\nRequest bodies: --post-data DATA | --post-file FILE | --method METHOD [--body-data DATA | --body-file FILE]\nBody files are read from the VFS. Downloads require explicit host authorization. Recursive mirroring is unsupported.\nTimeout (--timeout) is aggregate and host-capped; --tries=0 remains host-capped.\n",
+    version: "virtual-bash wget 0.0 (bounded HTTP HTTPS)\n",
+    status: (code) => code === 0 ? 0 : [1, 2, 3].includes(code) ? 2 : [23, 26].includes(code) ? 3 : code === 60 ? 5 : code === 22 ? 8 : 4
+  });
+}
+
+export {
+  createWgetCommand
+};

package/dist/safe-bash/command-chunks/{chunk-4ONEXMD3.js → chunk-EUSPTFAX.js}

@@ -49,7 +49,7 @@ import {
 } from "./chunk-DWFLVJC6.js";
 import {
   createZipCodec
-} from "./chunk-MKQVQMXO.js";
+} from "./chunk-5LU4UCBR.js";
 import {
   CodecError,
   createCompressionCodec

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

@@ -0,0 +1,97 @@
+import {
+  CurlError,
+  defaultNetworkLimits
+} from "./chunk-IYPAQ7PH.js";
+import {
+  scheduleNetworkDeadline
+} from "./chunk-KWESKQHR.js";
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-network-engine/src/shared.ts
+init_buffer();
+import { collectBytes, readBytes } from "../../safe-bash-contracts/index.js";
+import { writeDiagnostic } from "../../safe-bash-contracts/escaping.js";
+var encode = (text) => new TextEncoder().encode(text);
+function limitsFor(overrides = {}) {
+  const result = { ...defaultNetworkLimits, ...overrides };
+  for (const [name, value] of Object.entries(overrides)) {
+    const minimum = name === "maxRedirects" || name === "maxRetries" ? 0 : 1;
+    if (value !== Infinity && (!Number.isSafeInteger(value) || value < minimum)) {
+      throw new RangeError(`Invalid network limit: ${name}`);
+    }
+  }
+  return Object.freeze(result);
+}
+async function withSignal(operation, signal) {
+  signal.throwIfAborted();
+  return new Promise((resolve, reject) => {
+    const onAbort = () => {
+      cleanup();
+      reject(signal.reason);
+    };
+    const cleanup = () => signal.removeEventListener("abort", onAbort);
+    signal.addEventListener("abort", onAbort, { once: true });
+    Promise.resolve().then(operation).then((value) => {
+      cleanup();
+      resolve(value);
+    }, (error) => {
+      cleanup();
+      reject(error);
+    });
+  });
+}
+async function delay(milliseconds, signal) {
+  let cancel;
+  try {
+    await withSignal(() => new Promise((resolve) => {
+      cancel = scheduleNetworkDeadline(milliseconds, resolve);
+    }), signal);
+  } finally {
+    cancel?.();
+  }
+}
+function header(headers, name) {
+  return headers.find(([key]) => key.toLowerCase() === name.toLowerCase())?.[1];
+}
+function networkError(error) {
+  if (error instanceof CurlError) return error;
+  const code = error && typeof error === "object" && "code" in error ? String(error.code) : "";
+  if (["ENOTFOUND", "EAI_AGAIN"].includes(code)) return new CurlError(6, "Could not resolve host");
+  if (["ECONNREFUSED", "ENETUNREACH", "EHOSTUNREACH"].includes(code)) return new CurlError(7, "Failed to connect");
+  if (/CERT|SELF_SIGNED|UNABLE_TO_VERIFY/.test(code)) return new CurlError(60, "TLS certificate verification failed");
+  if (/TLS|SSL/.test(code)) return new CurlError(35, "TLS handshake failed");
+  return new CurlError(56, "Network transfer failed");
+}
+async function diagnostic(context, error) {
+  await writeDiagnostic(context.stderr, `${context.command}: (${error.exitCode}) ${error.message}
+`, context.signal);
+}
+async function collectNetworkBytes(source, options) {
+  if (Number.isFinite(options.maxBytes)) return collectBytes(source, options);
+  const chunks = [];
+  let size = 0;
+  for await (const chunk of readBytes(source, options.signal)) {
+    chunks.push(new Uint8Array(chunk));
+    size += chunk.length;
+  }
+  const bytes = new Uint8Array(size);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return bytes;
+}
+
+export {
+  encode,
+  limitsFor,
+  withSignal,
+  delay,
+  header,
+  networkError,
+  diagnostic,
+  collectNetworkBytes
+};

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

@@ -0,0 +1,195 @@
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-patch/src/sync.ts
+init_buffer();
+import { gnuInformationSync } from "../../safe-bash-io-engine/gnu-information.js";
+import { encoder } from "../../safe-bash-io-engine/internal.js";
+var syncDiffDecoder = new TextDecoder("utf-8", { fatal: false });
+function evalSyncPatch(inBytes, opArgs, readFileSync, writeFileSync) {
+  const gnuInfo = gnuInformationSync("patch", opArgs);
+  if (gnuInfo !== void 0) return gnuInfo;
+  if (!readFileSync || !writeFileSync) return void 0;
+  let strip;
+  let quiet = false;
+  let reverse = false;
+  let dryRun = false;
+  let outputPath;
+  let inputPath;
+  let ended = false;
+  const operands = [];
+  for (let i = 0; i < opArgs.length; i++) {
+    const a = opArgs[i];
+    if (ended || !a.startsWith("-") || a === "-") {
+      operands.push(a);
+      continue;
+    }
+    if (a === "--") {
+      ended = true;
+      continue;
+    }
+    if (a === "-s" || a === "--quiet" || a === "--silent") {
+      quiet = true;
+      continue;
+    }
+    if (a === "-R" || a === "--reverse") {
+      reverse = true;
+      continue;
+    }
+    if (a === "--dry-run") {
+      dryRun = true;
+      continue;
+    }
+    if (a === "-N" || a === "--forward" || a === "-f" || a === "--force" || a === "-t" || a === "--batch" || a === "-u" || a === "--unified") {
+      continue;
+    }
+    if (a === "-o" || a === "--output") {
+      outputPath = opArgs[++i];
+      if (!outputPath) return void 0;
+      continue;
+    }
+    if (a.startsWith("-o") && a.length > 2) {
+      outputPath = a.slice(2);
+      continue;
+    }
+    if (a.startsWith("--output=")) {
+      outputPath = a.slice(9);
+      if (!outputPath) return void 0;
+      continue;
+    }
+    if (a === "-p" || a === "--strip") {
+      const v = opArgs[++i];
+      if (!v || !/^\d+$/.test(v)) return void 0;
+      strip = Number(v);
+      continue;
+    }
+    if (a.startsWith("-p") && /^\d+$/.test(a.slice(2))) {
+      strip = Number(a.slice(2));
+      continue;
+    }
+    if (a.startsWith("--strip=") && /^\d+$/.test(a.slice(8))) {
+      strip = Number(a.slice(8));
+      continue;
+    }
+    if (a === "-i" || a === "--input") {
+      inputPath = opArgs[++i];
+      if (!inputPath) return void 0;
+      continue;
+    }
+    if (a.startsWith("--input=")) {
+      inputPath = a.slice(8);
+      continue;
+    }
+    return void 0;
+  }
+  if (operands.length > 2) return void 0;
+  const targetArg = operands[0];
+  const patchFileArg = inputPath ?? operands[1];
+  const patchBytes = patchFileArg && patchFileArg !== "-" ? readFileSync(patchFileArg) : inBytes;
+  if (!patchBytes || patchBytes.includes(0)) return void 0;
+  const patchText = syncDiffDecoder.decode(patchBytes);
+  const lines = patchText.split("\n");
+  let headerOld;
+  let headerNew;
+  let idx = 0;
+  while (idx < lines.length && !lines[idx].startsWith("@@ ")) {
+    if (lines[idx].startsWith("--- ")) {
+      headerOld = lines[idx].slice(4).split("	")[0].trim();
+    } else if (lines[idx].startsWith("+++ ")) {
+      headerNew = lines[idx].slice(4).split("	")[0].trim();
+    }
+    idx++;
+  }
+  if (idx >= lines.length) return void 0;
+  let resolvedTarget = targetArg;
+  if (!resolvedTarget) {
+    const hdr = headerNew && headerNew !== "/dev/null" ? headerNew : headerOld;
+    if (!hdr || hdr === "/dev/null") return void 0;
+    if (strip !== void 0) {
+      const parts = hdr.split("/");
+      if (parts.length <= strip) return void 0;
+      resolvedTarget = parts.slice(strip).join("/");
+    } else {
+      resolvedTarget = hdr.split("/").pop() || hdr;
+    }
+  }
+  if (!resolvedTarget) return void 0;
+  const origBytes = readFileSync(resolvedTarget);
+  if (origBytes && origBytes.includes(0)) return void 0;
+  const isNewFile = !origBytes && (reverse ? headerNew === "/dev/null" : headerOld === "/dev/null");
+  if (!origBytes && !isNewFile) return void 0;
+  const origText = origBytes ? syncDiffDecoder.decode(origBytes) : "";
+  let hasTrailingNewline = origText === "" ? true : origText.endsWith("\n");
+  const origLines = origText === "" ? [] : origText.endsWith("\n") ? origText.slice(0, -1).split("\n") : origText.split("\n");
+  const outLines = [];
+  let origPos = 0;
+  let lastHunkOp = " ";
+  while (idx < lines.length) {
+    const line = lines[idx];
+    if (!line.startsWith("@@ ")) {
+      if (line === "") {
+        idx++;
+        continue;
+      }
+      return void 0;
+    }
+    const m = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/.exec(line);
+    if (!m) return void 0;
+    const startLineNum = Number(reverse ? m[3] : m[1]);
+    const oldStart = startLineNum === 0 ? 0 : startLineNum - 1;
+    if (oldStart < origPos || oldStart > origLines.length) return void 0;
+    while (origPos < oldStart) outLines.push(origLines[origPos++]);
+    idx++;
+    while (idx < lines.length && !lines[idx].startsWith("@@ ")) {
+      const hl = lines[idx];
+      if (hl === "" && idx === lines.length - 1) {
+        idx++;
+        break;
+      }
+      const rawPrefix = hl[0];
+      const prefix = reverse ? rawPrefix === "+" ? "-" : rawPrefix === "-" ? "+" : rawPrefix : rawPrefix;
+      const body = hl.slice(1);
+      if (prefix === " ") {
+        if (origLines[origPos] !== body) return void 0;
+        outLines.push(body);
+        origPos++;
+        lastHunkOp = " ";
+      } else if (prefix === "-") {
+        if (origLines[origPos] !== body) return void 0;
+        origPos++;
+        if (origPos === origLines.length) hasTrailingNewline = true;
+        lastHunkOp = "-";
+      } else if (prefix === "+") {
+        outLines.push(body);
+        if (origPos === origLines.length) hasTrailingNewline = true;
+        lastHunkOp = "+";
+      } else if (hl.startsWith("\\ No newline")) {
+        if (lastHunkOp === "+" || lastHunkOp === " " && origPos === origLines.length) {
+          hasTrailingNewline = false;
+        }
+      } else {
+        return void 0;
+      }
+      idx++;
+    }
+  }
+  while (origPos < origLines.length) outLines.push(origLines[origPos++]);
+  const resultText = outLines.length === 0 ? "" : outLines.join("\n") + (hasTrailingNewline ? "\n" : "");
+  if (outputPath === "-") {
+    return resultText;
+  }
+  const destPath = outputPath ?? resolvedTarget;
+  if (!dryRun && outputPath !== "/dev/null") {
+    if (!writeFileSync(destPath, encoder.encode(resultText), false)) return void 0;
+  }
+  if (quiet) return "";
+  const verb = dryRun ? "checking" : "patching";
+  const label = outputPath !== void 0 ? `${outputPath} (read from ${resolvedTarget})` : resolvedTarget;
+  return `${verb} file ${label}
+`;
+}
+
+export {
+  evalSyncPatch
+};

package/dist/safe-bash/command-chunks/{chunk-HLMUPSM6.js → chunk-GI4CJED2.js}

@@ -1,12 +1,12 @@
 import {
   describe
-} from "./chunk-PRCT7FKJ.js";
+} from "./chunk-UMDIOL3O.js";
 import {
   JqError,
   JqLimitError,
   object,
   put
-} from "./chunk-AC6X7Q4I.js";
+} from "./chunk-QP4R6GLA.js";
 import {
   init_buffer
 } from "./chunk-HX3SHTCE.js";
@@ -93,5 +93,6 @@ async function* capture(input, pattern, modifiers, budget) {
 }
 
 export {
+  extendedPattern,
   capture
 };