@poe-platform/safe-bash 0.1.799 → 0.1.800

package/dist/safe-bash/command-chunks/{chunk-X2YQLGKS.js → chunk-SAMH7SQE.js}

@@ -1,9 +1,9 @@
-import {
-  parseRustPattern
-} from "./chunk-T5H5UJQ3.js";
 import {
   ReplacementBuffer
 } from "./chunk-N2F74VRO.js";
+import {
+  parseRustPattern
+} from "./chunk-T5H5UJQ3.js";
 import {
   ProgramError
 } from "./chunk-HLGKIZ25.js";
@@ -767,7 +767,7 @@ var Pattern = class {
             budget.step();
             groups.push(captures[index * 2] === void 0 ? void 0 : text.slice(captures[index * 2], captures[index * 2 + 1]));
           }
-          return { match: { start: matchStart, end: position, groups }, captures };
+          return { match: { start: matchStart, end: position, groups, captureOffsets: captures }, captures };
         }
         if (instruction.kind === "conditional") {
           const result = await this.findJq(text, budget, position, { pc: instruction.first, exact: true, captures, continuation });

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

@@ -0,0 +1,11 @@
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-zip-engine/src/zip/grow.ts
+init_buffer();
+var zipGrowRecords = /* @__PURE__ */ new WeakMap();
+
+export {
+  zipGrowRecords
+};

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

@@ -0,0 +1,634 @@
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-curl/src/curl.ts
+init_buffer();
+import { createOutputOperation, FsError, readBytes, toByteSource, writeBytes } from "../../safe-bash-contracts/index.js";
+import { normalizePath, posixPath as posix } from "../../safe-bash-contracts/path.js";
+import { inheritYieldCheckpoint, yieldTurn } from "../../safe-bash-contracts/yield.js";
+import { byteLength, decodeBytes, encodeBytes } from "../../safe-bash-io-engine/byte-encoding.js";
+import { builtInDirectContextExecutors, pathOf } from "../../safe-bash-io-engine/internal.js";
+import { createDeadlineOutput, deadlineDiagnostic } from "../../safe-bash-network-engine/aggregate.js";
+import { validateRequestHeader } from "../../safe-bash-network-engine/args.js";
+import { createBody, queryData } from "../../safe-bash-network-engine/body.js";
+import { scheduleNetworkDeadline } from "../../safe-bash-network-engine/deadline.js";
+import { decodeContent } from "../../safe-bash-network-engine/decode.js";
+import { expandUrls, globFilename } from "../../safe-bash-network-engine/glob.js";
+import { parseCurlInput } from "../../safe-bash-network-engine/input.js";
+import { dumpHeaders, responseHeaders, writeOutFormat, writeOutput } from "../../safe-bash-network-engine/output.js";
+import { createDefaultHttpTransport, requiresFiniteUrlLimits } from "../../safe-bash-network-engine/platform-portable.js";
+import { collectNetworkBytes as collectBytes, delay, diagnostic, encode, header, limitsFor, networkError, withSignal } from "../../safe-bash-network-engine/shared.js";
+import { CurlError } from "../../safe-bash-network-engine/types.js";
+import { curlRequestTarget } from "../../safe-bash-network-engine/url.js";
+var retryStatuses = /* @__PURE__ */ new Set([408, 429, 500, 502, 503, 504]);
+var redirectStatuses = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
+var writeOutDefaults = Object.freeze({
+  http_code: "000",
+  response_code: "000",
+  url_effective: "",
+  redirect_url: "",
+  content_type: "",
+  size_download: "0",
+  size_upload: "0",
+  num_redirects: "0",
+  num_retries: "0",
+  time_total: "0.000000",
+  exitcode: "0",
+  errormsg: "",
+  filename_effective: "",
+  method: "GET",
+  http_version: ""
+});
+function parseUrl(text, redirect = false) {
+  if (/[\s\x00-\x1f\x7f]/.test(text)) throw new CurlError(3, "Malformed URL");
+  let url;
+  try {
+    url = new URL(text);
+  } catch {
+    throw new CurlError(3, "Malformed URL; explicit HTTP(S) scheme required");
+  }
+  if (!["http:", "https:"].includes(url.protocol)) throw new CurlError(1, "Only HTTP and HTTPS are supported");
+  if (!url.hostname) throw new CurlError(3, "Malformed URL");
+  let user;
+  if (url.username || url.password) {
+    if (redirect) throw new CurlError(3, "Redirect URLs may not supply credentials");
+    try {
+      user = `${decodeURIComponent(url.username)}:${decodeURIComponent(url.password)}`;
+    } catch {
+      throw new CurlError(3, "Malformed URL credentials");
+    }
+    url.username = "";
+    url.password = "";
+  }
+  url.hash = "";
+  return { url, ...user === void 0 ? {} : { user } };
+}
+function requestHeaders(args, contentType, user, scoped, maxBytes, previous) {
+  const json = args.data[0]?.kind === "json";
+  if (json) contentType = "application/json";
+  const defaults = [["Accept", json ? "application/json" : "*/*"], ["User-Agent", args.agent ?? "virtual-bash-curl/0.0"]];
+  if (contentType !== void 0) defaults.push(["Content-Type", contentType]);
+  if (args.compressed) defaults.push(["Accept-Encoding", "gzip, deflate"]);
+  const referer = args.autoReferer && previous !== void 0 ? previous : args.referer;
+  if (referer) {
+    validateRequestHeader("Referer", referer);
+    defaults.push(["Referer", referer]);
+  }
+  if (scoped && args.etag !== void 0) defaults.push(["If-None-Match", args.etag]);
+  if (args.range !== void 0) defaults.push(["Range", `bytes=${args.range}`]);
+  if (scoped && user !== void 0) defaults.push(["Authorization", `Basic ${decodeBytes(encodeBytes(user), "base64")}`]);
+  if (scoped && args.bearer !== void 0) {
+    if (/[\r\n\0]/.test(args.bearer)) throw new CurlError(2, "Invalid bearer token");
+    defaults.push(["Authorization", `Bearer ${args.bearer}`]);
+  }
+  const custom = scoped ? args.headers : [];
+  const names = new Set(custom.map(([name]) => name.toLowerCase()));
+  const result = [
+    ...defaults.filter(([name]) => !names.has(name.toLowerCase())),
+    ...custom.filter((entry) => entry[1] !== null)
+  ];
+  if (result.reduce((size, [name, value]) => size + byteLength(name + value) + 4, 0) > maxBytes) {
+    throw new CurlError(63, "Request headers exceed host byte limit");
+  }
+  return result;
+}
+async function stop(response, signal) {
+  if (!response) return;
+  const cleanup = Promise.resolve().then(() => response.dispose());
+  void cleanup.catch(() => {
+  });
+  if (!signal.aborted) await withSignal(() => cleanup, signal).catch(() => {
+  });
+}
+function pipeClosed(error) {
+  return error instanceof Error && "code" in error && error.code === "EPIPE";
+}
+function remoteFilename(url) {
+  if (url.pathname === "/") return "curl_response";
+  const name = posix.basename(url.pathname);
+  if (!name || name === "/" || name === "." || name === "..") throw new CurlError(23, "URL has no safe remote filename");
+  return name;
+}
+async function existingSize(context, output, signal) {
+  try {
+    return (await context.fs.stat(pathOf(context, output), { signal })).size;
+  } catch (error) {
+    signal.throwIfAborted();
+    if (error instanceof FsError && error.code === "ENOENT") return void 0;
+    throw new CurlError(23, "Failed inspecting virtual output file");
+  }
+}
+function createCurlCommand(options = {}) {
+  return createTransferCommand(options, {
+    name: "curl",
+    help: "Usage: curl [HTTP(S) URL] [-X METHOD] [-H HEADER] [-d DATA] [-L] [-o VFSFILE]\nExplicit host authorization is required. See network/README.md for supported flags and limits.\n",
+    version: "virtual-bash curl 0.0 (HTTP HTTPS; Node streaming transport)\n",
+    parse: parseCurlInput,
+    status: (code) => code
+  });
+}
+function createTransferCommand(options, profile) {
+  if (options.authorize !== void 0 && typeof options.authorize !== "function") throw new TypeError(`${profile.name} requires an explicit network authorizer`);
+  const limits = limitsFor(options.limits);
+  if (requiresFiniteUrlLimits && (!Number.isFinite(limits.maxUrls) || !Number.isFinite(limits.maxBufferBytes))) {
+    throw new TypeError("Portable network commands require finite maxUrls and maxBufferBytes limits");
+  }
+  const transport = options.transport ?? createDefaultHttpTransport();
+  if (typeof transport !== "function") throw new TypeError("Invalid HTTP transport");
+  const authorize = options.authorize ?? (() => false);
+  const executions = /* @__PURE__ */ new WeakMap();
+  const def = {
+    name: profile.name,
+    async execute(context) {
+      context.signal.throwIfAborted();
+      const scope = context.executionScope ?? {};
+      let started = executions.get(scope) ?? performance.now();
+      const parsing = new AbortController();
+      const parsingSignal = AbortSignal.any([context.signal, parsing.signal]);
+      inheritYieldCheckpoint(context.signal, parsingSignal);
+      const cancelParsingDeadline = scheduleNetworkDeadline(
+        limits.maxTotalTimeMs - (performance.now() - started),
+        () => parsing.abort(new CurlError(28, "Operation timed out"))
+      );
+      let args;
+      let expanded;
+      try {
+        if (context.args.reduce((size, value) => size + byteLength(value), 0) > limits.maxBufferBytes) throw new CurlError(2, "Arguments exceed host buffer limit");
+        args = await withSignal(() => profile.parse({ ...context, signal: parsingSignal }, limits), parsingSignal);
+        parsingSignal.throwIfAborted();
+        if (performance.now() - started >= limits.maxTotalTimeMs) throw new CurlError(28, "Operation timed out");
+        if (args.help || args.version) {
+          await writeBytes(context.stdout, encode(args.version ? profile.version : profile.help), context.signal);
+          return { exitCode: 0 };
+        }
+        if (args.connectTimeoutMs !== void 0 && transport.supportsConnectTimeout !== true) {
+          throw new CurlError(2, "Transport cannot enforce connection timeout");
+        }
+        if (args.caFile !== void 0 && transport.supportsRequestCa !== true) {
+          throw new CurlError(2, "Transport cannot enforce request CA trust");
+        }
+        if (args.httpVersion !== void 0 && !transport.supportedHttpVersions?.includes(args.httpVersion)) {
+          throw new CurlError(2, "Transport cannot enforce requested HTTP version");
+        }
+        if (args.ignoreContentLength && transport.supportsIgnoreContentLength !== true) {
+          throw new CurlError(2, "Transport cannot enforce ignored Content-Length");
+        }
+        expanded = expandUrls(args.urls, args.globoff, limits);
+        for (const item of expanded) parseUrl(item.url);
+        if (!args.download) {
+          expanded = args.urls.flatMap((url, index) => expandUrls([url], args.globoff, limits).map((item) => ({ ...item, destination: args.outputs?.[index] ?? { remoteName: false } })));
+        }
+      } catch (error) {
+        context.signal.throwIfAborted();
+        const failure = error instanceof CurlError ? error : new CurlError(2, `Invalid ${profile.name} arguments`);
+        const reported = new CurlError(profile.status(failure.exitCode), failure.message);
+        if (failure.exitCode === 28) {
+          try {
+            await deadlineDiagnostic(context, reported, 0);
+          } catch (error2) {
+            context.signal.throwIfAborted();
+            if (!(error2 instanceof CurlError)) throw error2;
+          }
+        } else await diagnostic(context, reported);
+        return { exitCode: profile.status(failure.exitCode) };
+      } finally {
+        cancelParsingDeadline();
+      }
+      started = Math.min(started, executions.get(scope) ?? started);
+      executions.set(scope, started);
+      let exitCode = 0;
+      const headerState = { dumped: false };
+      for (const item of expanded) {
+        context.signal.throwIfAborted();
+        if (performance.now() - started >= limits.maxTotalTimeMs) {
+          const failure = new CurlError(28, "Operation timed out");
+          if (!args.silent || args.showError) {
+            try {
+              await deadlineDiagnostic(context, failure, 0);
+            } catch (error) {
+              context.signal.throwIfAborted();
+              if (!(error instanceof CurlError)) throw error;
+            }
+          }
+          return { exitCode: profile.status(failure.exitCode) };
+        }
+        const transferArgs = { ...args };
+        if (item.destination) {
+          delete transferArgs.output;
+          transferArgs.remoteName = item.destination.remoteName;
+          if (item.destination.output !== void 0) transferArgs.output = item.destination.output;
+        }
+        if (transferArgs.output !== void 0) transferArgs.output = globFilename(transferArgs.output, item.captures);
+        const code = await transfer(context, transferArgs, item.url, limits, transport, authorize, started, profile.status, headerState);
+        exitCode = args.download ? code || exitCode : code;
+      }
+      return { exitCode };
+    }
+  };
+  builtInDirectContextExecutors.add(def.execute);
+  return def;
+}
+async function transfer(context, args, input, limits, transport, authorize, started, status, headerState) {
+  const start = performance.now();
+  const remaining = () => Math.min(args.maxTimeMs - (performance.now() - start), limits.maxTotalTimeMs - (performance.now() - started));
+  const hasFileOutput = args.etagSave !== void 0 && args.etagSave !== "-" || args.remoteName || args.output !== void 0 && args.output !== "-" || args.dumpHeader !== void 0 && args.dumpHeader !== "-";
+  const operation = createDeadlineOutput(context, hasFileOutput ? { write: (chunk) => context.stdout.write(chunk) } : context.stdout, remaining());
+  const signal = operation.signal;
+  const borrowed = context.stdout.ownedOutput ? { [Symbol.asyncIterator]() {
+    const iterator = context.stdin[Symbol.asyncIterator]();
+    return { next: () => iterator.next() };
+  } } : context.stdin;
+  let response;
+  let failure;
+  const values = { ...writeOutDefaults };
+  let format = args.writeOut;
+  let formatReady = false;
+  let dumped = false;
+  let downloaded = 0;
+  let uploaded = 0;
+  let included = [];
+  let closedOutput = false;
+  const publish = async (bytes) => {
+    const writing = createDeadlineOutput(context, context.stdout, remaining());
+    try {
+      await writeBytes(writing.output, bytes, writing.signal);
+    } catch (error) {
+      context.signal.throwIfAborted();
+      if (!pipeClosed(error)) throw error;
+      closedOutput = true;
+    } finally {
+      await writing.close();
+    }
+  };
+  try {
+    if (args.etagCompare !== void 0) {
+      let bytes;
+      try {
+        bytes = await withSignal(() => context.fs.readFile(pathOf(context, args.etagCompare), { signal, ...Number.isFinite(limits.maxBufferBytes) ? { maxBytes: limits.maxBufferBytes } : {} }), signal);
+      } catch (error) {
+        signal.throwIfAborted();
+        if (!(error instanceof FsError && error.code === "ENOENT")) throw new CurlError(26, "Failed reading virtual ETag file");
+        bytes = new Uint8Array();
+      }
+      if (bytes.length > limits.maxBufferBytes) throw new CurlError(63, "ETag file exceeds host buffer limit");
+      const text = decodeBytes(encodeBytes(bytes), "latin1");
+      args.etag = text.split("\r").join("").split("\n").join("") || '""';
+      validateRequestHeader("If-None-Match", args.etag);
+    }
+    let ca;
+    if (args.caFile !== void 0) {
+      try {
+        const bytes = await withSignal(() => context.fs.readFile(pathOf(context, args.caFile), { signal, ...Number.isFinite(limits.maxBufferBytes) ? { maxBytes: limits.maxBufferBytes } : {} }), signal);
+        signal.throwIfAborted();
+        if (bytes.length > limits.maxBufferBytes) throw new CurlError(77, "CA certificate exceeds host buffer limit");
+        ca = new Uint8Array(bytes);
+      } catch {
+        signal.throwIfAborted();
+        throw new CurlError(77, "Failed reading virtual CA certificate file");
+      }
+    }
+    if (format?.startsWith("@")) {
+      try {
+        const bytes = format === "@-" ? await collectBytes(borrowed, { signal, maxBytes: limits.maxBufferBytes }) : await withSignal(() => context.fs.readFile(pathOf(context, format.slice(1)), { signal, ...Number.isFinite(limits.maxBufferBytes) ? { maxBytes: limits.maxBufferBytes } : {} }), signal);
+        format = decodeBytes(encodeBytes(bytes), "utf8");
+      } catch {
+        signal.throwIfAborted();
+        throw new CurlError(26, "Failed reading write-out format");
+      }
+    }
+    if (format !== void 0) {
+      writeOutFormat(format, values, limits.maxBufferBytes);
+      formatReady = true;
+    }
+    const parsed = parseUrl(input);
+    const initial = parsed.url;
+    const rawTarget = curlRequestTarget(input);
+    let initialTarget = rawTarget;
+    const initialSearch = initial.search;
+    if (args.query?.length) {
+      const queryArgs = { ...args, data: args.query };
+      delete queryArgs.upload;
+      const queryBody = createBody({ ...context, stdin: borrowed }, queryArgs, limits);
+      const encoded = await queryData(queryBody, signal, limits);
+      let query = "";
+      for (let index = 0; index < encoded.length; index++) {
+        const character = encoded[index];
+        if (character.charCodeAt(0) < 33 || character.charCodeAt(0) > 126) throw new CurlError(3, "Query data must be URL encoded");
+        if (character === "%" && index + 2 < encoded.length && "0123456789abcdefABCDEF".includes(encoded[index + 1]) && "0123456789abcdefABCDEF".includes(encoded[index + 2])) {
+          query += encoded.slice(index, index + 3).toLowerCase();
+          index += 2;
+        } else query += character;
+      }
+      initial.search += `${initial.search ? "&" : "?"}${query}`;
+    }
+    let body = createBody({ ...context, stdin: borrowed }, args, limits);
+    if (args.get && body) {
+      const query = await queryData(body, signal, limits);
+      if (/[^\x21-\x7e]/.test(query)) throw new CurlError(3, "GET data must be URL encoded");
+      initial.search += `${initial.search ? "&" : "?"}${query.replace(/%[0-9a-f]{2}/gi, (escape) => escape.toLowerCase())}`;
+      body = void 0;
+    }
+    if (initial.search !== initialSearch) initialTarget += initial.search.slice(initialSearch.length);
+    let output = args.remoteName ? args.directoryIndex && initial.pathname.endsWith("/") ? args.directoryIndex : remoteFilename(initial) : args.output;
+    if (args.outputDirectory !== void 0 && output !== void 0 && output !== "-" && (!args.download || args.remoteName)) {
+      output = `${args.outputDirectory}/${output}`;
+    }
+    values.filename_effective = output && output !== "-" ? output : "";
+    let resumeOffset = 0;
+    if (args.continueAt !== void 0) {
+      resumeOffset = args.continueAt === "auto" ? output && output !== "-" ? await existingSize(context, output, signal) ?? 0 : 0 : args.continueAt;
+    }
+    if (args.download && !args.download.spider && output && output !== "-") {
+      if (args.download.noClobber && !args.download.contentDisposition && await existingSize(context, output, signal) !== void 0) return 0;
+      if (args.download.resume) resumeOffset = await existingSize(context, output, signal) ?? 0;
+    }
+    if (output && output !== "-" && args.dumpHeader && args.dumpHeader !== "-" && normalizePath(pathOf(context, output)) === normalizePath(pathOf(context, args.dumpHeader))) {
+      throw new CurlError(23, "Body and header output files must differ");
+    }
+    const initialRequestMethod = args.head || args.download?.spider ? "HEAD" : args.get ? "GET" : args.upload !== void 0 ? "PUT" : body ? "POST" : "GET";
+    const initialMethod = args.method ?? initialRequestMethod;
+    requestHeaders(args, body?.contentType, args.user ?? parsed.user, true, limits.maxHeaderBytes);
+    attempts: for (let attempt = 0; attempt <= args.retries; attempt++) {
+      if (attempt && args.download?.resume && output && output !== "-") resumeOffset = await existingSize(context, output, signal) ?? 0;
+      values.num_retries = String(attempt);
+      downloaded = 0;
+      uploaded = 0;
+      failure = void 0;
+      let current = new URL(initial);
+      let currentUrl = current.origin + initialTarget;
+      let method = initialMethod;
+      let requestMethod = initialRequestMethod;
+      let currentBody = body;
+      let credentialsInScope = true;
+      let previous;
+      let redirects = 0;
+      included = [];
+      let headerBytes = 0;
+      while (true) {
+        signal.throwIfAborted();
+        if (remaining() <= 0) throw new CurlError(28, "Operation timed out");
+        values.url_effective = currentUrl;
+        values.method = method;
+        let denyPrivateNetworks = false;
+        let allowed;
+        try {
+          allowed = await withSignal(() => authorize({
+            url: currentUrl,
+            method,
+            attempt,
+            signal,
+            requirePrivateNetworkDeny() {
+              denyPrivateNetworks = true;
+            },
+            ...previous === void 0 ? {} : { redirectFrom: previous }
+          }), signal);
+        } catch {
+          signal.throwIfAborted();
+          throw new CurlError(7, "Network authorization failed");
+        }
+        if (remaining() <= 0) throw new CurlError(28, "Operation timed out");
+        if (allowed !== true) throw new CurlError(7, "Network access denied by host policy");
+        const policy = denyPrivateNetworks ? { denyPrivateNetworks: true } : {};
+        if (policy.denyPrivateNetworks && transport.supportsPrivateNetworkDeny !== true) {
+          throw new CurlError(7, "Transport cannot enforce private network policy");
+        }
+        const headers = requestHeaders(resumeOffset ? { ...args, range: `${resumeOffset}-` } : args, currentBody?.contentType, args.user ?? parsed.user, credentialsInScope, limits.maxHeaderBytes, previous);
+        if (args.verbose) await writeBytes(context.stderr, encode(`> ${method} ${current.origin}
+${headers.map(([name]) => `> ${name}: [redacted]
+`).join("")}`), signal);
+        const upload = currentBody && (async function* () {
+          for await (const chunk of currentBody.open(signal)) {
+            uploaded += chunk.length;
+            yield chunk;
+          }
+        })();
+        try {
+          response = await operation.acquire(async () => {
+            const acquired = await transport({
+              url: currentUrl,
+              method,
+              headers,
+              signal,
+              responseBodyMode: args.download && method === "HEAD" || args.head || args.download?.spider ? "omit" : args.fail ? "omit-on-http-error" : "read",
+              ...args.httpVersion === void 0 ? {} : { httpVersion: args.httpVersion },
+              ...args.ignoreContentLength ? { ignoreContentLength: true } : {},
+              registerCleanup: operation.registerCleanup,
+              ...policy,
+              ...upload ? { body: upload } : {},
+              ...ca === void 0 ? {} : { ca },
+              ...args.connectTimeoutMs === void 0 ? {} : { connectTimeoutMs: args.connectTimeoutMs }
+            });
+            let cleanup;
+            return { ...acquired, dispose() {
+              cleanup ??= Promise.resolve().then(() => acquired.dispose());
+              return cleanup;
+            } };
+          }, (result) => result.dispose());
+        } catch (error) {
+          signal.throwIfAborted();
+          const code = error && typeof error === "object" && "code" in error ? error.code : void 0;
+          if (args.retryTransport && (code === "ECONNRESET" || code === "ETIMEDOUT" || code === "EPIPE") && attempt < args.retries) {
+            await delay(args.retryDelayMs || Math.min(1e3 * 2 ** attempt, 6e5), signal);
+            continue attempts;
+          }
+          throw error;
+        }
+        const block = responseHeaders(response, limits.maxHeaderBytes);
+        headerBytes += block.length;
+        if (headerBytes > limits.maxHeaderBytes) throw new CurlError(63, "Combined response headers exceed host byte limit");
+        values.http_code = values.response_code = String(response.status).padStart(3, "0");
+        values.content_type = header(response.headers, "content-type") ?? "";
+        values.http_version = response.httpVersion ?? "1.1";
+        if (args.verbose) await writeBytes(context.stderr, encode(`< HTTP ${response.status}
+`), signal);
+        if (args.dumpHeader !== void 0) {
+          if (args.dumpHeader === "-") await publish(block);
+          else {
+            await dumpHeaders(context, args.dumpHeader, block, dumped || headerState.dumped, signal);
+            headerState.dumped = true;
+          }
+          dumped = true;
+        }
+        if (args.etagSave !== void 0) {
+          const tag = header(response.headers, "etag");
+          const bytes = tag === void 0 ? new Uint8Array() : new Uint8Array(encodeBytes(`${tag}
+`, "latin1"));
+          if (args.etagSave === "-") await publish(bytes);
+          else await writeOutput(context, args.etagSave, toByteSource(bytes), signal);
+        }
+        if (args.head || args.include) included.push(block);
+        const location = header(response.headers, "location");
+        if (redirectStatuses.has(response.status) && location !== void 0) {
+          let target;
+          let targetUrl;
+          try {
+            const base = currentUrl.split("?")[0];
+            const colon = location.indexOf(":");
+            const boundary = [...location].findIndex((character) => "/?#".includes(character));
+            const resolved = colon >= 0 && (boundary < 0 || colon < boundary) ? location : location.startsWith("//") ? current.protocol + location : location.startsWith("/") ? current.origin + location : location.startsWith("?") ? base + location : location.startsWith("#") || location === "" ? currentUrl + location : base.slice(0, base.lastIndexOf("/") + 1) + location;
+            target = parseUrl(resolved, true).url;
+            targetUrl = target.origin + curlRequestTarget(resolved);
+          } catch (error) {
+            if (error instanceof CurlError) throw error;
+            throw new CurlError(3, "Malformed redirect URL");
+          }
+          values.redirect_url = targetUrl;
+          if (args.location) {
+            if (redirects++ >= args.maxRedirects) throw new CurlError(47, "Maximum redirects exceeded");
+            if (current.protocol === "https:" && target.protocol === "http:") throw new CurlError(1, "HTTPS-to-HTTP redirects are disabled");
+            if (target.origin !== current.origin) credentialsInScope = false;
+            if (response.status === 303 && method !== "HEAD" || [301, 302].includes(response.status) && requestMethod === "POST") {
+              currentBody = void 0;
+              requestMethod = "GET";
+              if (args.method === void 0) method = "GET";
+            }
+            previous = currentUrl;
+            current = target;
+            currentUrl = targetUrl;
+            values.num_redirects = String(redirects);
+            await stop(response, signal);
+            response = void 0;
+            continue;
+          }
+        }
+        break;
+      }
+      if (!response) throw new CurlError(56, "No HTTP response");
+      if (args.download?.contentDisposition && args.remoteName) {
+        const disposition = header(response.headers, "content-disposition");
+        const parameter = disposition?.split(";").map((part) => part.trim()).find((part) => part.slice(0, part.indexOf("=")).toLowerCase() === "filename");
+        if (parameter) {
+          let filename = parameter.slice(parameter.indexOf("=") + 1).trim();
+          if (filename.startsWith('"') && filename.endsWith('"')) filename = filename.slice(1, -1);
+          filename = posix.basename(filename.split("\\").join("/"));
+          if (filename && filename !== "." && filename !== ".." && !filename.includes("\0")) output = args.outputDirectory === void 0 ? filename : `${args.outputDirectory}/${filename}`;
+        }
+      }
+      if (args.download?.noClobber && output && output !== "-" && await existingSize(context, output, signal) !== void 0) return 0;
+      let append = false;
+      if (resumeOffset && response.status === 206) {
+        const range = header(response.headers, "content-range") ?? "";
+        if (!range.startsWith(`bytes ${resumeOffset}-`)) throw new CurlError(args.continueAt === void 0 ? 56 : 33, "Invalid resume Content-Range");
+        append = true;
+      }
+      if (resumeOffset && response.status === 416) {
+        if (header(response.headers, "content-range") === `bytes */${resumeOffset}`) return 0;
+      }
+      if (resumeOffset && args.continueAt !== void 0 && !append) throw new CurlError(33, "Server does not support resuming this transfer");
+      if (response.status >= 400 && (args.fail || args.failWithBody)) failure = new CurlError(22, `HTTP response status ${response.status}`);
+      const suppressBody = response.status === 304 || args.fail && failure !== void 0;
+      const readBody = !(args.download && method === "HEAD") && !args.head && !suppressBody;
+      let published = 0;
+      if (!args.download?.spider && (!suppressBody || included.length)) {
+        if (args.download && output && output !== "-") await context.fs.mkdir(posix.dirname(pathOf(context, output)), { recursive: true, signal });
+        const length = args.ignoreContentLength ? void 0 : header(response.headers, "content-length");
+        if (readBody && length && /^\d+$/.test(length) && Number(length) > args.maxFileSize) throw new CurlError(63, "Response exceeds download byte limit");
+        const final = response;
+        const encoding = header(final.headers, "content-encoding");
+        const writing = output === void 0 || output === "-" ? createOutputOperation({ ...context, signal }, context.stdout) : void 0;
+        const bodySignal = writing?.signal ?? signal;
+        const source = (async function* () {
+          for (const bytes of included) {
+            published += bytes.length;
+            yield bytes;
+          }
+          if (readBody) {
+            if (args.raw && final.contentDecoded && encoding) throw new CurlError(61, "Transport cannot preserve encoded response bytes");
+            if (args.raw && header(final.headers, "transfer-encoding")) throw new CurlError(61, "Raw transfer encoding is unsupported by this transport");
+            let chunks = 0;
+            const encoded = (async function* () {
+              for await (const chunk of readBytes(final.body, bodySignal)) {
+                downloaded += chunk.length;
+                if (downloaded > args.maxFileSize) throw new CurlError(63, "Response exceeds download byte limit");
+                yield chunk;
+              }
+              if (!final.contentDecoded && length && /^\d+$/.test(length) && downloaded !== Number(length)) throw new CurlError(18, "Partial HTTP response body");
+            })();
+            const decoded = args.compressed && !args.raw && !final.contentDecoded && encoding ? decodeContent(encoded, encoding, bodySignal, args.maxFileSize) : encoded;
+            let outputBytes = 0;
+            try {
+              for await (const chunk of decoded) {
+                if (++chunks % 256 === 0) {
+                  await yieldTurn(context.signal);
+                  bodySignal.throwIfAborted();
+                }
+                outputBytes += chunk.length;
+                if (outputBytes > args.maxFileSize) throw new CurlError(63, "Decoded response exceeds download byte limit");
+                published += chunk.length;
+                yield chunk;
+              }
+            } catch (error) {
+              bodySignal.throwIfAborted();
+              if (!(error instanceof CurlError) && !final.contentDecoded && length && /^\d+$/.test(length) && downloaded < Number(length)) throw new CurlError(18, "Partial HTTP response body");
+              throw networkError(error);
+            }
+          }
+        })();
+        try {
+          await writeOutput(writing ? { ...context, stdout: writing.output } : context, output, source, bodySignal, append, args.failWithBody && failure !== void 0);
+        } catch (error) {
+          context.signal.throwIfAborted();
+          if (!pipeClosed(error)) throw error;
+          closedOutput = true;
+        } finally {
+          await writing?.close();
+        }
+      }
+      if (retryStatuses.has(response.status) && attempt < args.retries) {
+        if (failure && (!args.silent || args.showError)) await deadlineDiagnostic(context, new CurlError(status(failure.exitCode), failure.message), remaining());
+        const after = header(response.headers, "retry-after");
+        let wait = args.retryDelayMs || Math.min(1e3 * 2 ** attempt, 6e5);
+        if (after !== void 0) {
+          const parsed2 = /^\d+$/.test(after) ? Number(after) * 1e3 : Date.parse(after) - Date.now();
+          if (Number.isFinite(parsed2)) wait = Math.max(wait, parsed2);
+        }
+        await stop(response, signal);
+        response = void 0;
+        if (published && output !== void 0 && output !== "-" && !args.download?.resume) await writeOutput(context, output, toByteSource(""), signal);
+        await delay(Math.min(wait, limits.maxTimeMs), signal);
+        continue;
+      }
+      break;
+    }
+  } catch (error) {
+    if (context.signal.aborted) throw context.signal.reason;
+    if (pipeClosed(error)) closedOutput = true;
+    else if (!hasFileOutput && context.stdout.ownedOutput?.consumerClosed.aborted) failure = new CurlError(23, "Failed writing output");
+    else failure = signal.aborted && signal.reason instanceof CurlError ? signal.reason : networkError(error);
+  } finally {
+    try {
+      await operation.close();
+    } finally {
+      context.signal.throwIfAborted();
+    }
+  }
+  values.size_download = String(downloaded);
+  values.size_upload = String(uploaded);
+  values.time_total = ((performance.now() - start) / 1e3).toFixed(6);
+  values.exitcode = String(failure?.exitCode ?? 0);
+  values.errormsg = failure?.message ?? "";
+  if (format !== void 0 && formatReady) {
+    try {
+      await publish(writeOutFormat(format, values, limits.maxBufferBytes));
+    } catch (error) {
+      context.signal.throwIfAborted();
+      failure = error instanceof CurlError ? error : new CurlError(23, "Failed writing write-out result");
+    }
+  }
+  if (failure && (!args.silent || args.showError)) {
+    try {
+      await deadlineDiagnostic(context, new CurlError(status(failure.exitCode), failure.message), remaining());
+    } catch (error) {
+      context.signal.throwIfAborted();
+      if (!(error instanceof CurlError)) throw error;
+      failure = error;
+    }
+  }
+  return failure ? status(failure.exitCode) : closedOutput ? 141 : 0;
+}
+
+export {
+  createCurlCommand,
+  createTransferCommand
+};